diff --git a/client/dive-common/apispec.ts b/client/dive-common/apispec.ts
index 9ac26db83..d5b8ef232 100644
--- a/client/dive-common/apispec.ts
+++ b/client/dive-common/apispec.ts
@@ -149,6 +149,24 @@ interface FrameImage {
   timestamp?: number;
 }
 
+/** One metadata attachment loaded by a platform implementation. */
+interface FrameMetadataAttachmentText {
+  /** Preserved original name, falling back to the resolved item/path basename. */
+  name: string;
+  /** Present for a readable TXT/CSV attachment. */
+  text?: string;
+  /** Present when the selected locator could not be read. */
+  error?: string;
+}
+
+/** Complete normalized attachment response for one dataset. */
+interface FrameMetadataSourcesResponse {
+  /** Single-camera dataset attachment or multicamera parent attachment. */
+  shared?: FrameMetadataAttachmentText;
+  /** Camera-local attachments only, keyed by camera name. */
+  cameras: Record<string, FrameMetadataAttachmentText>;
+}
+
 export interface MultiCamImportFolderArgs {
   datasetName?: string; // Girder parent folder name (required on web)
   defaultDisplay: string; // In multicam the default camera to display
@@ -163,6 +181,8 @@ export interface MultiCamImportFolderArgs {
      * dataset's saved camera registration.
      */
     transformFile?: string;
+    /** Optional camera-local metadata attachment. */
+    metadataFile?: string;
     /** Per-camera media type when cameras differ (e.g. EO JPG + IR TIFF on web). */
     type?: 'image-sequence' | 'video' | 'large-image';
     /**
@@ -208,6 +228,10 @@ interface MediaImportResponse {
   globPattern: string;
   mediaConvertList: string[];
 }
+
+/** User-editable datasetInfo stored on the dataset's backing metadata object. */
+type DatasetInfoFields = Record<string, unknown>;
+
 /**
  * The parts of metadata a user should be able to modify.
  */
@@ -219,7 +243,7 @@ interface DatasetMetaMutable {
   imageEnhancements?: ImageEnhancements;
   attributes?: Readonly<Record<string, Attribute>>;
   attributeTrackFilters?: Readonly<Record<string, AttributeTrackFilter>>;
-  datasetInfo?: Record<string, unknown>;
+  datasetInfo?: DatasetInfoFields;
   cameraHomographies?: CameraHomographies;
   cameraCorrespondences?: CameraCorrespondences;
   cameraTransformTypes?: CameraTransformTypes;
@@ -331,6 +355,7 @@ interface Api {
 
   loadMetadata(datasetId: string): Promise<DatasetMeta>;
   loadDetections(datasetId: string, revision?: number, set?: string): Promise<AnnotationSchemaList>;
+  loadFrameMetadata(datasetId: string): Promise<FrameMetadataSourcesResponse>;
 
   saveDetections(datasetId: string, args: SaveDetectionsArgs): Promise<unknown>;
   saveMetadata(datasetId: string, metadata: DatasetMetaMutable): Promise<unknown>;
@@ -339,7 +364,13 @@ interface Api {
     args: SaveAttributeTrackFilterArgs): Promise<unknown>;
   // Non-Endpoint shared functions
   openFromDisk(datasetType: DatasetType | 'bulk' | 'calibration' | 'annotation' | 'text' | 'zip' | 'transform' | 'metadata', directory?: boolean):
-    Promise<{canceled?: boolean; filePaths: string[]; fileList?: File[]; root?: string}>;
+    Promise<{
+      canceled?: boolean;
+      filePaths: string[];
+      fileList?: File[];
+      root?: string;
+      selectionId?: string;
+    }>;
   /** Desktop: immediate child directory names under a parent folder (multicam subfolder import). */
   listImmediateSubfolders?(parentPath: string): Promise<string[]>;
   /** Desktop: subfolders or root-level video files under a parent folder (multicam import). */
@@ -591,6 +622,7 @@ export {
   AnnotationSchema,
   Api,
   DatasetMeta,
+  DatasetInfoFields,
   DatasetMetaMutable,
   DatasetMetaMutableKeys,
   MulticamSharedMutableKeys,
@@ -602,6 +634,8 @@ export {
   SubType,
   PipelineParamType,
   FrameImage,
+  FrameMetadataAttachmentText,
+  FrameMetadataSourcesResponse,
   MultiTrackRecord,
   MultiGroupRecord,
   Pipe,
diff --git a/client/dive-common/components/ImportAnnotations.vue b/client/dive-common/components/ImportAnnotations.vue
index f70721b9d..9424b6cff 100644
--- a/client/dive-common/components/ImportAnnotations.vue
+++ b/client/dive-common/components/ImportAnnotations.vue
@@ -5,6 +5,7 @@ import {
 import { useApi } from 'dive-common/apispec';
 import { usePrompt } from 'dive-common/vue-utilities/prompt-service';
 import { clientSettings, isStereoInteractiveModeEnabled } from 'dive-common/store/settings';
+import isFrameMetadataSourceName from 'dive-common/frameMetadata/naming';
 import clearLengthAttributes from 'dive-common/utils/clearLengthAttributes';
 import warpAnnotationsAcrossCameras from 'dive-common/utils/warpAnnotationsAcrossCameras';
 import { cloneDeep } from 'lodash';
@@ -188,6 +189,22 @@ export default defineComponent({
         if (!ret.canceled) {
           menuOpen.value = false;
           const path = ret.filePaths[0];
+          // A reserved-name sidecar is frame metadata, not annotations. Reject before
+          // the import call: web uploads the file and postprocesses afterwards, so a
+          // later check would leave it sitting in the dataset folder.
+          const name = ret.fileList?.[0]?.name ?? path;
+          if (isFrameMetadataSourceName(name)) {
+            await prompt({
+              title: 'Not an Annotation File',
+              text: [
+                `"${name.replace(/^.*[\\/]/, '')}" is a frame metadata file, not annotations.`,
+                'Attach frame metadata with the "Metadata File (Optional)" field when the dataset is created.',
+                'Attached that way, a frame metadata file may have any name.',
+              ],
+              positiveButton: 'OK',
+            });
+            return;
+          }
           let importFile: boolean | string[] = false;
           processing.value = true;
           const set = currentSet.value === 'default' ? undefined : currentSet.value;
diff --git a/client/dive-common/components/ImportMultiCamDialog/ImportMultiCamChooseMetadata.vue b/client/dive-common/components/ImportMultiCamDialog/ImportMultiCamChooseMetadata.vue
new file mode 100644
index 000000000..99050bddf
--- /dev/null
+++ b/client/dive-common/components/ImportMultiCamDialog/ImportMultiCamChooseMetadata.vue
@@ -0,0 +1,51 @@
+<script lang="ts">
+import { defineComponent } from 'vue';
+
+export default defineComponent({
+  name: 'ImportMultiCamChooseMetadata',
+  props: {
+    metadataFile: {
+      type: String,
+      default: '',
+    },
+  },
+});
+</script>
+
+<template>
+  <v-row
+    class="align-center"
+    no-gutters
+  >
+    <v-text-field
+      label="Camera Metadata File (Optional)"
+      placeholder="Not selected"
+      hint="A JSON, TXT, or CSV attachment for this camera. Pipelines that request it receive it;
+        rows in a TXT/CSV that match this camera's media are shown per frame."
+      persistent-hint
+      readonly
+      outlined
+      dense
+      :value="metadataFile"
+      class="mr-3"
+    />
+    <v-btn
+      v-if="metadataFile"
+      icon
+      class="mr-2"
+      aria-label="Clear camera metadata file"
+      @click="$emit('clear')"
+    >
+      <v-icon>mdi-close</v-icon>
+    </v-btn>
+    <v-btn
+      color="primary"
+      @click="$emit('open')"
+    >
+      Choose metadata
+      <v-icon class="ml-2">
+        mdi-file-cog
+      </v-icon>
+    </v-btn>
+  </v-row>
+</template>
diff --git a/client/dive-common/components/ImportMultiCamDialog/ImportMultiCamMetadata.vue b/client/dive-common/components/ImportMultiCamDialog/ImportMultiCamMetadata.vue
index f8fbad63f..20de2c793 100644
--- a/client/dive-common/components/ImportMultiCamDialog/ImportMultiCamMetadata.vue
+++ b/client/dive-common/components/ImportMultiCamDialog/ImportMultiCamMetadata.vue
@@ -1,6 +1,6 @@
 <!--
   Optional per-dataset metadata file picker (e.g. sea-lion flight log). Requires
-  `ctx`; uses metadataFile and open from ctx. Unlike calibration this is not gated
+  `ctx`; uses metadata and open from ctx. Unlike calibration this is not gated
   to stereo datasets.
 -->
 <script lang="ts">
@@ -14,12 +14,12 @@ export default defineComponent({
   },
   setup(props) {
     const {
-      metadataFile,
+      metadata,
       open,
       clearMetadataFile,
     } = props.ctx;
     return {
-      metadataFile,
+      metadata,
       open,
       clearMetadataFile,
     };
@@ -39,12 +39,12 @@ export default defineComponent({
       outlined
       dense
       hide-details
-      :value="metadataFile"
+      :value="metadata && metadata.name"
       hint="A .json, .txt, or .csv file passed to pipelines that request it."
       class="mr-3"
     />
     <v-btn
-      v-if="metadataFile"
+      v-if="metadata"
       icon
       class="mr-2"
       aria-label="Clear metadata file"
diff --git a/client/dive-common/components/ImportMultiCamDialog/ImportMultiCamMultiFolder.vue b/client/dive-common/components/ImportMultiCamDialog/ImportMultiCamMultiFolder.vue
index d0182cb41..a1c8b5025 100644
--- a/client/dive-common/components/ImportMultiCamDialog/ImportMultiCamMultiFolder.vue
+++ b/client/dive-common/components/ImportMultiCamDialog/ImportMultiCamMultiFolder.vue
@@ -9,6 +9,7 @@ import ImportMultiCamCameraGroup from './ImportMultiCamCameraGroup.vue';
 import ImportMultiCamChooseSource from './ImportMultiCamChooseSource.vue';
 import ImportMultiCamChooseAnnotation from './ImportMultiCamChooseAnnotation.vue';
 import ImportMultiCamChooseTransform from './ImportMultiCamChooseTransform.vue';
+import ImportMultiCamChooseMetadata from './ImportMultiCamChooseMetadata.vue';
 import ImportMultiCamAddType from './ImportMultiCamAddType.vue';
 import ImportMultiCamCameraOrderControls from './ImportMultiCamCameraOrderControls.vue';
 import { importMultiCamContextProp } from './importMultiCamContext';
@@ -20,6 +21,7 @@ export default defineComponent({
     ImportMultiCamChooseSource,
     ImportMultiCamChooseAnnotation,
     ImportMultiCamChooseTransform,
+    ImportMultiCamChooseMetadata,
     ImportMultiCamAddType,
     ImportMultiCamCameraOrderControls,
   },
@@ -48,6 +50,8 @@ export default defineComponent({
       showTransformFileField: props.ctx.showTransformFileField,
       openTransformFile: props.ctx.openTransformFile,
       clearTransformFile: props.ctx.clearTransformFile,
+      openCameraMetadataFile: props.ctx.openCameraMetadataFile,
+      clearCameraMetadataFile: props.ctx.clearCameraMetadataFile,
     };
   },
 });
@@ -94,6 +98,13 @@ export default defineComponent({
         @clear="clearTransformFile(key)"
         @open="openTransformFile(key)"
       />
+      <ImportMultiCamChooseMetadata
+        v-if="folderList[key].sourcePath"
+        :metadata-file="folderList[key].metadata && folderList[key].metadata.name"
+        class="my-3"
+        @clear="clearCameraMetadataFile(key)"
+        @open="openCameraMetadataFile(key)"
+      />
     </ImportMultiCamCameraGroup>
     <ImportMultiCamAddType
       v-if="!stereo"
diff --git a/client/dive-common/components/ImportMultiCamDialog/ImportMultiCamSubfolders.vue b/client/dive-common/components/ImportMultiCamDialog/ImportMultiCamSubfolders.vue
index 437477cca..232acceea 100644
--- a/client/dive-common/components/ImportMultiCamDialog/ImportMultiCamSubfolders.vue
+++ b/client/dive-common/components/ImportMultiCamDialog/ImportMultiCamSubfolders.vue
@@ -9,6 +9,7 @@ import { ImageSequenceType } from 'dive-common/constants';
 import ImportMultiCamCameraGroup from './ImportMultiCamCameraGroup.vue';
 import ImportMultiCamChooseSource from './ImportMultiCamChooseSource.vue';
 import ImportMultiCamChooseTransform from './ImportMultiCamChooseTransform.vue';
+import ImportMultiCamChooseMetadata from './ImportMultiCamChooseMetadata.vue';
 import ImportMultiCamCameraOrderControls from './ImportMultiCamCameraOrderControls.vue';
 import ImportMultiCamFinalizeStep from './ImportMultiCamFinalizeStep.vue';
 import { importMultiCamContextProp } from './importMultiCamContext';
@@ -19,6 +20,7 @@ export default defineComponent({
     ImportMultiCamCameraGroup,
     ImportMultiCamChooseSource,
     ImportMultiCamChooseTransform,
+    ImportMultiCamChooseMetadata,
     ImportMultiCamCameraOrderControls,
     ImportMultiCamFinalizeStep,
   },
@@ -51,6 +53,8 @@ export default defineComponent({
       showTransformFileField: props.ctx.showTransformFileField,
       openTransformFile: props.ctx.openTransformFile,
       clearTransformFile: props.ctx.clearTransformFile,
+      openCameraMetadataFile: props.ctx.openCameraMetadataFile,
+      clearCameraMetadataFile: props.ctx.clearCameraMetadataFile,
       ImageSequenceType,
     };
   },
@@ -150,6 +154,13 @@ export default defineComponent({
         @clear="clearTransformFile(key)"
         @open="openTransformFile(key)"
       />
+      <ImportMultiCamChooseMetadata
+        v-if="folderList[key] && folderList[key].sourcePath"
+        :metadata-file="folderList[key].metadata && folderList[key].metadata.name"
+        class="my-3"
+        @clear="clearCameraMetadataFile(key)"
+        @open="openCameraMetadataFile(key)"
+      />
     </ImportMultiCamCameraGroup>
     <ImportMultiCamFinalizeStep
       v-if="camerasReady"
diff --git a/client/dive-common/components/ImportMultiCamDialog/useImportMultiCamDialog.ts b/client/dive-common/components/ImportMultiCamDialog/useImportMultiCamDialog.ts
index bb8decc24..5b92b171c 100644
--- a/client/dive-common/components/ImportMultiCamDialog/useImportMultiCamDialog.ts
+++ b/client/dive-common/components/ImportMultiCamDialog/useImportMultiCamDialog.ts
@@ -44,6 +44,27 @@ import {
   validateMulticamImageSets,
 } from 'dive-common/components/ImportMultiCamDialog/validateMulticamImageSets';
 
+/**
+ * A chosen metadata attachment. One record replaces the parallel path/name pair the dialog used
+ * to carry: the two were always written and cleared together, and only one of them is ever
+ * shown.
+ */
+interface MetadataSelection {
+  /** What the import receives: an absolute path on desktop, an opaque registry key on web. */
+  value: string;
+  /** What the dialog shows. */
+  name: string;
+}
+
+function metadataSelection(
+  ret: { filePaths: string[]; selectionId?: string },
+): MetadataSelection {
+  // Web hands back a single-file pick, so filePaths[0] is already the basename the dialog
+  // should show; desktop hands back the absolute path, which is what it shows.
+  const [path] = ret.filePaths;
+  return { value: ret.selectionId || path, name: path };
+}
+
 export interface UseImportMultiCamDialogProps {
   stereo?: boolean;
   dataType: typeof VideoType | typeof ImageSequenceType;
@@ -84,6 +105,12 @@ export function useImportMultiCamDialog(
     sourcePath: string;
     trackFile: string;
     transformFile: string;
+    /**
+     * Optional camera-local metadata attachment. `value` is what the import receives (an
+     * absolute path on desktop, an opaque registry key on web); `name` is what the dialog
+     * shows. Absent until the user picks one.
+     */
+    metadata?: MetadataSelection;
     type?: DatasetType;
     /** Filename glob when cameras share one folder (per-modality suffixes). */
     glob?: string;
@@ -98,7 +125,7 @@ export function useImportMultiCamDialog(
   const calibrationAutoDiscoveryFailed = ref(false);
   // Optional per-dataset metadata file (e.g. sea-lion flight log). Not gated to
   // stereo; applies to any multicam import.
-  const metadataFile = ref('');
+  const metadata: Ref<MetadataSelection | null> = ref(null);
   const datasetName = ref('');
   const subfolderOriginalNames: Ref<Record<string, string>> = ref({});
   const cameraOrder: Ref<string[]> = ref([]);
@@ -568,6 +595,7 @@ export function useImportMultiCamDialog(
         ? newKey : sourcePath,
       trackFile: entry.trackFile,
       transformFile: entry.transformFile,
+      ...(entry.metadata ? { metadata: entry.metadata } : {}),
       ...(entry.type ? { type: entry.type } : {}),
       ...(entry.glob ? { glob: entry.glob } : {}),
     });
@@ -658,6 +686,17 @@ export function useImportMultiCamDialog(
     folderList.value[folder].transformFile = '';
   }
 
+  async function openCameraMetadataFile(folder: string) {
+    const ret = await openFromDisk('metadata');
+    if (!ret.canceled && ret.filePaths?.length) {
+      Vue.set(folderList.value[folder], 'metadata', metadataSelection(ret));
+    }
+  }
+
+  function clearCameraMetadataFile(folder: string) {
+    Vue.delete(folderList.value[folder], 'metadata');
+  }
+
   async function open(
     dstype: DatasetType | 'calibration' | 'text' | 'metadata',
     folder: string | 'calibration' | 'metadata',
@@ -674,7 +713,7 @@ export function useImportMultiCamDialog(
           saveCalibration(path);
         }
       } else if (folder === 'metadata') {
-        metadataFile.value = path;
+        metadata.value = metadataSelection(ret);
       } else if (importType.value === 'multi') {
         if (ret.root) {
           folderList.value[folder].sourcePath = ret.root;
@@ -743,7 +782,11 @@ export function useImportMultiCamDialog(
 
   const addNewSet = (name: string) => {
     if (importType.value === 'multi') {
-      Vue.set(folderList.value, name, { sourcePath: '', trackFile: '', transformFile: '' });
+      Vue.set(folderList.value, name, {
+        sourcePath: '',
+        trackFile: '',
+        transformFile: '',
+      });
       Vue.set(pendingImportPayloads.value, name, null);
       cameraOrder.value = [...cameraOrder.value, name];
     } else if (importType.value === 'keyword') {
@@ -762,7 +805,7 @@ export function useImportMultiCamDialog(
       orderedCameraKeys.value.forEach((key) => {
         if (folderList.value[key]) {
           const {
-            sourcePath, trackFile, transformFile, type, glob,
+            sourcePath, trackFile, transformFile, metadata: cameraMetadata, type, glob,
           } = folderList.value[key];
           if (type === 'multi') {
             // Sub Cameras shouldn't be multi types
@@ -773,6 +816,7 @@ export function useImportMultiCamDialog(
             trackFile,
             ...(type ? { type } : {}),
             ...(glob ? { glob } : {}),
+            ...(cameraMetadata ? { metadataFile: cameraMetadata.value } : {}),
           };
           // Transforms only apply to cameras after the first (reference) one.
           if (transformFile && showTransformFileField(key)) {
@@ -786,7 +830,7 @@ export function useImportMultiCamDialog(
         cameraOrder: orderedCameraKeys.value,
         sourceList,
         calibrationFile: calibrationFile.value,
-        metadataFile: metadataFile.value || undefined,
+        metadataFile: metadata.value?.value,
         type: props.dataType,
       };
       emit('begin-multicam-import', args);
@@ -796,7 +840,7 @@ export function useImportMultiCamDialog(
         sourcePath: keywordFolder.value,
         globList: globList.value,
         calibrationFile: calibrationFile.value,
-        metadataFile: metadataFile.value || undefined,
+        metadataFile: metadata.value?.value,
         type: 'image-sequence',
       };
       emit('begin-multicam-import', args);
@@ -825,7 +869,7 @@ export function useImportMultiCamDialog(
   }
 
   function clearMetadataFile() {
-    metadataFile.value = '';
+    metadata.value = null;
   }
 
   function applyLastCalibration() {
@@ -961,8 +1005,10 @@ export function useImportMultiCamDialog(
     showTransformFileField,
     openTransformFile,
     clearTransformFile,
+    openCameraMetadataFile,
+    clearCameraMetadataFile,
     clearCalibration,
-    metadataFile,
+    metadata,
     clearMetadataFile,
   };
 }
diff --git a/client/dive-common/components/importAnnotationsSets.spec.ts b/client/dive-common/components/importAnnotationsSets.spec.ts
index 509479827..e5acd56c3 100644
--- a/client/dive-common/components/importAnnotationsSets.spec.ts
+++ b/client/dive-common/components/importAnnotationsSets.spec.ts
@@ -6,8 +6,9 @@ import { provideAnnotator, dummyState, dummyHandler } from 'vue-media-annotator/
 import { provideApi } from 'dive-common/apispec';
 import ImportAnnotations from './ImportAnnotations.vue';
 
+const promptMock = vi.fn();
 vi.mock('dive-common/vue-utilities/prompt-service', () => ({
-  usePrompt: () => ({ prompt: vi.fn() }),
+  usePrompt: () => ({ prompt: promptMock }),
 }));
 
 /**
@@ -19,16 +20,32 @@ vi.mock('dive-common/vue-utilities/prompt-service', () => ({
  * Symbol(annotationSets)" for every such caller. Mounting with the menu closed
  * reproduces that; touching `sets` here must not throw.
  */
-function mountImportAnnotations(annotationSets: string[], annotationSet = '') {
+function mountImportAnnotations({
+  annotationSets = [],
+  annotationSet = '',
+  fileName,
+}: {
+  annotationSets?: string[];
+  annotationSet?: string;
+  /** File the OS picker returns for openUpload(); omit for tests that never open it. */
+  fileName?: string;
+} = {}) {
   const state = dummyState();
   state.annotationSets = ref(annotationSets);
   state.annotationSet = ref(annotationSet);
 
+  const importAnnotationFile = vi.fn(async () => true);
+  const openFromDisk = vi.fn(async () => ({
+    canceled: fileName === undefined,
+    filePaths: fileName === undefined ? [] : [fileName],
+    fileList: fileName === undefined ? [] : [new File(['a'], fileName)],
+  }));
+
   const Parent = defineComponent({
     setup() {
       provideApi({
-        openFromDisk: vi.fn(),
-        importAnnotationFile: vi.fn(),
+        openFromDisk,
+        importAnnotationFile,
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
       } as any);
       provideAnnotator(
@@ -51,37 +68,92 @@ function mountImportAnnotations(annotationSets: string[], annotationSet = '') {
     },
     mocks: { $vuetify: { breakpoint: { mdAndDown: false } } },
   });
-  return { vm: wrapper.findComponent(ImportAnnotations), state };
+  return { vm: wrapper.findComponent(ImportAnnotations), state, importAnnotationFile };
 }
 
 describe('ImportAnnotations annotation sets', () => {
   it('exposes sets without requiring a render pass', () => {
-    const { vm } = mountImportAnnotations(['setA', 'setB']);
+    const { vm } = mountImportAnnotations({ annotationSets: ['setA', 'setB'] });
     // Reading from outside render is what regressed: it must not throw.
     expect(() => vm.vm.sets).not.toThrow();
     expect(vm.vm.sets).toEqual(['setA', 'setB', 'default']);
   });
 
   it('always offers the default set when none are defined', () => {
-    const { vm } = mountImportAnnotations([]);
+    const { vm } = mountImportAnnotations();
     expect(vm.vm.sets).toEqual(['default']);
   });
 
   it('does not mutate the provided annotation sets', () => {
     const provided = ['only'];
-    const { vm } = mountImportAnnotations(provided);
+    const { vm } = mountImportAnnotations({ annotationSets: provided });
     expect(vm.vm.sets).toEqual(['only', 'default']);
     expect(provided).toEqual(['only']);
   });
 
   it('seeds currentSet from the provided annotation set, falling back to default', () => {
-    expect(mountImportAnnotations([], '').vm.vm.currentSet).toBe('default');
-    expect(mountImportAnnotations(['a'], 'a').vm.vm.currentSet).toBe('a');
+    expect(mountImportAnnotations().vm.vm.currentSet).toBe('default');
+    expect(mountImportAnnotations({ annotationSets: ['a'], annotationSet: 'a' }).vm.vm.currentSet)
+      .toBe('a');
   });
 
   it('does not alias the injected annotationSet ref', () => {
-    const { vm, state } = mountImportAnnotations(['a'], 'a');
+    const { vm, state } = mountImportAnnotations({ annotationSets: ['a'], annotationSet: 'a' });
     vm.vm.currentSet = 'other';
     expect(state.annotationSet.value).toBe('a');
   });
 });
+
+/**
+ * A reserved-name frame metadata attachment picked in the annotations dialog is not
+ * annotations. The reject has to happen before the import call: web's importAnnotationFile
+ * uploads the file and postprocesses afterwards, so anything later would leave it already in
+ * the dataset folder.
+ */
+describe('ImportAnnotations frame metadata reject', () => {
+  beforeEach(() => {
+    promptMock.mockClear();
+  });
+
+  // Every reserved basename, including the JSON pair: those are never readable as frame metadata
+  // but are still claimed by the name, so importing one as annotations is the same mistake.
+  it.each([
+    'frame-metadata.csv',
+    'frame-metadata.json',
+    'frame-metadata.txt',
+    'frame_metadata.csv',
+    'frame_metadata.json',
+    'frame_metadata.txt',
+    'FRAME-METADATA.CSV',
+  ])('never imports %s as annotations', async (fileName) => {
+    const { vm, importAnnotationFile } = mountImportAnnotations({ fileName });
+
+    await vm.vm.openUpload();
+
+    expect(importAnnotationFile).not.toHaveBeenCalled();
+    expect(promptMock).toHaveBeenCalledWith(expect.objectContaining({
+      title: 'Not an Annotation File',
+    }));
+  });
+
+  it('names a remedy that exists on this platform', async () => {
+    const { vm } = mountImportAnnotations({ fileName: 'frame-metadata.csv' });
+
+    await vm.vm.openUpload();
+
+    const { text } = promptMock.mock.calls[0][0];
+    // The creation-time picker is the one surface that accepts an attachment.
+    expect(text.join(' ')).toContain('"Metadata File (Optional)"');
+    // Arbitrary names work through that path, so renaming is the wrong advice.
+    expect(text.join(' ')).not.toContain('rename');
+  });
+
+  it('still imports a normally named annotation file', async () => {
+    const { vm, importAnnotationFile } = mountImportAnnotations({ fileName: 'tracks.csv' });
+
+    await vm.vm.openUpload();
+
+    expect(importAnnotationFile).toHaveBeenCalled();
+    expect(promptMock).not.toHaveBeenCalled();
+  });
+});
diff --git a/client/dive-common/constants.ts b/client/dive-common/constants.ts
index f91b619b4..7c38771b7 100644
--- a/client/dive-common/constants.ts
+++ b/client/dive-common/constants.ts
@@ -190,8 +190,6 @@ const stereoPipelineMarker = 'measurement';
 const calibrationFileMarker = 'calibrationFile';
 /** Girder item meta key marking the JSON camera-rig used for calibration display. */
 const jsonCalibrationFileMarker = 'jsonCalibrationFile';
-/** Girder item meta key marking the optional per-dataset metadata file upload. */
-const metadataFileMarker = 'metadataFile';
 /** Legacy common_stereo category key; never shown in the run-pipeline menu. */
 const hiddenPipelineCategories = ['stereo'];
 /** Pipeline name/category substrings hidden from the web run-pipeline menu. */
@@ -236,7 +234,6 @@ export {
   stereoPipelineMarker,
   calibrationFileMarker,
   jsonCalibrationFileMarker,
-  metadataFileMarker,
   hiddenPipelineCategories,
   webExcludedPipelineTerms,
   multiCamPipelineMarkers,
diff --git a/client/dive-common/frameMetadata/naming.ts b/client/dive-common/frameMetadata/naming.ts
new file mode 100644
index 000000000..32620fd91
--- /dev/null
+++ b/client/dive-common/frameMetadata/naming.ts
@@ -0,0 +1,17 @@
+// Keep this basename-only predicate mirrored with the server helper in
+// server/dive_utils/frame_metadata.py because matching names are auto-read as frame metadata
+// instead of imported as annotations.
+const FRAME_METADATA_SOURCE_NAMES = new Set([
+  'frame-metadata.csv',
+  'frame-metadata.json',
+  'frame-metadata.txt',
+  'frame_metadata.csv',
+  'frame_metadata.json',
+  'frame_metadata.txt',
+]);
+
+export default function isFrameMetadataSourceName(name: string): boolean {
+  const separator = Math.max(name.lastIndexOf('/'), name.lastIndexOf('\\'));
+  const basename = separator === -1 ? name : name.slice(separator + 1);
+  return FRAME_METADATA_SOURCE_NAMES.has(basename.toLowerCase());
+}
diff --git a/client/dive-common/frameMetadata/readability.spec.ts b/client/dive-common/frameMetadata/readability.spec.ts
new file mode 100644
index 000000000..928524303
--- /dev/null
+++ b/client/dive-common/frameMetadata/readability.spec.ts
@@ -0,0 +1,19 @@
+/// <reference types="vitest" />
+
+import { isFrameMetadataReadableName } from './readability';
+
+describe('isFrameMetadataReadableName', () => {
+  it.each([
+    ['frame-metadata.csv', true],
+    ['FLIGHT_LOG.CSV', true],
+    ['notes.txt', true],
+    ['notes.TxT', true],
+    ['flight_log.json', false],
+    ['telemetry.yml', false],
+    ['csv', false],
+    ['archive.csv.zip', false],
+    ['dir.csv/notes.json', false],
+  ])('reads %s: %s', (name, expected) => {
+    expect(isFrameMetadataReadableName(name)).toBe(expected);
+  });
+});
diff --git a/client/dive-common/frameMetadata/readability.ts b/client/dive-common/frameMetadata/readability.ts
new file mode 100644
index 000000000..d5098fa8c
--- /dev/null
+++ b/client/dive-common/frameMetadata/readability.ts
@@ -0,0 +1,20 @@
+// Keep this extension-only predicate shared by the platform attachment loaders (web
+// platform/web-girder/api/frameMetadata.service.ts, desktop platform/desktop/backend/native/common.ts)
+// because a name the parser cannot read must still be handed to pipelines untouched, and the two
+// loaders drifting would make the same file readable on one platform and opaque on the other.
+const READABLE_ATTACHMENT_EXTENSION = /\.(csv|txt)$/i;
+
+/** True when an attachment name is one the frame metadata parser is allowed to read. */
+export function isFrameMetadataReadableName(name: string): boolean {
+  return READABLE_ATTACHMENT_EXTENSION.test(name);
+}
+
+/**
+ * Shown when a declared attachment exists but its bytes could not be read.
+ *
+ * The web server emits this same string from `_metadata_attachment` in
+ * `server/dive_server/crud_dataset.py`, so the two copies must stay byte-identical: the client
+ * surfaces whichever one produced the response, and a drift would show two different errors for
+ * the same condition depending on which side detected it.
+ */
+export const METADATA_ATTACHMENT_UNAVAILABLE = 'Metadata attachment is unavailable.';
diff --git a/client/platform/desktop/backend/ipcService.ts b/client/platform/desktop/backend/ipcService.ts
index b546ac1cc..3c08df650 100644
--- a/client/platform/desktop/backend/ipcService.ts
+++ b/client/platform/desktop/backend/ipcService.ts
@@ -228,6 +228,11 @@ export default function register() {
     return ret;
   });
 
+  ipcMain.handle('load-frame-metadata', async (
+    event,
+    { datasetId }: { datasetId: string },
+  ) => common.loadFrameMetadata(settings.get(), datasetId));
+
   ipcMain.handle('import-multicam-media', async (event, { args }:
     { args: MultiCamImportArgs }) => {
     const ret = await beginMultiCamImport(args);
diff --git a/client/platform/desktop/backend/native/common.spec.ts b/client/platform/desktop/backend/native/common.spec.ts
index 9368f5fc3..0173cc1b3 100644
--- a/client/platform/desktop/backend/native/common.spec.ts
+++ b/client/platform/desktop/backend/native/common.spec.ts
@@ -13,6 +13,7 @@ import { MultiTrackRecord } from 'dive-common/apispec';
 import { Attribute } from 'vue-media-annotator/use/AttributeTypes';
 import * as common from './common';
 import { createWorkingDirectory } from './utils';
+import beginMultiCamImport from './multiCamImport';
 
 vi.mock('fs-extra', async () => {
   const actual = await vi.importActual<typeof import('fs-extra')>('fs-extra');
@@ -298,6 +299,154 @@ beforeEach(() => {
         'file1.csv': '',
         'file2.csv': '',
       },
+      frameMetadataSource: {
+        'image_0001.jpg': '',
+        'image_0002.jpg': '',
+        'image_0003.jpg': '',
+        'frame-metadata.txt': [
+          'filename,depth,temperature',
+          'image_0001.jpg,192.80,4.0',
+          'image_0002.jpg,193.10,4.1',
+          'image_0003.jpg,193.40,4.2',
+          '',
+        ].join('\n'),
+      },
+      videoMetadataSource: {
+        'movie.mp4': '',
+        'frame_metadata.csv': 'frame,depth\n0,10\n2,30\n',
+      },
+      multicamVideoMetadata: {
+        'frame_metadata.csv': 'frame,depth\n0,shared\n2,long-camera\n',
+        left: {
+          'left.mp4': '',
+        },
+        right: {
+          'right.mp4': '',
+        },
+      },
+      // Two reserved-name attachments in one folder: read-time discovery reports the
+      // ambiguity instead of choosing one or merging them.
+      frameMetadataAmbiguous: {
+        'image_0001.jpg': '',
+        'frame-metadata.txt': 'filename,depth\nimage_0001.jpg,10\n',
+        'frame_metadata.csv': 'filename,depth\nimage_0001.jpg,99\n',
+      },
+      // An exported dataset folder: the attachment travels under metadata/ and meta.json
+      // carries only the exporting server's item id, which import must ignore.
+      archiveDataset: {
+        'image_0001.jpg': '',
+        'meta.json': JSON.stringify({ metadataFileItemId: '64b8f0c2e1d3a40001abcdef' }),
+        metadata: {
+          'flight_log.csv': 'filename,altitude\nimage_0001.jpg,120\n',
+        },
+      },
+      // An ordinary media folder that keeps its own metadata/ subdirectory. It is not an export
+      // archive -- no meta.json -- so the archive contract must not be applied to its contents.
+      metadataSubdirectory: {
+        'image_0001.jpg': '',
+        metadata: {
+          'exif.xml': '<exif/>',
+          'notes.xml': '<notes/>',
+        },
+      },
+      // An attachment the user picks in the dialog, named nothing like a reserved sidecar.
+      explicitMetadata: {
+        'flight_log.json': '{"rows": []}',
+      },
+      // Keyword multicam import: originalBasePath holds the image-list FILE, not a directory.
+      multicamImageList: {
+        'image_list.txt': 'img_l1.jpg\nimg_r1.jpg\n',
+        'img_l1.jpg': '',
+        'img_r1.jpg': '',
+        'frame_metadata.csv': 'filename,depth\nimg_l1.jpg,10\n',
+      },
+      // Multicam with an explicit shared attachment and a camera-local reserved-name one.
+      multicamExplicitShared: {
+        left: { 'img_l1.jpg': '' },
+        right: {
+          'img_r1.jpg': '',
+          'frame_metadata.csv': 'filename,depth\nimg_r1.jpg,300\n',
+        },
+      },
+      frameMetadataDoubleExt: {
+        'photo.jpg.png': '',
+        'frame_metadata.csv': [
+          'filename,depth',
+          'photo.jpg.png,10',
+          '',
+        ].join('\n'),
+      },
+      frameMetadataNoSource: {
+        'image_0001.jpg': '',
+        'notes.txt': 'note,value\nhello,world\n',
+      },
+      // Duplicate image basename across subfolders: the read path keys last-wins instead of
+      // throwing like the import-path validator.
+      frameMetadataDupSource: {
+        'frame_metadata.csv': [
+          'filename,depth',
+          'image_0001.jpg,10',
+          'image_0002.jpg,20',
+          '',
+        ].join('\n'),
+      },
+      // Multicam whose root (originalBasePath) is also the 'left' camera's media dir; the shared
+      // sidecar must be listed once for 'left' and 'right' names other images so it joins nothing.
+      multicamRootDedup: {
+        'frame_metadata.csv': [
+          'filename,depth',
+          'img_l1.jpg,100',
+          'img_l2.jpg,200',
+          '',
+        ].join('\n'),
+        right: {
+          'img_r1.jpg': '',
+        },
+      },
+      // Multicam whose parent root holds one wide sidecar naming both cameras' images; each
+      // camera's media lives in its own subfolder, so the shared root file binds both cameras.
+      multicamSharedRoot: {
+        'frame_metadata.csv': [
+          'filename,depth',
+          'img_l1.jpg,100',
+          'img_l2.jpg,110',
+          'img_r1.jpg,300',
+          'img_r2.jpg,310',
+          '',
+        ].join('\n'),
+        left: {
+          'img_l1.jpg': '',
+          'img_l2.jpg': '',
+        },
+        right: {
+          'img_r1.jpg': '',
+          'img_r2.jpg': '',
+        },
+      },
+      // Import-gate fixtures.
+      fmGateMixed: {
+        'image_0001.jpg': '',
+        // Sorts first but is declared frame metadata: skipped as a track-file candidate, left on disk.
+        'frame_metadata.csv': 'filename,depth\nimage_0001.jpg,10\n',
+        'zzz_annotations.csv': '# comment line\n# metadata,fps: 32,"whatever"\n#comment line',
+      },
+      fmGateFrameMetadataOnly: {
+        'image_0001.jpg': '',
+        'frame_metadata.csv': 'filename,depth\nimage_0001.jpg,10\n',
+      },
+      fmGateMultipleMetadata: {
+        'image_0001.jpg': '',
+        'frame_metadata.csv': 'filename,depth\nimage_0001.jpg,10\n',
+        'frame-metadata.json': '{}',
+      },
+      fmGateExplicit: {
+        'frame_metadata.csv': 'filename,depth\nimage_0001.jpg,10\n',
+      },
+      // A plain CSV (not declared) whose contents fail to parse as VIAME annotations: the error
+      // gains the rename hint. The unterminated quote makes csv-parse reject.
+      fmGateViameFail: {
+        'nav.csv': 'filename,depth\n"unterminated,10\n',
+      },
     },
     '/home/user/viamedata': {
     // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -346,12 +495,261 @@ beforeEach(() => {
             id: 'projectid1',
             type: 'video',
             fps: 5,
+            originalBasePath: '/home/user/data/videoMetadataSource',
             originalVideoFile: 'whatever.mp4',
             transcodedVideoFile: 'whatever-transcoded.mp4',
           } as JsonMeta),
           'result_whatever.json': JSON.stringify({}),
+          'whatever-transcoded.mp4': '',
+          auxiliary: {},
+        },
+        projectidMulticamVideoMetadata: {
+          'meta.json': JSON.stringify({
+            version: 1,
+            id: 'projectidMulticamVideoMetadata',
+            type: 'multi',
+            fps: 5,
+            originalBasePath: '/home/user/data/multicamVideoMetadata',
+            multiCam: {
+              defaultDisplay: 'left',
+              cameras: {
+                left: {
+                  type: 'video',
+                  originalBasePath: '/home/user/data/multicamVideoMetadata/left',
+                  originalVideoFile: 'left.mp4',
+                  metadataFile: 'auxiliary/left/local.csv',
+                  metadataOriginalName: 'left-local.csv',
+                },
+                right: {
+                  type: 'video',
+                  originalBasePath: '/home/user/data/multicamVideoMetadata/right',
+                  originalVideoFile: 'right.mp4',
+                },
+              },
+            },
+          }),
+          'result_whatever.json': JSON.stringify({}),
+          auxiliary: {
+            left: {
+              'local.csv': 'frame,depth\n0,local\n',
+            },
+          },
+        },
+        projectidFrameMetadata: {
+          'meta.json': JSON.stringify({
+            version: 1,
+            id: 'projectidFrameMetadata',
+            type: 'image-sequence',
+            fps: 5,
+            originalBasePath: '/home/user/data/frameMetadataSource',
+            originalImageFiles: [
+              'image_0001.jpg',
+              'image_0002.jpg',
+              'image_0003.jpg',
+            ],
+          }),
+          'result_whatever.json': JSON.stringify({}),
+          auxiliary: {},
+        },
+        projectidFrameMetadataAmbiguous: {
+          'meta.json': JSON.stringify({
+            version: 1,
+            id: 'projectidFrameMetadataAmbiguous',
+            type: 'image-sequence',
+            fps: 5,
+            originalBasePath: '/home/user/data/frameMetadataAmbiguous',
+            originalImageFiles: ['image_0001.jpg'],
+          }),
+          'result_whatever.json': JSON.stringify({}),
+          auxiliary: {},
+        },
+        projectidMulticamImageList: {
+          'meta.json': JSON.stringify({
+            version: 1,
+            id: 'projectidMulticamImageList',
+            type: 'multi',
+            fps: 5,
+            originalBasePath: '/home/user/data/multicamImageList/image_list.txt',
+            multiCam: {
+              defaultDisplay: 'left',
+              cameras: {
+                left: {
+                  type: 'image-sequence',
+                  originalBasePath: '',
+                  imageListPath: '/home/user/data/multicamImageList/image_list.txt',
+                  originalImageFiles: ['/home/user/data/multicamImageList/img_l1.jpg'],
+                },
+                right: {
+                  type: 'image-sequence',
+                  originalBasePath: '',
+                  imageListPath: '/home/user/data/multicamImageList/image_list.txt',
+                  originalImageFiles: ['/home/user/data/multicamImageList/img_r1.jpg'],
+                },
+              },
+            },
+          }),
+          'result_whatever.json': JSON.stringify({}),
+          auxiliary: {},
+        },
+        projectidMulticamExplicitShared: {
+          'meta.json': JSON.stringify({
+            version: 1,
+            id: 'projectidMulticamExplicitShared',
+            type: 'multi',
+            fps: 5,
+            originalBasePath: '/home/user/data/multicamExplicitShared',
+            metadataFile: 'auxiliary/flight_log.csv',
+            metadataOriginalName: 'flight_log.csv',
+            multiCam: {
+              defaultDisplay: 'left',
+              cameras: {
+                left: {
+                  type: 'image-sequence',
+                  originalBasePath: '/home/user/data/multicamExplicitShared/left',
+                  originalImageFiles: ['img_l1.jpg'],
+                },
+                right: {
+                  type: 'image-sequence',
+                  originalBasePath: '/home/user/data/multicamExplicitShared/right',
+                  originalImageFiles: ['img_r1.jpg'],
+                },
+              },
+            },
+          }),
+          'result_whatever.json': JSON.stringify({}),
+          auxiliary: {
+            'flight_log.csv': 'filename,altitude\nimg_l1.jpg,120\n',
+          },
+        },
+        projectidFrameMetadataNoSource: {
+          'meta.json': JSON.stringify({
+            version: 1,
+            id: 'projectidFrameMetadataNoSource',
+            type: 'image-sequence',
+            fps: 5,
+            originalBasePath: '/home/user/data/frameMetadataNoSource',
+            originalImageFiles: [
+              'image_0001.jpg',
+            ],
+          }),
+          'result_whatever.json': JSON.stringify({}),
+          auxiliary: {},
+        },
+        projectidFrameMetadataDoubleExt: {
+          'meta.json': JSON.stringify({
+            version: 1,
+            id: 'projectidFrameMetadataDoubleExt',
+            type: 'image-sequence',
+            fps: 5,
+            originalBasePath: '/home/user/data/frameMetadataDoubleExt',
+            originalImageFiles: [
+              'photo.jpg.png',
+            ],
+          }),
+          'result_whatever.json': JSON.stringify({}),
+          auxiliary: {},
+        },
+        projectidFrameMetadataDup: {
+          'meta.json': JSON.stringify({
+            version: 1,
+            id: 'projectidFrameMetadataDup',
+            type: 'image-sequence',
+            fps: 5,
+            originalBasePath: '/home/user/data/frameMetadataDupSource',
+            // Two files share the basename image_0001.jpg (different subfolders).
+            originalImageFiles: [
+              'a/image_0001.jpg',
+              'b/image_0001.jpg',
+              'a/image_0002.jpg',
+            ],
+          }),
+          'result_whatever.json': JSON.stringify({}),
           auxiliary: {},
         },
+        projectidMetadataAttachment: {
+          'meta.json': JSON.stringify({
+            version: 1,
+            id: 'projectidMetadataAttachment',
+            type: 'image-sequence',
+            fps: 5,
+            originalBasePath: '/home/user/data/frameMetadataSource',
+            originalImageFiles: [
+              'image_0001.jpg',
+              'image_0002.jpg',
+              'image_0003.jpg',
+            ],
+            metadataFile: '/home/user/viamedata/DIVE_Projects/projectidMetadataAttachment/flight_log.csv',
+          }),
+          'result_whatever.json': JSON.stringify({}),
+          'flight_log.csv': [
+            'filename,altitude',
+            'image_0001.jpg,120',
+            '',
+          ].join('\n'),
+          auxiliary: {},
+        },
+        projectidMulticamRootDedup: {
+          'meta.json': JSON.stringify({
+            version: 1,
+            id: 'projectidMulticamRootDedup',
+            type: 'multi',
+            fps: 5,
+            originalBasePath: '/home/user/data/multicamRootDedup',
+            multiCam: {
+              defaultDisplay: 'left',
+              cameras: {
+                left: {
+                  type: 'image-sequence',
+                  originalBasePath: '/home/user/data/multicamRootDedup',
+                  originalImageFiles: ['img_l1.jpg', 'img_l2.jpg'],
+                },
+                right: {
+                  type: 'image-sequence',
+                  originalBasePath: '/home/user/data/multicamRootDedup/right',
+                  originalImageFiles: ['img_r1.jpg'],
+                },
+              },
+            },
+          }),
+          'result_whatever.json': JSON.stringify({}),
+          auxiliary: {},
+        },
+        projectidMulticamSharedRoot: {
+          'meta.json': JSON.stringify({
+            version: 1,
+            id: 'projectidMulticamSharedRoot',
+            type: 'multi',
+            fps: 5,
+            originalBasePath: '/home/user/data/multicamSharedRoot',
+            multiCam: {
+              defaultDisplay: 'left',
+              cameras: {
+                left: {
+                  type: 'image-sequence',
+                  originalBasePath: '/home/user/data/multicamSharedRoot/left',
+                  originalImageFiles: ['img_l1.jpg', 'img_l2.jpg'],
+                  metadataFile: 'auxiliary/left/local.csv',
+                  metadataOriginalName: 'left-local.csv',
+                },
+                right: {
+                  type: 'image-sequence',
+                  originalBasePath: '/home/user/data/multicamSharedRoot/right',
+                  originalImageFiles: ['img_r1.jpg', 'img_r2.jpg'],
+                },
+              },
+            },
+          }),
+          'result_whatever.json': JSON.stringify({}),
+          auxiliary: {
+            left: {
+              'local.csv': [
+                'filename,depth',
+                'other.jpg,999',
+                '',
+              ].join('\n'),
+            },
+          },
+        },
         projectid2Bad: {
           'meta.json': '{}',
           // Won't match
@@ -559,6 +957,106 @@ describe('native.common', () => {
     expect(payload.jsonMeta.originalBasePath).toBe('/home/user/data/imageSuccess');
   });
 
+  it('offers one reserved metadata attachment on the media import response', async () => {
+    const payload = await common.beginMediaImport('/home/user/data/frameMetadataSource');
+
+    // The dialog binds metadataFileAbsPath, so a discovered attachment must land there rather
+    // than on jsonMeta, where the user could neither see nor clear it.
+    expect(payload.metadataFileAbsPath)
+      .toBe('/home/user/data/frameMetadataSource/frame-metadata.txt');
+    expect(payload.jsonMeta.metadataFile).toBeUndefined();
+  });
+
+  it('offers an exported folder\'s archive attachment on the media import response', async () => {
+    const payload = await common.beginMediaImport('/home/user/data/archiveDataset');
+
+    expect(payload.metadataFileAbsPath)
+      .toBe('/home/user/data/archiveDataset/metadata/flight_log.csv');
+  });
+
+  it('stores the explicitly chosen attachment under its own name', async () => {
+    // The folder holds frame-metadata.txt, but the user picked flight_log.json in the import
+    // dialog. Storing it under the discovered name would both mislabel it in the panel and,
+    // because readability is decided by name, feed a JSON body to the CSV parser.
+    const payload = await common.beginMediaImport('/home/user/data/frameMetadataSource');
+    payload.metadataFileAbsPath = '/home/user/data/explicitMetadata/flight_log.json';
+
+    const { meta } = await common.finalizeMediaImport(settings, payload);
+    const projectDir = npath.join(settings.dataPath, ProjectsFolderName, meta.id);
+    expect(meta.metadataOriginalName).toBe('flight_log.json');
+    expect(meta.metadataFile).toBe(npath.join(projectDir, 'auxiliary', 'flight_log.json'));
+
+    const loaded = await common.loadFrameMetadata(settings, meta.id);
+    expect(loaded.shared?.name).toBe('flight_log.json');
+    expect(loaded.shared?.text).toBeUndefined();
+  });
+
+  it('refuses a metadata attachment the platforms do not accept', async () => {
+    const payload = await common.beginMediaImport('/home/user/data/imageSuccess');
+    payload.metadataFileAbsPath = '/home/user/data/imageSuccess/foo.png';
+
+    await expect(common.finalizeMediaImport(settings, payload))
+      .rejects.toThrow('Metadata attachment must be a JSON, TXT, or CSV file');
+  });
+
+  it('stores shared and camera-local multicam attachments under auxiliary', async () => {
+    const shared = '/home/user/data/videoMetadataSource/frame_metadata.csv';
+    const local = '/home/user/data/frameMetadataSource/frame-metadata.txt';
+    const payload = await beginMultiCamImport({
+      datasetName: 'metadata_multicam',
+      defaultDisplay: 'left',
+      sourceList: {
+        left: {
+          sourcePath: '/home/user/data/imageSuccess',
+          trackFile: '',
+          metadataFile: local,
+        },
+        right: {
+          sourcePath: '/home/user/data/imageSuccess',
+          trackFile: '',
+        },
+      },
+      metadataFile: shared,
+      type: 'image-sequence',
+    });
+
+    const { meta } = await common.finalizeMediaImport(settings, payload);
+    const projectDir = npath.join(settings.dataPath, ProjectsFolderName, meta.id);
+    expect(meta.metadataFile).toBe(npath.join(projectDir, 'auxiliary', 'frame_metadata.csv'));
+    expect(meta.multiCam?.cameras.left.metadataFile)
+      .toBe(npath.join(projectDir, 'auxiliary', 'left', 'frame-metadata.txt'));
+    expect(await fs.pathExists(meta.metadataFile as string)).toBe(true);
+    expect(await fs.pathExists(meta.multiCam?.cameras.left.metadataFile as string)).toBe(true);
+
+    const leftMeta = await fs.readJSON(npath.join(projectDir, 'left', 'meta.json'));
+    expect(leftMeta.metadataFile).toBe(meta.multiCam?.cameras.left.metadataFile);
+    expect(leftMeta.metadataOriginalName).toBe('frame-metadata.txt');
+    const rightMeta = await fs.readJSON(npath.join(projectDir, 'right', 'meta.json'));
+    expect(rightMeta.metadataFile).toBeUndefined();
+    expect(rightMeta.metadataOriginalName).toBeUndefined();
+  });
+
+  it('warns instead of refusing when a folder holds two reserved metadata attachments', async () => {
+    // The dialog's "Metadata File (Optional)" picker is the only place the user can settle
+    // this, and it opens only once beginMediaImport returns, so the import must survive.
+    const payload = await common.beginMediaImport('/home/user/data/fmGateMultipleMetadata');
+
+    expect(payload.metadataFileAbsPath).toBeUndefined();
+    expect(payload.importWarnings).toEqual([
+      'More than one metadata file was found in /home/user/data/fmGateMultipleMetadata.'
+      + ' Keep one and try again.',
+    ]);
+  });
+
+  it('leaves a plain folder\'s own metadata/ subdirectory alone', async () => {
+    // Only exported dataset folders carry the archive contract. Applying it here would make
+    // any dataset with a metadata/ directory of its own impossible to import.
+    const payload = await common.beginMediaImport('/home/user/data/metadataSubdirectory');
+
+    expect(payload.metadataFileAbsPath).toBeUndefined();
+    expect(payload.importWarnings).toBeUndefined();
+  });
+
   it('beginMediaImport image lists success', async () => {
     const payload = await common.beginMediaImport(
       '/home/user/data/imageLists/success/image_list.txt',
@@ -1362,6 +1860,179 @@ describe('native.common', () => {
   });
 });
 
+describe('frame metadata read path (source text loading)', () => {
+  it('loads a single-camera reserved-name fallback as the shared attachment', async () => {
+    const data = await common.loadFrameMetadata(settings, 'projectidFrameMetadata');
+    expect(data.cameras).toEqual({});
+    expect(data.shared?.name).toBe('frame-metadata.txt');
+    expect(data.shared?.text).toContain('image_0001.jpg');
+    expect(data.shared?.text).toContain('depth');
+  });
+
+  it('uses the selected metadata attachment without adding a reserved fallback', async () => {
+    const data = await common.loadFrameMetadata(settings, 'projectidMetadataAttachment');
+    expect(data.cameras).toEqual({});
+    expect(data.shared?.name).toBe('flight_log.csv');
+    expect(data.shared?.text).toContain('image_0001.jpg,120');
+  });
+
+  it('reports more than one reserved-name fallback instead of merging them', async () => {
+    const data = await common.loadFrameMetadata(settings, 'projectidFrameMetadataAmbiguous');
+    expect(data).toEqual({
+      shared: {
+        name: 'Metadata File',
+        error: 'More than one reserved-name metadata attachment is available.',
+      },
+      cameras: {},
+    });
+  });
+
+  it('omits a camera whose only text file is not a declared sidecar', async () => {
+    await expect(common.loadFrameMetadata(settings, 'projectidFrameMetadataNoSource'))
+      .resolves.toEqual({ cameras: {} });
+  });
+
+  it('loads a sidecar that names double-extension media by full name', async () => {
+    const data = await common.loadFrameMetadata(settings, 'projectidFrameMetadataDoubleExt');
+    expect(data.shared?.name).toBe('frame_metadata.csv');
+    expect(data.shared?.text).toContain('photo.jpg.png');
+  });
+
+  it('loads a sidecar for duplicate image basenames without validating media keys', async () => {
+    const data = await common.loadFrameMetadata(settings, 'projectidFrameMetadataDup');
+    expect(data.shared?.name).toBe('frame_metadata.csv');
+    expect(data.shared?.text).toContain('image_0001.jpg');
+  });
+
+  it('returns a multicam shared root attachment once', async () => {
+    const data = await common.loadFrameMetadata(settings, 'projectidMulticamRootDedup');
+    expect(data.cameras).toEqual({});
+    expect(data.shared?.name).toBe('frame_metadata.csv');
+    expect(data.shared?.text).toContain('img_l1.jpg');
+  });
+
+  it('returns shared and camera-local multicam attachments at their own scopes', async () => {
+    const data = await common.loadFrameMetadata(settings, 'projectidMulticamSharedRoot');
+    expect(data.shared?.name).toBe('frame_metadata.csv');
+    expect(data.shared?.text).toContain('img_r1.jpg');
+    expect(data.cameras.left.name).toBe('left-local.csv');
+    expect(data.cameras.left.text).toContain('other.jpg,999');
+    expect(data.cameras.right).toBeUndefined();
+  });
+
+  it('keeps a camera-local reserved attachment beside an explicit shared one', async () => {
+    const data = await common.loadFrameMetadata(settings, 'projectidMulticamExplicitShared');
+    expect(data.shared?.name).toBe('flight_log.csv');
+    expect(data.shared?.text).toContain('img_l1.jpg,120');
+    expect(data.cameras.right.name).toBe('frame_metadata.csv');
+    expect(data.cameras.right.text).toContain('img_r1.jpg,300');
+    expect(data.cameras.left).toBeUndefined();
+  });
+
+  it('resolves a multicam whose base path is an image list file, not a directory', async () => {
+    const data = await common.loadFrameMetadata(settings, 'projectidMulticamImageList');
+    expect(data.shared?.name).toBe('frame_metadata.csv');
+    expect(data.shared?.text).toContain('img_l1.jpg,10');
+    expect(data.cameras).toEqual({});
+  });
+
+  it('loads a single-camera video reserved-name fallback', async () => {
+    const data = await common.loadFrameMetadata(settings, 'projectid1VideoGood');
+    expect(data.cameras).toEqual({});
+    expect(data.shared?.name).toBe('frame_metadata.csv');
+    expect(data.shared?.text).toContain('2,30');
+  });
+
+  it('loads shared and camera-local multicamera video attachments', async () => {
+    const data = await common.loadFrameMetadata(settings, 'projectidMulticamVideoMetadata');
+    expect(data.shared?.name).toBe('frame_metadata.csv');
+    expect(data.shared?.text).toContain('2,long-camera');
+    expect(data.cameras.left.name).toBe('left-local.csv');
+    expect(data.cameras.left.text).toContain('0,local');
+    expect(data.cameras.right).toBeUndefined();
+  });
+});
+
+describe('frame metadata discovery', () => {
+  it('frameMetadataSourceDirectories returns the base path for a directory import', () => {
+    expect(common.frameMetadataSourceDirectories({
+      originalBasePath: '/data/set',
+      originalImageFiles: ['img001.png'],
+    })).toEqual([npath.resolve('/data/set')]);
+  });
+
+  it('frameMetadataSourceDirectories lists the image-list directory then the absolute image directory', () => {
+    expect(common.frameMetadataSourceDirectories({
+      originalBasePath: '',
+      originalImageFiles: ['/imgs/a.png'],
+      imageListPath: '/lists/list.txt',
+    })).toEqual([npath.resolve('/lists'), npath.resolve('/imgs')]);
+  });
+
+  it('frameMetadataSourceDirectories lists every absolute image directory from image-list entries', () => {
+    expect(common.frameMetadataSourceDirectories({
+      originalBasePath: '',
+      originalImageFiles: ['/imgs/a.png', '/extra/b.png', '/imgs/c.png'],
+      imageListPath: '/lists/list.txt',
+    })).toEqual([npath.resolve('/lists'), npath.resolve('/imgs'), npath.resolve('/extra')]);
+  });
+
+  it('frameMetadataSourceDirectories dedupes directories that resolve to the same path', () => {
+    expect(common.frameMetadataSourceDirectories({
+      originalBasePath: '/data',
+      originalImageFiles: ['/data/a.png'],
+      imageListPath: '/data/list.txt',
+    })).toEqual([npath.resolve('/data')]);
+  });
+
+  it('frameMetadataSourceDirectories supports a video media directory', () => {
+    expect(common.frameMetadataSourceDirectories({
+      originalBasePath: '/data/video',
+      originalVideoFile: 'movie.mp4',
+    })).toEqual([npath.resolve('/data/video')]);
+  });
+
+  it('frameMetadataSourceDirectories ignores a relative first image (covered by the base path)', () => {
+    expect(common.frameMetadataSourceDirectories({
+      originalBasePath: '/base',
+      originalImageFiles: ['sub/a.png'],
+    })).toEqual([npath.resolve('/base')]);
+  });
+});
+
+describe('frame metadata import gates', () => {
+  it('picks the annotation CSV and leaves a declared frame metadata sidecar in place', async () => {
+    // 'frame_metadata.csv' sorts first but is declared frame metadata: it must be skipped as a
+    // track-file candidate and stay on disk for read-time discovery.
+    const dir = '/home/user/data/fmGateMixed';
+    const payload = await common.beginMediaImport(dir);
+    expect(payload.trackFileAbsPath).toBe(npath.join(dir, 'zzz_annotations.csv'));
+    expect(payload.metadataFileAbsPath).toBe(npath.join(dir, 'frame_metadata.csv'));
+    expect(fs.existsSync(npath.join(dir, 'frame_metadata.csv'))).toBe(true);
+  });
+
+  it('leaves no track file when only a declared frame metadata sidecar is present', async () => {
+    const payload = await common.beginMediaImport('/home/user/data/fmGateFrameMetadataOnly');
+    expect(payload.trackFileAbsPath).toBeFalsy();
+  });
+
+  it('rejects an explicit import of a frame metadata file', async () => {
+    await expect(common.ingestDataFiles(
+      settings,
+      'projectid1',
+      ['/home/user/data/fmGateExplicit/frame_metadata.csv'],
+    )).rejects.toThrow(/frame metadata file/);
+  });
+
+  it('hints at the rename convention when a plain frame-metadata-shaped CSV fails VIAME import', async () => {
+    await expect(common.ingestDataFiles(
+      settings,
+      'projectid1',
+      ['/home/user/data/fmGateViameFail/nav.csv'],
+    )).rejects.toThrow(/rename it to frame-metadata\.csv/);
+  });
+});
+
 afterEach(() => {
   mockfs.restore();
 });
diff --git a/client/platform/desktop/backend/native/common.ts b/client/platform/desktop/backend/native/common.ts
index c6ae541e7..d13f093d4 100644
--- a/client/platform/desktop/backend/native/common.ts
+++ b/client/platform/desktop/backend/native/common.ts
@@ -27,7 +27,15 @@ import {
   Pipe,
   PipeMetadata,
   PipelineParamType,
+  FrameMetadataAttachmentText,
+  FrameMetadataSourcesResponse,
 } from 'dive-common/apispec';
+import { orderedMultiCamCameraNames } from 'dive-common/multicamDisplay';
+import isFrameMetadataSourceName from 'dive-common/frameMetadata/naming';
+import {
+  METADATA_ATTACHMENT_UNAVAILABLE, isFrameMetadataReadableName,
+} from 'dive-common/frameMetadata/readability';
+import { parentDatasetId, parseCompositeDatasetId } from 'dive-common/compositeDatasetId';
 import * as viameSerializers from 'platform/desktop/backend/serializers/viame';
 import * as nistSerializers from 'platform/desktop/backend/serializers/nist';
 import * as dive from 'platform/desktop/backend/serializers/dive';
@@ -38,7 +46,7 @@ import kpf from 'platform/desktop/backend/serializers/kpf';
 import { checkMedia } from 'platform/desktop/backend/native/mediaJobs';
 import {
   websafeImageTypes, websafeVideoTypes, otherImageTypes, otherVideoTypes, fileVideoTypes,
-  MultiType, JsonMetaRegEx, largeImageDesktopTypes,
+  MultiType, JsonMetaRegEx, largeImageDesktopTypes, metadataFileTypes,
 } from 'dive-common/constants';
 import {
   JsonMeta, Settings, JsonMetaCurrentVersion, DesktopMetadata,
@@ -51,7 +59,6 @@ import {
   cleanString, filterByGlob, makeid, strNumericCompare,
 } from 'platform/desktop/sharedUtils';
 import { parseFrameTimestamp } from 'dive-common/frameTimestamp';
-import { parseCompositeDatasetId } from 'dive-common/compositeDatasetId';
 
 import processTrackAttributes from './attributeProcessor';
 import { upgrade } from './migrations';
@@ -66,6 +73,8 @@ import { realCalibrationName } from './datasetCalibration';
 import { splitExt } from './utils';
 
 const AuxFolderName = 'auxiliary';
+// Where an export archive stores each dataset scope's metadata attachment.
+const ArchiveMetadataFolderName = 'metadata';
 
 const JsonTrackFileName = /^result(_.*)?\.json$/i;
 const JsonFileName = /^.*\.json$/i;
@@ -571,6 +580,331 @@ async function loadDetections(settings: Settings, datasetId: string) {
   return loadAnnotationFile(projectDirData.trackFileAbsPath);
 }
 
+/**
+ * Frame-metadata read path. Declared frame metadata sidecars are discovered on disk and read here.
+ * Parsing and resolving against media filenames happens in the renderer via the shared TypeScript
+ * resolver (dive-common/frameMetadata). Nothing derived is persisted; the sidecar the user dropped
+ * is the only stored form.
+ */
+interface FrameMetadataSource {
+  originalBasePath: string;
+  originalImageFiles?: string[];
+  imageListPath?: string;
+  originalVideoFile?: string;
+}
+
+// Directories that may hold a camera's sidecars: the media base path, the image-list directory,
+// and any absolute media paths. Deduped, order-preserving.
+function frameMetadataSourceDirectories(source: FrameMetadataSource): string[] {
+  const mediaPaths = [
+    ...(source.originalImageFiles ?? []),
+    ...(source.originalVideoFile ? [source.originalVideoFile] : []),
+  ];
+  const directories = [
+    source.originalBasePath,
+    source.imageListPath ? npath.dirname(source.imageListPath) : '',
+    // Only absolute media entries reveal extra directories; relative names are
+    // resolved against originalBasePath, already covered above.
+    ...mediaPaths
+      .filter((mediaPath) => npath.isAbsolute(mediaPath))
+      .map((mediaPath) => npath.dirname(mediaPath)),
+  ];
+  // uniq keeps first-occurrence order, so folder precedence (base path first) is preserved.
+  return uniq(directories.filter(Boolean).map((directory) => npath.resolve(directory)));
+}
+
+const multipleReservedMetadataAttachments = (
+  'More than one reserved-name metadata attachment is available.'
+);
+
+/**
+ * A missing directory, or a media/image-list FILE path where a directory was expected, simply
+ * holds no attachment. Every other readdir failure -- an unreadable directory, say -- stays an
+ * error: reading it as "nothing here" would report a dataset as having no attachment when its
+ * directory could not be read at all.
+ */
+function noEntriesIfAbsent(err: NodeJS.ErrnoException): never[] {
+  if (err.code === 'ENOENT' || err.code === 'ENOTDIR') {
+    return [];
+  }
+  throw err;
+}
+
+function listNames(directory: string): Promise<string[]> {
+  return fs.readdir(directory).catch(noEntriesIfAbsent);
+}
+
+async function reservedMetadataAttachmentPaths(directory: string): Promise<string[]> {
+  const names = await listNames(directory);
+  const candidates = names
+    .filter(isFrameMetadataSourceName)
+    .map((name) => npath.join(directory, name));
+  const files = await Promise.all(candidates.map(async (candidate) => {
+    try {
+      return (await fs.stat(candidate)).isFile() ? candidate : null;
+    } catch {
+      return null;
+    }
+  }));
+  return files.filter((candidate): candidate is string => candidate !== null);
+}
+
+/**
+ * The one reserved-name attachment in a media directory. Reserved-name discovery is only
+ * consulted when the user made no explicit choice, so an ambiguous directory is an error only
+ * in that case -- matching the server's explicit-then-reserved resolution order.
+ */
+async function reservedMetadataAttachmentPath(directory: string): Promise<string | undefined> {
+  const paths = await reservedMetadataAttachmentPaths(directory);
+  if (paths.length > 1) {
+    throw new Error(
+      `More than one metadata file was found in ${directory}. Keep one and try again.`,
+    );
+  }
+  return paths[0];
+}
+
+async function listArchiveMetadataFiles(directory: string): Promise<string[]> {
+  const entries: fs.Dirent[] = await fs.readdir(directory, { withFileTypes: true })
+    .catch(noEntriesIfAbsent);
+  const nested = await Promise.all(entries.map(async (entry) => {
+    const entryPath = npath.join(directory, entry.name);
+    return entry.isDirectory() ? listArchiveMetadataFiles(entryPath) : [entryPath];
+  }));
+  return nested.flat();
+}
+
+/**
+ * Whether a directory is one scope of an exported dataset. Every export writes a meta.json
+ * beside the media, and the server twin is only ever reached through
+ * `_load_exported_dataset_meta`, which requires one -- so the archive contract below is scoped
+ * the same way here. An ordinary media folder that happens to keep its own `metadata/`
+ * subdirectory is not an archive and must import untouched.
+ */
+async function isExportedDatasetDirectory(directory: string): Promise<boolean> {
+  return (await listNames(directory)).some((name) => JsonMetaRegEx.test(name));
+}
+
+/**
+ * The metadata attachment an export archive carries for one dataset directory: the single file
+ * under its `metadata/` subdirectory. meta.json's contents are never consulted -- a locator
+ * stored there would be a path from another machine -- so archives written by any DIVE version,
+ * including ones that carry no attachment at all, import the same way. The walk is recursive so
+ * an archive rewritten by a tool that nested the file is still imported.
+ * Mirrors `_archive_metadata_attachment` in server/dive_tasks/utils.py, error strings included.
+ */
+async function archiveMetadataAttachment(directory: string): Promise<string | undefined> {
+  if (!(await isExportedDatasetDirectory(directory))) {
+    return undefined;
+  }
+  const files = await listArchiveMetadataFiles(npath.join(directory, ArchiveMetadataFolderName));
+  if (!files.length) {
+    return undefined;
+  }
+  if (files.length > 1) {
+    throw new Error(
+      'More than one metadata file was found in the archive metadata directory.'
+      + ' Keep one and try again.',
+    );
+  }
+  const [attachment] = files;
+  if (!metadataFileTypes.includes(npath.extname(attachment).slice(1).toLowerCase())) {
+    throw new Error('Archive metadata attachment must be a JSON, TXT, or CSV file');
+  }
+  return attachment;
+}
+
+/**
+ * The attachment a media directory offers on import: an export archive's `metadata/` file
+ * first, then a reserved-name file lying beside the media.
+ */
+async function discoverMetadataAttachment(directory: string): Promise<string | undefined> {
+  const archived = await archiveMetadataAttachment(directory);
+  return archived ?? reservedMetadataAttachmentPath(directory);
+}
+
+/**
+ * Discovery for the single-dataset import, where the answer is only the value the import
+ * dialog's "Metadata File (Optional)" field opens with. That field is the one place the user
+ * can resolve an ambiguous or unreadable directory, and it appears only after this returns, so
+ * a discovery failure is reported as an import warning instead of refusing the whole dataset.
+ * The multicam path keeps the throw: its per-camera picks are already made when it runs.
+ */
+async function suggestMetadataAttachment(
+  directory: string,
+): Promise<{ path?: string; warning?: string }> {
+  try {
+    return { path: await discoverMetadataAttachment(directory) };
+  } catch (err) {
+    return { warning: (err as Error).message };
+  }
+}
+
+async function loadMetadataAttachment(
+  projectBasePath: string,
+  storedPath: string,
+  originalName?: string,
+): Promise<FrameMetadataAttachmentText> {
+  const absolutePath = npath.resolve(projectBasePath, storedPath);
+  const name = originalName || npath.basename(storedPath);
+  try {
+    const stat = await fs.stat(absolutePath);
+    if (!stat.isFile()) {
+      return { name, error: METADATA_ATTACHMENT_UNAVAILABLE };
+    }
+    if (!isFrameMetadataReadableName(name)) {
+      return { name };
+    }
+    return { name, text: await fs.readFile(absolutePath, 'utf-8') };
+  } catch {
+    return { name, error: METADATA_ATTACHMENT_UNAVAILABLE };
+  }
+}
+
+async function reservedMetadataAttachment(
+  directories: string[],
+): Promise<FrameMetadataAttachmentText | undefined> {
+  const resolvedDirectories = uniq(directories.map((directory) => npath.resolve(directory)));
+  async function resolveAt(index: number): Promise<FrameMetadataAttachmentText | undefined> {
+    const resolved = resolvedDirectories[index];
+    if (resolved === undefined) {
+      return undefined;
+    }
+    const paths = await reservedMetadataAttachmentPaths(resolved);
+    if (paths.length > 1) {
+      return {
+        name: 'Metadata File',
+        error: multipleReservedMetadataAttachments,
+      };
+    }
+    if (paths.length === 1) {
+      return loadMetadataAttachment(resolved, paths[0]);
+    }
+    return resolveAt(index + 1);
+  }
+  return resolveAt(0);
+}
+
+async function isExistingDirectory(path: string): Promise<boolean> {
+  try {
+    return (await fs.stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function commonParentDirectory(paths: string[]): string | null {
+  const resolved = paths.filter((item) => item).map((item) => npath.resolve(item));
+  if (!resolved.length) {
+    return null;
+  }
+  const [first, ...rest] = resolved;
+  const firstParts = first.split(npath.sep);
+  let { length } = firstParts;
+  rest.forEach((candidate) => {
+    const parts = candidate.split(npath.sep);
+    length = Math.min(length, parts.length);
+    for (let i = 0; i < length; i += 1) {
+      if (firstParts[i] !== parts[i]) {
+        length = i;
+        break;
+      }
+    }
+  });
+  const prefix = firstParts.slice(0, length).join(npath.sep);
+  // Return null rather than the filesystem root when cameras share no common prefix,
+  // so an unrelated-mount multicam never scans every sidecar at '/'.
+  return prefix || null;
+}
+
+async function loadMulticamFrameMetadata(
+  projectBasePath: string,
+  projectMetaData: JsonMeta,
+): Promise<FrameMetadataSourcesResponse> {
+  const { multiCam } = projectMetaData;
+  if (!multiCam) {
+    return { cameras: {} };
+  }
+
+  const cameraEntries = orderedMultiCamCameraNames({
+    cameras: multiCam.cameras,
+    defaultDisplay: multiCam.defaultDisplay,
+  }).map((cameraName) => [cameraName, multiCam.cameras[cameraName]] as const);
+
+  // originalBasePath is a directory for folder imports but a media/image-list FILE path for
+  // keyword imports, so fall back to the cameras' shared parent unless it is really a directory.
+  const rootDirectory = await isExistingDirectory(projectMetaData.originalBasePath)
+    ? projectMetaData.originalBasePath
+    : commonParentDirectory(cameraEntries.flatMap(([, camera]) => (
+      frameMetadataSourceDirectories(camera)
+    )));
+  const resolvedRoot = rootDirectory ? npath.resolve(rootDirectory) : null;
+  const shared = projectMetaData.metadataFile
+    ? await loadMetadataAttachment(
+      projectBasePath,
+      projectMetaData.metadataFile,
+      projectMetaData.metadataOriginalName,
+    )
+    : await reservedMetadataAttachment(rootDirectory ? [rootDirectory] : []);
+
+  const cameras: FrameMetadataSourcesResponse['cameras'] = {};
+
+  await Promise.all(cameraEntries.map(async ([cameraName, cameraMeta]) => {
+    if (cameraMeta.type !== 'image-sequence' && cameraMeta.type !== 'video') {
+      return;
+    }
+    if (cameraMeta.metadataFile) {
+      cameras[cameraName] = await loadMetadataAttachment(
+        projectBasePath,
+        cameraMeta.metadataFile,
+        cameraMeta.metadataOriginalName,
+      );
+      return;
+    }
+    // A camera-local reserved-name attachment stands on its own: the dataset-level attachment
+    // never suppresses it, however the shared one was declared.
+    const localDirectories = frameMetadataSourceDirectories(cameraMeta)
+      .filter((directory) => resolvedRoot === null || directory !== resolvedRoot);
+    const local = await reservedMetadataAttachment(localDirectories);
+    if (local) {
+      cameras[cameraName] = local;
+    }
+  }));
+
+  return {
+    ...(shared ? { shared } : {}),
+    cameras,
+  };
+}
+
+async function loadFrameMetadata(
+  settings: Settings,
+  datasetId: string,
+): Promise<FrameMetadataSourcesResponse> {
+  const parentId = parentDatasetId(datasetId);
+  const projectDirData = await getValidatedProjectDir(settings, parentId);
+  const projectMetaData = await loadJsonMetadata(projectDirData.metaFileAbsPath);
+
+  if (projectMetaData.type === MultiType) {
+    return loadMulticamFrameMetadata(projectDirData.basePath, projectMetaData);
+  }
+  if (projectMetaData.type !== 'image-sequence' && projectMetaData.type !== 'video') {
+    return { cameras: {} };
+  }
+
+  const shared = projectMetaData.metadataFile
+    ? await loadMetadataAttachment(
+      projectDirData.basePath,
+      projectMetaData.metadataFile,
+      projectMetaData.metadataOriginalName,
+    )
+    : await reservedMetadataAttachment(frameMetadataSourceDirectories(projectMetaData));
+  return {
+    ...(shared ? { shared } : {}),
+    cameras: {},
+  };
+}
+
 /**
  * Look through DIVE project path, find subfolders that
  * look like datasets, and return them.
@@ -922,6 +1256,11 @@ async function _ingestFilePath(
   if (fs.statSync(path).size === 0) {
     return null;
   }
+  // Frame-metadata sidecars are read from the media folder, so importing one as annotations would
+  // copy it into the wrong storage path.
+  if (isFrameMetadataSourceName(path)) {
+    throw new Error(`${npath.basename(path)} is a frame metadata file. Place it in the dataset's media folder; it cannot be imported as annotations.`);
+  }
   let warnings: string[] = [];
   // Make a copy of the file in aux
   const projectInfo = getProjectDir(settings, datasetId);
@@ -954,7 +1293,14 @@ async function _ingestFilePath(
     }
   } else if (CsvFileName.test(path)) {
     // VIAME CSV File
-    const data = await viameSerializers.parseFile(path, imageMap);
+    let data: Awaited<ReturnType<typeof viameSerializers.parseFile>>;
+    try {
+      data = await viameSerializers.parseFile(path, imageMap);
+    } catch (e) {
+      // A plain CSV that fails to parse as annotations is often frame metadata. Desktop has no
+      // in-viewer frame metadata import, so the rename convention is the only remedy to offer.
+      throw new Error(`${(e as Error).message} If this file is frame metadata rather than annotations, rename it to frame-metadata.csv and place it in the dataset's media folder.`);
+    }
     annotations.tracks = data[0].tracks;
     annotations.groups = data[0].groups;
     meta.fps = data[0].fps;
@@ -1160,7 +1506,10 @@ async function findTrackandMetaFileinFolder(path: string) {
   let { trackFileAbsPath } = results;
   const { metaFileAbsPath } = results;
   if (!trackFileAbsPath) {
-    const csvFileCandidates = await _findCSVTrackFiles(path);
+    // Declared frame metadata sidecars stay in place for read-time discovery; the first
+    // remaining CSV is unconditionally the annotation track file.
+    const csvFileCandidates = (await _findCSVTrackFiles(path))
+      .filter((candidate) => !isFrameMetadataSourceName(candidate));
     if (csvFileCandidates.length) {
       [trackFileAbsPath] = csvFileCandidates;
     }
@@ -1477,6 +1826,9 @@ async function beginMediaImport(path: string): Promise<DesktopMediaImportRespons
 
   const { trackFileAbsPath, metaFileAbsPath } = await
   findTrackandMetaFileinFolder(relatedDataSearchPath);
+  // The discovered attachment is a suggestion the import dialog shows and the user can clear or
+  // replace, so it travels on the response rather than on jsonMeta.
+  const metadata = await suggestMetadataAttachment(relatedDataSearchPath);
   return {
     jsonMeta,
     globPattern: '',
@@ -1485,6 +1837,8 @@ async function beginMediaImport(path: string): Promise<DesktopMediaImportRespons
     forceMediaTranscode: false,
     multiCamTrackFiles: null,
     metaFileAbsPath,
+    ...(metadata.path ? { metadataFileAbsPath: metadata.path } : {}),
+    ...(metadata.warning ? { importWarnings: [metadata.warning] } : {}),
   };
 }
 
@@ -1634,12 +1988,20 @@ async function finalizeMediaImport(
   const metadataSourcePath = args.metadataFileAbsPath || jsonMeta.metadataFile;
   if (metadataSourcePath) {
     const resolvedMetadataSource = npath.resolve(metadataSourcePath);
+    const metadataOriginalName = npath.basename(resolvedMetadataSource);
+    if (!metadataFileTypes.includes(npath.extname(metadataOriginalName).slice(1).toLowerCase())) {
+      throw new Error('Metadata attachment must be a JSON, TXT, or CSV file');
+    }
+    const metadataDir = npath.join(projectDirAbsPath, AuxFolderName);
+    await fs.ensureDir(metadataDir);
     const metadataDest = npath.join(
-      projectDirAbsPath,
-      npath.basename(resolvedMetadataSource),
+      metadataDir,
+      metadataOriginalName,
     );
-    await fs.copy(resolvedMetadataSource, metadataDest);
-    jsonMeta.metadataOriginalName = npath.basename(resolvedMetadataSource);
+    if (resolvedMetadataSource !== metadataDest) {
+      await fs.copy(resolvedMetadataSource, metadataDest);
+    }
+    jsonMeta.metadataOriginalName = metadataOriginalName;
     jsonMeta.metadataFile = metadataDest;
   } else {
     // Ensure a stale source path never survives when no file was chosen.
@@ -1647,6 +2009,27 @@ async function finalizeMediaImport(
     jsonMeta.metadataOriginalName = undefined;
   }
 
+  if (datasetType === MultiType && jsonMeta.multiCam?.cameras) {
+    const cameraEntries = Object.entries(jsonMeta.multiCam.cameras);
+    for (let i = 0; i < cameraEntries.length; i += 1) {
+      const [cameraName, camera] = cameraEntries[i];
+      if (camera.metadataFile) {
+        const source = npath.resolve(camera.metadataFile);
+        const originalName = npath.basename(camera.metadataOriginalName || source);
+        const cameraMetadataDir = npath.join(projectDirAbsPath, AuxFolderName, cameraName);
+        // eslint-disable-next-line no-await-in-loop
+        await fs.ensureDir(cameraMetadataDir);
+        const destination = npath.join(cameraMetadataDir, originalName);
+        if (source !== destination) {
+          // eslint-disable-next-line no-await-in-loop
+          await fs.copy(source, destination);
+        }
+        camera.metadataFile = destination;
+        camera.metadataOriginalName = originalName;
+      }
+    }
+  }
+
   // Filter all parts of the input based on glob pattern
   if (globPattern && jsonMeta.type === 'image-sequence') {
     const searchPath = jsonMeta.imageListPath || jsonMeta.originalBasePath;
@@ -1708,6 +2091,10 @@ async function finalizeMediaImport(
       const cameraData = cameraNameAndData[i][1];
 
       const jsonClone = { ...cloneDeep(jsonMeta), ...cameraData };
+      if (!cameraData.metadataFile) {
+        delete jsonClone.metadataFile;
+        delete jsonClone.metadataOriginalName;
+      }
       jsonClone.multiCam = null;
       jsonClone.id = `${jsonMeta.id}/${cameraName}`;
       jsonClone.transcodedVideoFile = cameraData.transcodedVideoFile || '';
@@ -1871,6 +2258,7 @@ async function exportConfiguration(settings: Settings, args: ExportConfiguration
 export {
   ProjectsFolderName,
   JobsFolderName,
+  ArchiveMetadataFolderName,
   autodiscoverData,
   bulkMediaImport,
   beginMediaImport,
@@ -1891,6 +2279,9 @@ export {
   loadJsonMetadata,
   loadAnnotationFile,
   loadDetections,
+  loadFrameMetadata,
+  frameMetadataSourceDirectories,
+  discoverMetadataAttachment,
   openLink,
   openPathInFileManager,
   ingestDataFiles,
@@ -1903,7 +2294,6 @@ export {
   listImmediateSubfolders,
   listParentFolderCameras,
   resolveMulticamCameraSourcePath,
-  findTrackandMetaFileinFolder,
 };
 
 export {
diff --git a/client/platform/desktop/backend/native/multiCam.spec.ts b/client/platform/desktop/backend/native/multiCam.spec.ts
index 5aa85350e..e1541139d 100644
--- a/client/platform/desktop/backend/native/multiCam.spec.ts
+++ b/client/platform/desktop/backend/native/multiCam.spec.ts
@@ -100,6 +100,188 @@ describe('native.multiCamImport', () => {
     expect(output.jsonMeta.name).toBe('my_stereo_scene');
   });
 
+  it('carries one camera-local metadata attachment into the camera record', async () => {
+    const metadataFile = '/home/user/data/local.csv';
+
+    const output = await beginMultiCamImport({
+      datasetName: 'my_stereo_scene',
+      defaultDisplay: 'left',
+      sourceList: {
+        left: {
+          sourcePath: '/home/user/data/stereoLeftRightImages/left',
+          trackFile: '',
+          metadataFile,
+        },
+        right: { sourcePath: '/home/user/data/stereoLeftRightImages/right', trackFile: '' },
+      },
+      type: 'image-sequence',
+    });
+
+    expect(output.jsonMeta.multiCam?.cameras.left.metadataFile).toBe(metadataFile);
+    expect(output.jsonMeta.multiCam?.cameras.left.metadataOriginalName).toBe('local.csv');
+    expect(output.jsonMeta.multiCam?.cameras.right.metadataFile).toBeUndefined();
+  });
+
+  it('discovers shared and camera archive attachments by directory', async () => {
+    const output = await beginMultiCamImport({
+      datasetName: 'archive_multicam',
+      defaultDisplay: 'left',
+      sourceList: {
+        left: { sourcePath: '/home/user/data/archiveMulticam/left', trackFile: '' },
+        right: { sourcePath: '/home/user/data/archiveMulticam/right', trackFile: '' },
+      },
+      type: 'image-sequence',
+    });
+
+    expect(output.jsonMeta.metadataFile)
+      .toBe('/home/user/data/archiveMulticam/metadata/shared.csv');
+    expect(output.jsonMeta.multiCam?.cameras.left.metadataFile)
+      .toBe('/home/user/data/archiveMulticam/left/metadata/local.csv');
+    expect(output.jsonMeta.multiCam?.cameras.right.metadataFile).toBeUndefined();
+  });
+
+  it('imports an archive whose meta.json carries only a legacy item-id locator', async () => {
+    // What today's upstream/main writes: a bare Girder item id in meta.json and the attachment
+    // at the archive root. Nothing to discover, and nothing to fail on.
+    const output = await beginMultiCamImport({
+      defaultDisplay: 'left',
+      sourceList: {
+        left: { sourcePath: '/home/user/data/upstreamArchiveMulticam/left', trackFile: '' },
+        right: { sourcePath: '/home/user/data/upstreamArchiveMulticam/right', trackFile: '' },
+      },
+      type: 'image-sequence',
+    });
+
+    expect(output.jsonMeta.metadataFile).toBeUndefined();
+    expect(output.jsonMeta.multiCam?.cameras.left.metadataFile).toBeUndefined();
+    expect(output.jsonMeta.multiCam?.cameras.right.metadataFile).toBeUndefined();
+  });
+
+  it('rejects an archive metadata directory holding more than one file', async () => {
+    await fs.writeFile('/home/user/data/archiveMulticam/metadata/extra.csv', 'filename,depth\n');
+
+    await expect(beginMultiCamImport({
+      defaultDisplay: 'left',
+      sourceList: {
+        left: { sourcePath: '/home/user/data/archiveMulticam/left', trackFile: '' },
+        right: { sourcePath: '/home/user/data/archiveMulticam/right', trackFile: '' },
+      },
+      type: 'image-sequence',
+    })).rejects.toThrow(
+      'More than one metadata file was found in the archive metadata directory.'
+      + ' Keep one and try again.',
+    );
+  });
+
+  it('rejects an archive metadata attachment of an unsupported type', async () => {
+    await fs.remove('/home/user/data/archiveMulticam/metadata/shared.csv');
+    await fs.writeFile('/home/user/data/archiveMulticam/metadata/shared.png', '');
+
+    await expect(beginMultiCamImport({
+      defaultDisplay: 'left',
+      sourceList: {
+        left: { sourcePath: '/home/user/data/archiveMulticam/left', trackFile: '' },
+        right: { sourcePath: '/home/user/data/archiveMulticam/right', trackFile: '' },
+      },
+      type: 'image-sequence',
+    })).rejects.toThrow('Archive metadata attachment must be a JSON, TXT, or CSV file');
+  });
+
+  it('finds an archive attachment a rewriting tool nested one level down', async () => {
+    // The Python twin walks metadata/ with rglob and pins this same shape in
+    // server/tests/test_multicam_zip_import.py. A flat-only readdir here would drop the file
+    // silently, because the import skips the metadata directory when uploading media.
+    await fs.remove('/home/user/data/archiveMulticam/metadata/shared.csv');
+    await fs.ensureDir('/home/user/data/archiveMulticam/metadata/nested');
+    await fs.writeFile(
+      '/home/user/data/archiveMulticam/metadata/nested/shared.csv',
+      'filename,depth\n',
+    );
+
+    const output = await beginMultiCamImport({
+      defaultDisplay: 'left',
+      sourceList: {
+        left: { sourcePath: '/home/user/data/archiveMulticam/left', trackFile: '' },
+        right: { sourcePath: '/home/user/data/archiveMulticam/right', trackFile: '' },
+      },
+      type: 'image-sequence',
+    });
+
+    expect(output.jsonMeta.metadataFile)
+      .toBe('/home/user/data/archiveMulticam/metadata/nested/shared.csv');
+  });
+
+  it('ignores an empty directory beside one archive attachment', async () => {
+    await fs.ensureDir('/home/user/data/archiveMulticam/metadata/empty');
+
+    const output = await beginMultiCamImport({
+      defaultDisplay: 'left',
+      sourceList: {
+        left: { sourcePath: '/home/user/data/archiveMulticam/left', trackFile: '' },
+        right: { sourcePath: '/home/user/data/archiveMulticam/right', trackFile: '' },
+      },
+      type: 'image-sequence',
+    });
+
+    expect(output.jsonMeta.metadataFile)
+      .toBe('/home/user/data/archiveMulticam/metadata/shared.csv');
+  });
+
+  it('lets an explicit camera pick stand where discovery finds an ambiguous folder', async () => {
+    // Two reserved-name files beside the media: the server prefers the explicit selection
+    // rather than refusing the folder, and so does desktop.
+    await fs.writeFile('/home/user/data/stereoLeftRightImages/left/frame_metadata.csv', 'filename,depth\n');
+    await fs.writeFile('/home/user/data/stereoLeftRightImages/left/frame-metadata.txt', 'filename,depth\n');
+
+    const output = await beginMultiCamImport({
+      defaultDisplay: 'left',
+      sourceList: {
+        left: {
+          sourcePath: '/home/user/data/stereoLeftRightImages/left',
+          trackFile: '',
+          metadataFile: '/home/user/data/local.csv',
+        },
+        right: { sourcePath: '/home/user/data/stereoLeftRightImages/right', trackFile: '' },
+      },
+      type: 'image-sequence',
+    });
+
+    expect(output.jsonMeta.multiCam?.cameras.left.metadataFile).toBe('/home/user/data/local.csv');
+  });
+
+  it('rejects an ambiguous camera folder when nothing was picked for it', async () => {
+    await fs.writeFile('/home/user/data/stereoLeftRightImages/left/frame_metadata.csv', 'filename,depth\n');
+    await fs.writeFile('/home/user/data/stereoLeftRightImages/left/frame-metadata.txt', 'filename,depth\n');
+
+    await expect(beginMultiCamImport({
+      defaultDisplay: 'left',
+      sourceList: {
+        left: { sourcePath: '/home/user/data/stereoLeftRightImages/left', trackFile: '' },
+        right: { sourcePath: '/home/user/data/stereoLeftRightImages/right', trackFile: '' },
+      },
+      type: 'image-sequence',
+    })).rejects.toThrow(
+      'More than one metadata file was found in /home/user/data/stereoLeftRightImages/left.'
+      + ' Keep one and try again.',
+    );
+  });
+
+  it('treats reserved metadata beside same-directory videos as shared', async () => {
+    const output = await beginMultiCamImport({
+      defaultDisplay: 'left',
+      sourceList: {
+        left: { sourcePath: '/home/user/data/sharedVideos/left.mp4', trackFile: '' },
+        right: { sourcePath: '/home/user/data/sharedVideos/right.mp4', trackFile: '' },
+      },
+      type: 'video',
+    });
+
+    expect(output.jsonMeta.metadataFile)
+      .toBe('/home/user/data/sharedVideos/frame_metadata.csv');
+    expect(output.jsonMeta.multiCam?.cameras.left.metadataFile).toBeUndefined();
+    expect(output.jsonMeta.multiCam?.cameras.right.metadataFile).toBeUndefined();
+  });
+
   if (multiCamSetup.folderTests) {
     const folderTests = (multiCamSetup.folderTests as FolderTest);
     Object.entries(folderTests).forEach(([key, val]) => {
diff --git a/client/platform/desktop/backend/native/multiCamImport.ts b/client/platform/desktop/backend/native/multiCamImport.ts
index 1a946a76e..db5520297 100644
--- a/client/platform/desktop/backend/native/multiCamImport.ts
+++ b/client/platform/desktop/backend/native/multiCamImport.ts
@@ -8,7 +8,8 @@ import {
   MultiCamImportArgs,
 } from 'dive-common/apispec';
 import {
-  websafeImageTypes, websafeVideoTypes, otherImageTypes, otherVideoTypes, MultiType,
+  websafeImageTypes, websafeVideoTypes, otherImageTypes, otherVideoTypes, metadataFileTypes,
+  MultiType,
 } from 'dive-common/constants';
 import { preferEoIrSubfolderOrder } from 'dive-common/components/ImportMultiCamDialog/multicamSubfolderLayout';
 import {
@@ -21,7 +22,7 @@ import { readTransformMatrix } from 'vue-media-annotator/alignedView/alignedView
 import {
   mergeRegistrationSources, unknownCameraWarning,
 } from 'vue-media-annotator/alignedView/cameraRegistrationFiles';
-import { findImagesInFolder } from './common';
+import { discoverMetadataAttachment, findImagesInFolder } from './common';
 import {
   CameraCorrespondences,
   CameraHomographies,
@@ -81,7 +82,17 @@ async function beginMultiCamImport(args: MultiCamImportArgs): Promise<DesktopMed
     if (!(args.defaultDisplay in args.sourceList)) {
       throw new Error(`${args.defaultDisplay} is not a camera name`);
     }
-    Object.entries(args.sourceList).forEach(([key, item]) => {
+    const sourceDirectories = Object.fromEntries(
+      Object.entries(args.sourceList).map(([key, item]) => [
+        key,
+        args.type === 'video' ? npath.dirname(item.sourcePath) : item.sourcePath,
+      ]),
+    );
+    const sourceDirectoryCounts = Object.values(sourceDirectories).reduce(
+      (counts, directory) => counts.set(directory, (counts.get(directory) || 0) + 1),
+      new Map<string, number>(),
+    );
+    await asyncForEach(Object.entries(args.sourceList), async ([key, item]) => {
       const pathExists = fs.existsSync(item.sourcePath);
       if (!pathExists) {
         throw new Error(`file or directory for ${key} not found: ${item.sourcePath}`);
@@ -94,6 +105,25 @@ async function beginMultiCamImport(args: MultiCamImportArgs): Promise<DesktopMed
         transcodedImageFiles: [],
         transcodedVideoFile: '',
       };
+      // Discovery runs only when the user picked nothing for this camera, and only when the
+      // camera owns its directory: a directory shared by several cameras is resolved once at
+      // the dataset scope below.
+      const sourceDirectory = sourceDirectories[key];
+      const discoverable = !item.metadataFile
+        && sourceDirectoryCounts.get(sourceDirectory) === 1;
+      const cameraMetadataFile = item.metadataFile
+        || (discoverable ? await discoverMetadataAttachment(sourceDirectory) : undefined);
+      if (cameraMetadataFile) {
+        if (!fs.existsSync(cameraMetadataFile) || !fs.statSync(cameraMetadataFile).isFile()) {
+          throw new Error(`metadata file for ${key} not found: ${cameraMetadataFile}`);
+        }
+        const extension = npath.extname(cameraMetadataFile).slice(1).toLowerCase();
+        if (!metadataFileTypes.includes(extension)) {
+          throw new Error(`Camera "${key}" metadata must be a JSON, TXT, or CSV file`);
+        }
+        cameras[key].metadataFile = cameraMetadataFile;
+        cameras[key].metadataOriginalName = npath.basename(cameraMetadataFile);
+      }
       if (args.type === 'video') {
         // Reset the base path to a folder for videos
         cameras[key].originalBasePath = npath.dirname(cameras[key].originalBasePath);
@@ -178,6 +208,27 @@ async function beginMultiCamImport(args: MultiCamImportArgs): Promise<DesktopMed
     });
   }
 
+  let sharedMetadataFile: string | undefined;
+  if (isFolderArgs(args)) {
+    const cameraDirectories = Object.values(args.sourceList).map((item) => (
+      args.type === 'video' ? npath.dirname(item.sourcePath) : item.sourcePath
+    ));
+    const uniqueCameraDirectories = [...new Set(cameraDirectories)];
+    const parentCandidates = [...new Set(
+      uniqueCameraDirectories.map((path) => npath.dirname(path)),
+    )];
+    let sharedDirectory: string | undefined;
+    if (uniqueCameraDirectories.length === 1) {
+      [sharedDirectory] = uniqueCameraDirectories;
+    } else if (parentCandidates.length === 1) {
+      [sharedDirectory] = parentCandidates;
+    }
+    sharedMetadataFile = args.metadataFile
+      || (sharedDirectory ? await discoverMetadataAttachment(sharedDirectory) : undefined);
+  } else {
+    sharedMetadataFile = args.metadataFile || undefined;
+  }
+
   const jsonMeta: JsonMeta = {
     version: JsonMetaCurrentVersion,
     type: datasetType,
@@ -201,7 +252,7 @@ async function beginMultiCamImport(args: MultiCamImportArgs): Promise<DesktopMed
     },
     // Stash the metadata source path; finalizeMediaImport copies it into the
     // project directory and rewrites this to the stored copy's path.
-    metadataFile: args.metadataFile || undefined,
+    metadataFile: sharedMetadataFile,
     subType: null,
   };
   if (Object.keys(seedHomographies).length || Object.keys(seedCorrespondences).length) {
diff --git a/client/platform/desktop/backend/native/multicamExport.spec.ts b/client/platform/desktop/backend/native/multicamExport.spec.ts
new file mode 100644
index 000000000..dac8d921f
--- /dev/null
+++ b/client/platform/desktop/backend/native/multicamExport.spec.ts
@@ -0,0 +1,207 @@
+import mockfs from 'mock-fs';
+import npath from 'path';
+import fs from 'fs-extra';
+
+import type { Settings } from 'platform/desktop/constants';
+import { exportMulticamEverything } from './multicamExport';
+
+/**
+ * Captures the staged export directory before it is zipped and removed. Zipping is the only
+ * thing replaced here; everything the export writes is real (mocked) filesystem work.
+ * mock-fs only backs the asynchronous fs API in this environment, so the snapshot is async and
+ * the mocked archive holds its "finished" event until the snapshot completes.
+ */
+const zipMock = vi.hoisted(() => ({
+  staged: {} as Record<string, string>,
+  snapshot: null as null | ((dir: string) => Promise<Record<string, string>>),
+}));
+
+vi.mock('archiver', () => ({
+  default: () => {
+    let piped: { end: () => void } | undefined;
+    let pending: Promise<unknown> = Promise.resolve();
+    const archive = {
+      on: () => archive,
+      pipe: (output: { end: () => void }) => { piped = output; },
+      directory: (sourceDir: string) => {
+        pending = zipMock.snapshot!(sourceDir)
+          .then((tree) => Object.assign(zipMock.staged, tree));
+      },
+      finalize: () => { pending.then(() => piped?.end()); },
+    };
+    return archive;
+  },
+}));
+
+async function snapshot(dir: string, prefix = ''): Promise<Record<string, string>> {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  const trees = await Promise.all(entries.map(async (entry) => {
+    const full = npath.join(dir, entry.name);
+    const key = prefix ? `${prefix}/${entry.name}` : entry.name;
+    return entry.isDirectory()
+      ? snapshot(full, key)
+      : { [key]: await fs.readFile(full, 'utf-8') };
+  }));
+  return Object.assign({}, ...trees);
+}
+zipMock.snapshot = (dir: string) => snapshot(dir);
+
+vi.mock('fs-extra', async () => {
+  const actual = await vi.importActual<typeof import('fs-extra')>('fs-extra');
+  const fsNode = await import('node:fs');
+  const existsByStat = (targetPath: fsNode.PathLike) => {
+    try {
+      fsNode.statSync(targetPath);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  const patchedDefault = { ...actual.default, existsSync: existsByStat, pathExistsSync: existsByStat };
+  return {
+    ...actual, default: patchedDefault, existsSync: existsByStat, pathExistsSync: existsByStat,
+  };
+});
+
+const settings: Settings = {
+  version: 1,
+  dataPath: '/home/user/viamedata',
+  viamePath: '/opt/viame',
+  readonlyMode: false,
+  overrides: {},
+};
+
+const projectDir = '/home/user/viamedata/DIVE_Projects/multicamExport';
+
+function cameraMeta(camera: string) {
+  return {
+    version: 1,
+    id: `multicamExport/${camera}`,
+    name: camera,
+    type: 'image-sequence',
+    fps: 5,
+    originalFps: 5,
+    originalBasePath: `/home/user/data/multicamExport/${camera}`,
+    originalImageFiles: [`img_${camera}.png`],
+    originalVideoFile: '',
+    transcodedImageFiles: [],
+    transcodedVideoFile: '',
+    multiCam: null,
+    subType: null,
+  };
+}
+
+beforeEach(() => {
+  zipMock.staged = {};
+  mockfs({
+    '/tmp': {},
+    '/home/user/output': {},
+    '/home/user/data/multicamExport': {
+      left: { 'img_left.png': '' },
+      right: { 'img_right.png': '' },
+    },
+    '/home/user/viamedata': {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      DIVE_Projects: {
+        multicamExport: {
+          'meta.json': JSON.stringify({
+            version: 1,
+            id: 'multicamExport',
+            name: 'reef_survey',
+            type: 'multi',
+            fps: 5,
+            originalFps: 5,
+            originalBasePath: '/home/user/data/multicamExport',
+            originalImageFiles: [],
+            originalVideoFile: '',
+            transcodedImageFiles: [],
+            transcodedVideoFile: '',
+            subType: 'stereo',
+            metadataFile: `${projectDir}/auxiliary/flight_log.csv`,
+            metadataOriginalName: 'flight_log.csv',
+            multiCam: {
+              defaultDisplay: 'left',
+              cameraOrder: ['left', 'right'],
+              cameras: {
+                left: {
+                  ...cameraMeta('left'),
+                  metadataFile: `${projectDir}/auxiliary/left/left_log.csv`,
+                  metadataOriginalName: 'left_log.csv',
+                },
+                right: cameraMeta('right'),
+              },
+            },
+          }),
+          'result_1.json': JSON.stringify({}),
+          auxiliary: {
+            'flight_log.csv': 'filename,altitude\nimg_left.png,120\n',
+            left: { 'left_log.csv': 'filename,depth\nimg_left.png,10\n' },
+          },
+          left: {
+            'meta.json': JSON.stringify({
+              ...cameraMeta('left'),
+              metadataFile: `${projectDir}/auxiliary/left/left_log.csv`,
+              metadataOriginalName: 'left_log.csv',
+            }),
+            'result_1.json': JSON.stringify({}),
+            auxiliary: {},
+          },
+          right: {
+            'meta.json': JSON.stringify(cameraMeta('right')),
+            'result_1.json': JSON.stringify({}),
+            auxiliary: {},
+          },
+        },
+      },
+    },
+  });
+});
+
+afterEach(() => {
+  mockfs.restore();
+});
+
+describe('exportMulticamEverything', () => {
+  it('writes each scope\'s attachment under its own metadata directory', async () => {
+    const path = await exportMulticamEverything(settings, {
+      id: 'multicamExport',
+      path: '/home/user/output/reef_survey.zip',
+      exclude: false,
+      typeFilter: new Set<string>(),
+    });
+
+    expect(path).toBe('/home/user/output/reef_survey.zip');
+    // Dataset scope at <dataset>/metadata/, camera scope at <dataset>/<camera>/metadata/ --
+    // the two places both importers look.
+    expect(zipMock.staged['reef_survey/metadata/flight_log.csv']).toContain('img_left.png,120');
+    expect(zipMock.staged['reef_survey/left/metadata/left_log.csv']).toContain('img_left.png,10');
+    expect(zipMock.staged['reef_survey/right/metadata/left_log.csv']).toBeUndefined();
+    expect(zipMock.staged['reef_survey/annotations.dive.json']).toBeDefined();
+    expect(zipMock.staged['reef_survey/left/annotations.dive.json']).toBeDefined();
+  });
+
+  it('never writes a local attachment path into the archive meta.json', async () => {
+    await exportMulticamEverything(settings, {
+      id: 'multicamExport',
+      path: '/home/user/output/reef_survey.zip',
+      exclude: false,
+      typeFilter: new Set<string>(),
+    });
+
+    // A locator would be this machine's absolute path; a re-import would read it as a local
+    // file that does not exist there. Importers discover the attachment by directory instead.
+    const meta = JSON.parse(zipMock.staged['reef_survey/meta.json']);
+    expect(meta.metadataFile).toBeUndefined();
+    expect(meta.metadataOriginalName).toBeUndefined();
+    expect(meta.multiCam.cameras.left.metadataFile).toBeUndefined();
+    expect(meta.multiCam.cameras.left.metadataOriginalName).toBeUndefined();
+
+    const multiCam = JSON.parse(zipMock.staged['reef_survey/multiCam.json']);
+    expect(multiCam.cameras.left.metadataFile).toBeUndefined();
+
+    const leftMeta = JSON.parse(zipMock.staged['reef_survey/left/meta.json']);
+    expect(leftMeta.metadataFile).toBeUndefined();
+    expect(leftMeta.metadataOriginalName).toBeUndefined();
+  });
+});
diff --git a/client/platform/desktop/backend/native/multicamExport.ts b/client/platform/desktop/backend/native/multicamExport.ts
index 886194cc4..945562134 100644
--- a/client/platform/desktop/backend/native/multicamExport.ts
+++ b/client/platform/desktop/backend/native/multicamExport.ts
@@ -7,16 +7,21 @@ import os from 'os';
 import fs from 'fs-extra';
 import { createWriteStream } from 'fs';
 import archiver from 'archiver';
+import { omit } from 'lodash';
 
 import { MultiType } from 'dive-common/constants';
 import { orderedMultiCamCameraNames } from 'dive-common/multicamDisplay';
 import { buildPerCameraRegistrationFiles } from 'vue-media-annotator/alignedView/cameraRegistrationFiles';
-import { ExportMulticamEverythingArgs, Settings } from 'platform/desktop/constants';
+import {
+  Camera, ExportMulticamEverythingArgs, JsonMeta, Settings,
+} from 'platform/desktop/constants';
 import * as viameSerializers from 'platform/desktop/backend/serializers/viame';
 import * as dive from 'platform/desktop/backend/serializers/dive';
 
 // eslint-disable-next-line import/no-cycle
-import { getValidatedProjectDir, loadAnnotationFile, loadJsonMetadata } from './common';
+import {
+  ArchiveMetadataFolderName, getValidatedProjectDir, loadAnnotationFile, loadJsonMetadata,
+} from './common';
 import {
   findParentFolderCalibrationFile,
   getDatasetCalibrationExportPath,
@@ -29,8 +34,28 @@ async function writeJsonFile(absPath: string, data: unknown): Promise<void> {
   await fs.writeFile(absPath, JSON.stringify(data, null, 2));
 }
 
+/**
+ * Attachment locators never travel in an archive: `metadataFile` holds this machine's absolute
+ * path, which a re-import would read as a local file that does not exist there. The attachment
+ * itself travels as the single file in each scope's `metadata/` directory, which is where both
+ * importers look for it.
+ */
+function withoutMetadataAttachment<T extends JsonMeta | Camera>(scope: T) {
+  return omit(scope, ['metadataFile', 'metadataOriginalName']);
+}
+
 function buildExportMetaJson(meta: JsonMeta): Record<string, unknown> {
-  const output: Record<string, unknown> = { ...meta };
+  const output: Record<string, unknown> = withoutMetadataAttachment(meta);
+  if (meta.multiCam?.cameras) {
+    output.multiCam = {
+      ...meta.multiCam,
+      cameras: Object.fromEntries(
+        Object.entries(meta.multiCam.cameras).map(([cameraName, camera]) => [
+          cameraName, withoutMetadataAttachment(camera),
+        ]),
+      ),
+    };
+  }
   if (meta.type === 'image-sequence') {
     const files = meta.transcodedImageFiles?.length
       ? meta.transcodedImageFiles
@@ -61,7 +86,17 @@ async function writeDatasetExportContents(
   };
 
   await fs.ensureDir(destDir);
-  await fs.writeJSON(npath.join(destDir, 'meta.json'), buildExportMetaJson(meta), { spaces: 2 });
+  const exportMeta = buildExportMetaJson(meta);
+  if (meta.metadataFile) {
+    if (!await fs.pathExists(meta.metadataFile)) {
+      throw new Error(`Metadata attachment is missing: ${meta.metadataFile}`);
+    }
+    const metadataName = npath.basename(meta.metadataOriginalName ?? meta.metadataFile);
+    const metadataDir = npath.join(destDir, ArchiveMetadataFolderName);
+    await fs.ensureDir(metadataDir);
+    await fs.copy(meta.metadataFile, npath.join(metadataDir, metadataName));
+  }
+  await fs.writeJSON(npath.join(destDir, 'meta.json'), exportMeta, { spaces: 2 });
   await dive.serializeFile(
     npath.join(destDir, 'annotations.dive.json'),
     data,
@@ -117,7 +152,7 @@ export async function exportMulticamEverything(
     await fs.ensureDir(datasetDir);
     await fs.writeJSON(
       npath.join(datasetDir, 'multiCam.json'),
-      parentMeta.multiCam,
+      buildExportMetaJson(parentMeta).multiCam,
       { spaces: 2 },
     );
     await writeDatasetExportContents(
@@ -136,13 +171,6 @@ export async function exportMulticamEverything(
       await fs.copy(calibrationPath, npath.join(datasetDir, calibrationName));
     }
 
-    // Optional pipeline metadata sidecar (e.g. flight log), same as web full export.
-    if (parentMeta.metadataFile && await fs.pathExists(parentMeta.metadataFile)) {
-      const metadataName = parentMeta.metadataOriginalName
-        ?? npath.basename(parentMeta.metadataFile);
-      await fs.copy(parentMeta.metadataFile, npath.join(datasetDir, metadataName));
-    }
-
     // Regenerate the camera registration as its per-camera files so the
     // zip carries it even when only the import-time seed exists.
     const rigRegistration = await loadEffectiveRegistration(parentDirInfo.basePath, parentMeta);
diff --git a/client/platform/desktop/backend/serializers/viame.ts b/client/platform/desktop/backend/serializers/viame.ts
index 414a1ad1d..bce98969b 100644
--- a/client/platform/desktop/backend/serializers/viame.ts
+++ b/client/platform/desktop/backend/serializers/viame.ts
@@ -11,7 +11,9 @@ import moment from 'moment';
 import { cloneDeep, flattenDeep, isEmpty } from 'lodash';
 import { pipeline, Readable, Writable } from 'stream';
 
-import { AnnotationSchema, MultiGroupRecord, MultiTrackRecord } from 'dive-common/apispec';
+import {
+  AnnotationSchema, DatasetInfoFields, MultiGroupRecord, MultiTrackRecord,
+} from 'dive-common/apispec';
 import { JsonMeta } from 'platform/desktop/constants';
 import { splitExt } from 'platform/desktop/backend/native/utils';
 // Imports that involve actual code require relative imports because ts-node barely works
@@ -44,7 +46,7 @@ export interface AnnotationFileData {
   groups: MultiGroupRecord;
   fps?: number;
   execTime?: number;
-  datasetInfo?: Record<string, unknown>;
+  datasetInfo?: DatasetInfoFields;
 }
 
 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/matchAll
@@ -126,11 +128,11 @@ function syncDetectionLengthFields(feature: Feature): Feature {
 }
 
 /**
- * Read dataset metadata from a `dataset_info: <json>` comment field. Returns the parsed
+ * Read dataset info from a `dataset_info: <json>` comment field. Returns the parsed
  * object, or a `warning` if the field is present but unusable so the import can continue.
  */
 function parseDatasetInfo(row: string[]): {
-  datasetInfo?: Record<string, unknown>;
+  datasetInfo?: DatasetInfoFields;
   warning?: string;
 } {
   const field = row.find((f) => f.trim().startsWith('dataset_info:'));
@@ -141,7 +143,7 @@ function parseDatasetInfo(row: string[]): {
   try {
     const parsed = JSON.parse(json);
     if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-      return { datasetInfo: parsed as Record<string, unknown> };
+      return { datasetInfo: parsed as DatasetInfoFields };
     }
     // eslint-disable-next-line no-nested-ternary
     const kind = parsed === null ? 'null' : Array.isArray(parsed) ? 'array' : typeof parsed;
@@ -415,7 +417,7 @@ async function parse(input: Readable, imageMap?: Map<string, number>): Promise<[
   });
   let fps: number | undefined;
   let execTime: number | undefined;
-  let datasetInfo: Record<string, unknown> | undefined;
+  let datasetInfo: DatasetInfoFields | undefined;
   const dataMap = new Map<number, TrackData>();
   const missingImages: string[] = [];
   const foundImages: {image: string; frame: number; csvFrame: number}[] = [];
diff --git a/client/platform/desktop/constants.ts b/client/platform/desktop/constants.ts
index 09d3f18ef..fcefcb9a3 100644
--- a/client/platform/desktop/constants.ts
+++ b/client/platform/desktop/constants.ts
@@ -46,6 +46,10 @@ export interface Camera {
   transcodedVideoFile: string;
   transcodedMisalign?: boolean;
   imageListPath?: string;
+  /** Stored camera-local metadata attachment path. */
+  metadataFile?: string;
+  /** Preserved original name of the camera-local metadata attachment. */
+  metadataOriginalName?: string;
 }
 
 export interface MultiCamDesktop {
@@ -273,7 +277,9 @@ export interface DesktopMediaImportResponse extends MediaImportResponse {
   multiCamTrackFiles: null | Record<string, string>;
   forceMediaTranscode: boolean;
   metaFileAbsPath?: string;
-  // Absolute path of an optional metadata file chosen in the import dialog.
+  // Absolute path of the one optional metadata attachment. Seeded by import-time discovery
+  // (an exported folder's metadata/ directory, or a reserved-name file beside the media) and
+  // shown in the import dialog, where the user can clear or replace it before finalize.
   metadataFileAbsPath?: string;
   // Non-fatal problems found while preparing the import (e.g. a registration
   // file naming cameras this dataset doesn't have), shown in the import dialog.
diff --git a/client/platform/desktop/frontend/api.ts b/client/platform/desktop/frontend/api.ts
index 69d6dc309..c449db5a2 100644
--- a/client/platform/desktop/frontend/api.ts
+++ b/client/platform/desktop/frontend/api.ts
@@ -4,7 +4,7 @@ import type {
   DatasetMetaMutable, DatasetType, MultiCamImportArgs,
   Pipe, Pipelines, PipelineParams, SaveAttributeArgs,
   SaveAttributeTrackFilterArgs, SaveDetectionsArgs, TrainingConfigs,
-  DatasetCalibrationResult,
+  DatasetCalibrationResult, FrameMetadataSourcesResponse,
   SegmentationPredictRequest, SegmentationPredictResponse, SegmentationStatusResponse,
   SegmentationStereoSegmentRequest, SegmentationStereoSegmentResponse,
   TextQueryRequest, TextQueryResponse, RefineDetectionsRequest, RefineDetectionsResponse,
@@ -632,6 +632,10 @@ async function loadDetections(datasetId: string) {
   };
 }
 
+function loadFrameMetadata(datasetId: string): Promise<FrameMetadataSourcesResponse> {
+  return window.diveDesktop.invoke('load-frame-metadata', { datasetId });
+}
+
 async function saveMetadata(id: string, args: DatasetMetaMutable) {
   const client = await getClient();
   return client.post(`dataset/${id}/meta`, args);
@@ -711,6 +715,7 @@ export {
   /* Standard Specification APIs */
   loadMetadata,
   loadDetections,
+  loadFrameMetadata,
   getPipelineList,
   deleteTrainedPipeline,
   runPipeline,
diff --git a/client/platform/desktop/frontend/components/ImportDialog.vue b/client/platform/desktop/frontend/components/ImportDialog.vue
index 62504c956..a03585fae 100644
--- a/client/platform/desktop/frontend/components/ImportDialog.vue
+++ b/client/platform/desktop/frontend/components/ImportDialog.vue
@@ -271,8 +271,8 @@ export default defineComponent({
           class="mt-3"
           prepend-inner-icon="mdi-file-cog"
           label="Metadata File (Optional)"
-          hint="Optional. A .json, .txt, or .csv file passed to pipelines that request it
-            (e.g. a sea-lion flight log)."
+          hint="Passed to pipelines that request it. CSV and TXT frame rows also appear as
+            Frame Metadata (e.g. a sea-lion flight log)."
           persistent-hint
           @input="argCopy.metadataFileAbsPath = $event"
           @click="openUpload('metadata')"
diff --git a/client/platform/web-girder/App.vue b/client/platform/web-girder/App.vue
index b4f16e2bf..921b4510a 100644
--- a/client/platform/web-girder/App.vue
+++ b/client/platform/web-girder/App.vue
@@ -17,6 +17,7 @@ import {
   runPipeline,
   exportTrainedPipeline,
   getDatasetCalibration,
+  loadFrameMetadata,
   getTrainingConfigurations,
   runTraining,
   saveMetadata,
@@ -70,6 +71,7 @@ export default defineComponent({
       getTrainingConfigurations: unwrap(getTrainingConfigurations),
       runTraining: unwrap(runTraining),
       loadDetections,
+      loadFrameMetadata,
       saveDetections: unwrap(saveDetections),
       saveMetadata: unwrap(saveMetadata),
       saveAttributes: unwrap(saveAttributes),
diff --git a/client/platform/web-girder/api/dataset.service.spec.ts b/client/platform/web-girder/api/dataset.service.spec.ts
new file mode 100644
index 000000000..176800413
--- /dev/null
+++ b/client/platform/web-girder/api/dataset.service.spec.ts
@@ -0,0 +1,49 @@
+// eslint-disable-next-line import/no-extraneous-dependencies -- Vitest is only used in tests
+import {
+  beforeEach, describe, expect, it, vi,
+} from 'vitest';
+
+import girderRest from 'platform/web-girder/plugins/girder';
+import { uploadAndSetMetadataFile } from './dataset.service';
+
+vi.mock('platform/web-girder/plugins/girder', () => ({
+  default: {
+    get: vi.fn(),
+    post: vi.fn(),
+  },
+}));
+
+function metadataFile() {
+  return new File(['filename,depth\nimg.png,10\n'], 'metadata.csv', { type: 'text/csv' });
+}
+
+describe('uploadAndSetMetadataFile', () => {
+  beforeEach(() => {
+    vi.mocked(girderRest.get).mockReset();
+    vi.mocked(girderRest.post).mockReset();
+  });
+
+  it('uploads the file as an item, then declares that item as the attachment', async () => {
+    vi.mocked(girderRest.post)
+      .mockResolvedValueOnce({ data: { _id: 'item-id' } })
+      .mockResolvedValueOnce({ data: { _id: 'upload-id' } })
+      .mockResolvedValueOnce({ data: {} })
+      .mockResolvedValueOnce({ data: {} });
+
+    await expect(uploadAndSetMetadataFile('folder-id', metadataFile())).resolves.toBeUndefined();
+
+    expect(vi.mocked(girderRest.post).mock.calls[3][0]).toBe('dive_dataset/folder-id/metadata_file');
+    expect(vi.mocked(girderRest.post).mock.calls[3][2]).toEqual({ params: { itemId: 'item-id' } });
+  });
+
+  it('surfaces a rejected declaration to the caller', async () => {
+    const error = { response: { status: 400 } };
+    vi.mocked(girderRest.post)
+      .mockResolvedValueOnce({ data: { _id: 'item-id' } })
+      .mockResolvedValueOnce({ data: { _id: 'upload-id' } })
+      .mockResolvedValueOnce({ data: {} })
+      .mockRejectedValueOnce(error);
+
+    await expect(uploadAndSetMetadataFile('folder-id', metadataFile())).rejects.toBe(error);
+  });
+});
diff --git a/client/platform/web-girder/api/dataset.service.ts b/client/platform/web-girder/api/dataset.service.ts
index 9a9e9b423..3f584d6a9 100644
--- a/client/platform/web-girder/api/dataset.service.ts
+++ b/client/platform/web-girder/api/dataset.service.ts
@@ -5,9 +5,12 @@ import {
   registrationValuesSummary, filterRegistrationValues, mergeRegistrationValues,
 } from 'vue-media-annotator/alignedView/cameraRegistrationFiles';
 import {
-  DatasetMetaMutable, DatasetType, FrameImage, SaveAttributeArgs, SaveAttributeTrackFilterArgs,
+  DatasetMetaMutable, DatasetType, FrameImage,
+  SaveAttributeArgs, SaveAttributeTrackFilterArgs,
 } from 'dive-common/apispec';
-import { calibrationFileMarker, jsonCalibrationFileMarker, metadataFileMarker } from 'dive-common/constants';
+import {
+  calibrationFileMarker, jsonCalibrationFileMarker,
+} from 'dive-common/constants';
 import { attachFrameTimestamps } from 'dive-common/frameTimestamp';
 import { parentDatasetId } from 'dive-common/compositeDatasetId';
 import { isStereoCalibrationFileName } from 'dive-common/stereoParentFolder';
@@ -135,42 +138,64 @@ function makeViameFolder({
   );
 }
 
-async function importAnnotationFile(datasetId: string, path: string, file?: HTMLFile, additive = false, additivePrepend = '', set: string | undefined = undefined): Promise<boolean | string[]> {
-  if (file === undefined) {
-    return false;
-  }
-  // Resolve composite multicam ids (parent/camera) to the camera folder so
-  // annotations land on the active camera; mutable config is synced to the
-  // parent by server process_items (same behavior as desktop dataFileImport).
-  const { folderId } = await resolveDatasetFolderId(datasetId);
+/**
+ * Girder's two-request upload to a folder: initialize the file, then push its single chunk.
+ * Resolves with the completed file document (which carries `itemId`, the id of the item
+ * Girder created for it) or null if either request did not succeed.
+ */
+async function uploadFileToFolder(parentId: string, file: File): Promise<{ itemId: string } | null> {
   const resp = await girderRest.post('/file', null, {
     params: {
       parentType: 'folder',
-      parentId: folderId,
+      parentId,
       name: file.name,
       size: file.size,
       mimeType: file.type,
     },
   });
-  if (resp.status === 200) {
-    const uploadResponse = await girderRest.post('file/chunk', file, {
-      params: {
-        uploadId: resp.data._id,
-        offset: 0,
-      },
-      headers: { 'Content-Type': 'application/octet-stream' },
-    });
-    if (uploadResponse.status === 200) {
-      const final = await postProcess(folderId, true, false, additive, additivePrepend, set);
-      if (final.data.warnings !== undefined) {
-        const { warnings } = final.data;
-        return warnings;
-      }
-
-      return final.status === 200;
-    }
+  if (resp.status !== 200) {
+    return null;
   }
-  return false;
+  const uploadResponse = await girderRest.post('file/chunk', file, {
+    params: {
+      uploadId: resp.data._id,
+      offset: 0,
+    },
+    headers: { 'Content-Type': 'application/octet-stream' },
+  });
+  return uploadResponse.status === 200 ? uploadResponse.data : null;
+}
+
+async function importAnnotationFile(datasetId: string, path: string, file?: HTMLFile, additive = false, additivePrepend = '', set: string | undefined = undefined): Promise<boolean | string[]> {
+  if (file === undefined) {
+    return false;
+  }
+  // Resolve composite multicam ids (parent/camera) to the camera folder so
+  // annotations land on the active camera; mutable config is synced to the
+  // parent by server process_items (same behavior as desktop dataFileImport).
+  const { folderId } = await resolveDatasetFolderId(datasetId);
+  const uploaded = await uploadFileToFolder(folderId, file);
+  if (uploaded === null) {
+    return false;
+  }
+  const final = await postProcess(folderId, true, false, additive, additivePrepend, set);
+  if (final.data.warnings !== undefined) {
+    const { warnings } = final.data;
+    return warnings;
+  }
+  return final.status === 200;
+}
+
+/** Upload a metadata file into the dataset folder and declare it as the attachment. */
+async function uploadAndSetMetadataFile(
+  datasetId: string,
+  file: HTMLFile,
+): Promise<void> {
+  const folderId = parentDatasetId(datasetId);
+  const itemId = await uploadMetadataFileItem(folderId, file);
+  await girderRest.post(`dive_dataset/${folderId}/metadata_file`, null, {
+    params: { itemId },
+  });
 }
 
 async function saveAttributes(datasetId: string, args: SaveAttributeArgs) {
@@ -247,7 +272,7 @@ async function importCameraRegistration(
   return summary;
 }
 
-export type UploadRole = 'media' | 'annotations' | 'datasetConfig' | 'ignored';
+export type UploadRole = 'media' | 'annotations' | 'datasetConfig' | 'frameMetadata' | 'ignored';
 
 /** Every validated filename under exactly one role. `ignored` is the files not accepted. */
 export type ValidatedUploadRoleMap = Record<UploadRole, string[]>;
@@ -350,16 +375,13 @@ async function uploadCalibrationItem(parentFolderId: string, file: File): Promis
 }
 
 /**
- * Upload an optional per-dataset metadata file as a marked Girder item in the
- * dataset (parent) folder and return its item id.
+ * Upload an optional per-dataset metadata file and return its item id.
  */
 async function uploadMetadataFileItem(parentFolderId: string, file: File): Promise<string> {
-  const metadataMeta = { [metadataFileMarker]: 'true' };
   const itemResp = await girderRest.post<GirderModel>('/item', null, {
     params: {
       folderId: parentFolderId,
       name: file.name,
-      metadata: JSON.stringify(metadataMeta),
     },
   });
   const itemId = itemResp.data._id;
@@ -379,18 +401,9 @@ async function uploadMetadataFileItem(parentFolderId: string, file: File): Promi
     },
     headers: { 'Content-Type': 'application/octet-stream' },
   });
-  // Girder item metadata is set via PUT item/:id/metadata (not PUT item/:id).
-  await girderRest.put(`item/${itemId}/metadata`, metadataMeta);
   return itemId;
 }
 
-/** Mark an already-uploaded metadata item as the dataset's metadata file. */
-function setDatasetMetadataFile(folderId: string, itemId: string) {
-  return girderRest.post(`dive_dataset/${folderId}/metadata_file`, null, {
-    params: { itemId },
-  });
-}
-
 function calibrationMarkerTruthy(meta: Record<string, unknown> | undefined, key: string): boolean {
   const marker = meta?.[key];
   return marker === true || marker === 'true' || marker === '1';
@@ -462,7 +475,7 @@ export {
   saveAttributeTrackFilters,
   saveMetadata,
   uploadCalibrationItem,
+  uploadAndSetMetadataFile,
   uploadMetadataFileItem,
-  setDatasetMetadataFile,
   validateUploadGroup,
 };
diff --git a/client/platform/web-girder/api/frameMetadata.service.spec.ts b/client/platform/web-girder/api/frameMetadata.service.spec.ts
new file mode 100644
index 000000000..65c47a550
--- /dev/null
+++ b/client/platform/web-girder/api/frameMetadata.service.spec.ts
@@ -0,0 +1,88 @@
+// eslint-disable-next-line import/no-extraneous-dependencies -- Vitest is only used in tests
+import {
+  beforeEach, describe, expect, it, vi,
+} from 'vitest';
+
+import girderRest from 'platform/web-girder/plugins/girder';
+import loadFrameMetadata from './frameMetadata.service';
+
+vi.mock('platform/web-girder/plugins/girder', () => ({
+  default: {
+    get: vi.fn(),
+  },
+}));
+
+describe('loadFrameMetadata', () => {
+  beforeEach(() => {
+    vi.mocked(girderRest.get).mockReset();
+  });
+
+  it('loads shared and camera-local attachments into one normalized response', async () => {
+    vi.mocked(girderRest.get).mockImplementation(async (url: string) => {
+      if (url === 'dive_dataset/dataset-id/frame_metadata_sources') {
+        return {
+          data: {
+            shared: { itemId: 'shared-id', name: 'shared.csv' },
+            cameras: {
+              port: { itemId: 'port-id', name: 'port.csv' },
+              starboard: { name: 'missing.csv', error: 'Metadata attachment is unavailable.' },
+            },
+          },
+        };
+      }
+      if (url === 'item/shared-id/download') {
+        return { data: 'filename,depth\nport.png,10\n' };
+      }
+      if (url === 'item/port-id/download') {
+        return { data: 'filename,depth\nport.png,99\n' };
+      }
+      throw new Error(`Unexpected URL: ${url}`);
+    });
+
+    await expect(loadFrameMetadata('dataset-id')).resolves.toEqual({
+      shared: {
+        name: 'shared.csv',
+        text: 'filename,depth\nport.png,10\n',
+      },
+      cameras: {
+        port: {
+          name: 'port.csv',
+          text: 'filename,depth\nport.png,99\n',
+        },
+        starboard: {
+          name: 'missing.csv',
+          error: 'Metadata attachment is unavailable.',
+        },
+      },
+    });
+  });
+
+  it('does not download an attachment the parser is not allowed to read', async () => {
+    vi.mocked(girderRest.get).mockResolvedValueOnce({
+      data: {
+        shared: { itemId: 'json-id', name: 'pipeline-input.json' },
+        cameras: {},
+      },
+    });
+
+    await expect(loadFrameMetadata('dataset-id')).resolves.toEqual({
+      shared: { name: 'pipeline-input.json' },
+      cameras: {},
+    });
+    expect(girderRest.get).toHaveBeenCalledTimes(1);
+  });
+
+  it('reports a failed download as an unavailable attachment', async () => {
+    vi.mocked(girderRest.get).mockImplementation(async (url: string) => {
+      if (url === 'dive_dataset/dataset-id/frame_metadata_sources') {
+        return { data: { shared: { itemId: 'gone-id', name: 'nav.csv' }, cameras: {} } };
+      }
+      throw new Error('404');
+    });
+
+    await expect(loadFrameMetadata('dataset-id')).resolves.toEqual({
+      shared: { name: 'nav.csv', error: 'Metadata attachment is unavailable.' },
+      cameras: {},
+    });
+  });
+});
diff --git a/client/platform/web-girder/api/frameMetadata.service.ts b/client/platform/web-girder/api/frameMetadata.service.ts
new file mode 100644
index 000000000..7a7825d9a
--- /dev/null
+++ b/client/platform/web-girder/api/frameMetadata.service.ts
@@ -0,0 +1,80 @@
+import type {
+  FrameMetadataAttachmentText,
+  FrameMetadataSourcesResponse,
+} from 'dive-common/apispec';
+import { parentDatasetId } from 'dive-common/compositeDatasetId';
+import {
+  METADATA_ATTACHMENT_UNAVAILABLE,
+  isFrameMetadataReadableName,
+} from 'dive-common/frameMetadata/readability';
+import girderRest from 'platform/web-girder/plugins/girder';
+
+/**
+ * One attachment the server located: either it resolved to an item, or it could not be
+ * read and carries the reason instead. The two are mutually exclusive.
+ */
+type FrameMetadataSourceItem =
+  | { itemId: string; name: string }
+  | { name: string; error: string };
+
+interface FrameMetadataSourceItemsResponse {
+  shared?: FrameMetadataSourceItem;
+  cameras: Record<string, FrameMetadataSourceItem>;
+}
+
+async function getFrameMetadataSourceItems(datasetId: string): Promise<FrameMetadataSourceItemsResponse> {
+  const folderId = parentDatasetId(datasetId);
+  const { data } = await girderRest.get<FrameMetadataSourceItemsResponse>(
+    `dive_dataset/${folderId}/frame_metadata_sources`,
+  );
+  return data;
+}
+
+/**
+ * Download a Girder item's raw bytes as text over the existing item-download route. Used by the
+ * web frame-metadata read path to hand sidecar text to the shared parser. The axios JSON
+ * transform is disabled so a numeric-heavy CSV/TXT is returned verbatim, never coerced.
+ */
+async function downloadItemText(itemId: string): Promise<string> {
+  const { data } = await girderRest.get<string>(`item/${itemId}/download`, {
+    responseType: 'text',
+    transformResponse: [(value: string) => value],
+  });
+  return typeof data === 'string' ? data : String(data);
+}
+
+async function loadAttachment(
+  item: FrameMetadataSourceItem,
+): Promise<FrameMetadataAttachmentText> {
+  if ('error' in item) {
+    return { name: item.name, error: item.error };
+  }
+  if (!isFrameMetadataReadableName(item.name)) {
+    return { name: item.name };
+  }
+  try {
+    return { name: item.name, text: await downloadItemText(item.itemId) };
+  } catch {
+    return { name: item.name, error: METADATA_ATTACHMENT_UNAVAILABLE };
+  }
+}
+
+/**
+ * Fetch every attachment the dataset declares, shared and per-camera, in one pass. The eager
+ * fetch is intended: the response is the whole dataset's attachment set, cached once, so
+ * switching cameras never issues another request.
+ */
+async function loadFrameMetadata(datasetId: string): Promise<FrameMetadataSourcesResponse> {
+  const response = await getFrameMetadataSourceItems(datasetId);
+  const cameraEntries = await Promise.all(
+    Object.entries(response.cameras ?? {}).map(async ([camera, item]) => (
+      [camera, await loadAttachment(item)] as const
+    )),
+  );
+  return {
+    ...(response.shared ? { shared: await loadAttachment(response.shared) } : {}),
+    cameras: Object.fromEntries(cameraEntries),
+  };
+}
+
+export default loadFrameMetadata;
diff --git a/client/platform/web-girder/api/index.ts b/client/platform/web-girder/api/index.ts
index 63e1ac4f1..3249aa0a1 100644
--- a/client/platform/web-girder/api/index.ts
+++ b/client/platform/web-girder/api/index.ts
@@ -8,6 +8,7 @@ import { clearCalibrationFolderMetadata, getDatasetCalibration } from './dataset
 export * from './annotation.service';
 export * from './configuration.service';
 export * from './dataset.service';
+export { default as loadFrameMetadata } from './frameMetadata.service';
 export * from './girder.service';
 export * from './multicamResolve';
 export * from './rpc.service';
diff --git a/client/platform/web-girder/multicamFileRegistry.spec.ts b/client/platform/web-girder/multicamFileRegistry.spec.ts
index a05a64a92..62286f413 100644
--- a/client/platform/web-girder/multicamFileRegistry.spec.ts
+++ b/client/platform/web-girder/multicamFileRegistry.spec.ts
@@ -8,10 +8,12 @@ import {
   getCalibrationFile,
   getCameraPackageFiles,
   getLastCalibration,
+  getMetadataFile,
   mediaFileNamesForImport,
   saveCalibration,
   stashAnnotationFile,
   stashCalibrationFile,
+  stashMetadataFile,
 } from './multicamFileRegistry';
 
 /** Fixed lastModified so "did the user pick this very file?" is deterministic in tests. */
@@ -85,7 +87,7 @@ describe('multicam camera package construction', () => {
   it('reports only media filenames for multicam pre-import validation', () => {
     const files = [
       fileWithPath('img001.png', 'cam1/img001.png'),
-      fileWithPath('nav.csv', 'cam1/nav.csv'),
+      fileWithPath('frame_metadata.csv', 'cam1/frame_metadata.csv'),
       fileWithPath('tracks.csv', 'cam1/tracks.csv'),
     ];
     expect(mediaFileNamesForImport(files, 'image-sequence')).toEqual(['img001.png']);
@@ -139,12 +141,51 @@ describe('multicam camera package construction', () => {
     expect(replaced).toEqual([folderTrack]);
   });
 
-  it('keeps camera-folder annotations and config in the package, not just media', () => {
-    // tracks.csv and config.json are auto-detected in the camera folder, and both belong to
-    // the camera: the package is everything the server validates, not only the media.
-    const folderFiles = [file('img001.png'), file('tracks.csv'), file('config.json')];
+  it('keeps same-named camera metadata selections under distinct keys', () => {
+    const left = new File(['left'], 'frame_metadata.csv', { type: 'text/csv' });
+    const right = new File(['right'], 'frame_metadata.csv', { type: 'text/csv' });
+    stashMetadataFile('metadata-selection-left', left);
+    stashMetadataFile('metadata-selection-right', right);
+
+    expect(getMetadataFile('metadata-selection-left')).toBe(left);
+    expect(getMetadataFile('metadata-selection-right')).toBe(right);
+    expect(getMetadataFile('frame_metadata.csv')).toBeUndefined();
+  });
+
+  it('removes an explicitly selected in-folder attachment before flattening', () => {
+    const selected = file('frame_metadata.csv');
+    stashMetadataFile('metadata-selection-left', selected);
+    const { files: cameraFiles, replaced } = getCameraPackageFiles([
+      fileWithPath('img001.png', 'left/img001.png'),
+      fileWithPath('frame_metadata.csv', 'left/frame_metadata.csv'),
+    ], undefined, 'metadata-selection-left');
+
+    expect(cameraFiles.map((entry) => entry.name)).toEqual(['img001.png']);
+    // The attachment is uploaded separately, so re-picking it drops nothing.
+    expect(replaced).toEqual([]);
+  });
+
+  it('reports a camera-folder sidecar displaced by a same-named metadata pick', () => {
+    // The metadata attachment is never added back to the package, so a distinct folder file
+    // of the same name would otherwise leave the upload with no message at all.
+    const picked = file('nav.csv', 'chosen from another directory');
+    stashMetadataFile('metadata-selection-left', picked);
+    const folderSidecar = fileWithPath('nav.csv', 'left/nav.csv', 'the camera folder sidecar');
+    const { files: cameraFiles, replaced } = getCameraPackageFiles([
+      fileWithPath('img001.png', 'left/img001.png'),
+      folderSidecar,
+    ], undefined, 'metadata-selection-left');
+
+    expect(cameraFiles.map((entry) => entry.name)).toEqual(['img001.png']);
+    expect(replaced).toEqual([folderSidecar]);
+  });
+
+  it('keeps camera-folder annotations and sidecars in the package, not just media', () => {
+    // tracks.csv and frame_metadata.csv are auto-detected in the camera folder; both
+    // must ride along with the camera, not just the media.
+    const folderFiles = [file('img001.png'), file('tracks.csv'), file('frame_metadata.csv')];
     expect(getCameraPackageFiles(folderFiles).files.map((f) => f.name)).toEqual([
-      'img001.png', 'tracks.csv', 'config.json',
+      'img001.png', 'tracks.csv', 'frame_metadata.csv',
     ]);
   });
 });
diff --git a/client/platform/web-girder/multicamFileRegistry.ts b/client/platform/web-girder/multicamFileRegistry.ts
index 21481b269..b1dd50025 100644
--- a/client/platform/web-girder/multicamFileRegistry.ts
+++ b/client/platform/web-girder/multicamFileRegistry.ts
@@ -18,6 +18,7 @@ const annotationFilesByKey = new Map<string, File>();
 const calibrationFilesByKey = new Map<string, File>();
 const transformFilesByKey = new Map<string, File>();
 const metadataFilesByKey = new Map<string, File>();
+let metadataSelectionCounter = 0;
 
 function commonDirectoryRoot(paths: string[]): string {
   if (!paths.length) {
@@ -148,6 +149,8 @@ function isSameSelection(a: File, b: File): boolean {
  *
  * An explicit pick always wins over a folder file of the same name — the folder copy is
  * dropped, so the user uploads the file they chose and Girder never sees a duplicate name.
+ * The explicitly chosen metadata attachment is dropped from the package entirely: it is
+ * uploaded and declared separately once the camera dataset exists.
  *
  * A dropped folder copy that is not the picked file is a real file leaving the upload, so it
  * is returned in `replaced` rather than vanishing.
@@ -158,9 +161,12 @@ function isSameSelection(a: File, b: File): boolean {
 export function getCameraPackageFiles(
   folderFiles: File[],
   annotationKey?: string,
+  metadataKey?: string,
 ): CameraPackage {
   const annotationFile = annotationKey ? getAnnotationFile(annotationKey) : undefined;
-  const explicitFiles = annotationFile ? [annotationFile] : [];
+  const metadataFile = metadataKey ? getMetadataFile(metadataKey) : undefined;
+  const explicitFiles = [annotationFile, metadataFile]
+    .filter((file): file is File => file !== undefined);
   const explicitNames = new Set(explicitFiles.map((file) => file.name));
   const folderPackage = flattenUploadFiles(
     folderFiles.filter((file) => !explicitNames.has(file.name)),
@@ -221,25 +227,13 @@ export function getCalibrationFile(key: string): File | undefined {
   return [...calibrationFilesByKey.values()].find((file) => file.name === key);
 }
 
-/** Stash the chosen per-dataset metadata File for later upload lookup by path or name. */
+/** Stash a chosen metadata File under its opaque selection key. */
 export function stashMetadataFile(key: string, file: File): void {
-  calibrationLookupKeys(key).forEach((lookupKey) => {
-    metadataFilesByKey.set(lookupKey, file);
-  });
-  metadataFilesByKey.set(file.name, file);
+  metadataFilesByKey.set(key, file);
 }
 
 export function getMetadataFile(key: string): File | undefined {
-  if (!key) {
-    return undefined;
-  }
-  const lookupMatch = calibrationLookupKeys(key)
-    .map((lookupKey) => metadataFilesByKey.get(lookupKey))
-    .find((file) => file !== undefined);
-  if (lookupMatch) {
-    return lookupMatch;
-  }
-  return [...metadataFilesByKey.values()].find((file) => file.name === key);
+  return key ? metadataFilesByKey.get(key) : undefined;
 }
 
 export function clearMulticamFileRegistry(): void {
@@ -248,6 +242,7 @@ export function clearMulticamFileRegistry(): void {
   calibrationFilesByKey.clear();
   transformFilesByKey.clear();
   metadataFilesByKey.clear();
+  metadataSelectionCounter = 0;
 }
 
 export async function openFromDiskWithRegistry(
@@ -263,7 +258,10 @@ export async function openFromDiskWithRegistry(
     } else if (datasetType === 'transform') {
       stashTransformFile(ret.filePaths[0], ret.fileList[0]);
     } else if (datasetType === 'metadata') {
-      stashMetadataFile(ret.filePaths[0], ret.fileList[0]);
+      metadataSelectionCounter += 1;
+      const selectionId = `metadata-selection-${metadataSelectionCounter}`;
+      stashMetadataFile(selectionId, ret.fileList[0]);
+      return { ...ret, selectionId };
     } else {
       stashFileSelection(ret);
     }
diff --git a/client/platform/web-girder/uploadSlots.spec.ts b/client/platform/web-girder/uploadSlots.spec.ts
index 975e1dbe5..256d34745 100644
--- a/client/platform/web-girder/uploadSlots.spec.ts
+++ b/client/platform/web-girder/uploadSlots.spec.ts
@@ -12,11 +12,33 @@ function accountedNames(slots: ReturnType<typeof suggestUploadSlots>): string[]
     ...slots.mediaList.map((f) => f.name),
     ...(slots.annotationFile ? [slots.annotationFile.name] : []),
     ...(slots.configFile ? [slots.configFile.name] : []),
+    ...(slots.metadataFile ? [slots.metadataFile.name] : []),
     ...slots.unslotted.map((entry) => entry.name),
   ].sort();
 }
 
 describe('suggestUploadSlots', () => {
+  it('routes a reserved-name attachment to the metadata slot, images to media', () => {
+    const slots = suggestUploadSlots([file('img001.png'), file('img002.png'), file('frame-metadata.csv')]);
+    expect(slots.mediaList.map((f) => f.name)).toEqual(['img001.png', 'img002.png']);
+    expect(slots.metadataFile?.name).toBe('frame-metadata.csv');
+    expect(slots.annotationFile).toBeNull();
+    expect(slots.configFile).toBeNull();
+    expect(slots.unslotted).toEqual([]);
+  });
+
+  it('reports extra reserved-name attachments instead of failing the whole selection', () => {
+    const slots = suggestUploadSlots([
+      file('img001.png'),
+      file('frame-metadata.csv'),
+      file('frame_metadata.json'),
+    ]);
+    expect(slots.metadataFile?.name).toBe('frame-metadata.csv');
+    expect(slots.unslotted).toEqual([
+      { name: 'frame_metadata.json', reason: 'Only one metadata file can be uploaded per dataset' },
+    ]);
+  });
+
   it('suggests a single annotation CSV and keeps it out of the media slot', () => {
     const slots = suggestUploadSlots([file('img001.png'), file('tracks.csv')]);
     expect(slots.mediaList.map((f) => f.name)).toEqual(['img001.png']);
@@ -64,7 +86,7 @@ describe('suggestUploadSlots', () => {
       file('img001.png'), file('img002.png'),
       file('tracks.csv'), file('extra.csv'),
       file('dataset.meta.json'), file('other.json'),
-      file('nav.unknown'),
+      file('frame-metadata.txt'), file('nav.unknown'),
     ];
     const slots = suggestUploadSlots(picked);
     expect(accountedNames(slots)).toEqual(picked.map((f) => f.name).sort());
diff --git a/client/platform/web-girder/uploadSlots.ts b/client/platform/web-girder/uploadSlots.ts
index 989e33b42..ef372e565 100644
--- a/client/platform/web-girder/uploadSlots.ts
+++ b/client/platform/web-girder/uploadSlots.ts
@@ -1,3 +1,4 @@
+import isFrameMetadataSourceName from 'dive-common/frameMetadata/naming';
 import { JsonMetaRegEx } from 'dive-common/constants';
 import type { IgnoredUploadFile } from './api/dataset.service';
 
@@ -5,16 +6,18 @@ export interface SuggestedUploadSlots {
   mediaList: File[];
   annotationFile: File | null;
   configFile: File | null;
+  metadataFile: File | null;
   /**
    * Picked files no slot can hold, each with the reason. A dataset takes at most one
-   * annotation source, so the extras are reported to the user instead of being placed in a
-   * slot that would make the whole selection fail validation.
+   * annotation source and one metadata attachment, so the extras are reported to the user
+   * instead of being placed in a slot that would make the whole selection fail validation.
    */
   unslotted: IgnoredUploadFile[];
 }
 
 const ONE_ANNOTATION_REASON = 'Only one annotation file can be uploaded per dataset';
 const ONE_CONFIG_REASON = 'Only one configuration file can be uploaded per dataset';
+const ONE_METADATA_REASON = 'Only one metadata file can be uploaded per dataset';
 
 /** Files the server classifies as annotation sources, in the order this split prefers them. */
 function annotationCandidates(files: File[], configFiles: File[]): File[] {
@@ -31,25 +34,32 @@ function annotationCandidates(files: File[], configFiles: File[]): File[] {
 /**
  * Auto-suggest a picked selection into the per-role upload slots.
  *
- * Placement is a convenience split the server re-validates at upload. Every input file lands
- * in exactly one slot or in `unslotted`, so nothing the user picked is ever silently dropped.
+ * Only a reserved-name attachment is assigned to the metadata slot here;
+ * media/annotation/config placement is a convenience split the server re-validates at upload.
+ * Every input file lands in exactly one slot or in `unslotted`, so nothing the user picked is
+ * ever silently dropped.
  */
 export default function suggestUploadSlots(fileList: File[]): SuggestedUploadSlots {
-  const configFiles = fileList.filter((f) => JsonMetaRegEx.test(f.name));
+  const isMetadata = (file: File) => isFrameMetadataSourceName(file.name);
+  const rest = fileList.filter((file) => !isMetadata(file));
+  const [metadataFile = null, ...extraMetadata] = fileList.filter(isMetadata);
+  const configFiles = rest.filter((f) => JsonMetaRegEx.test(f.name));
   const [configFile = null, ...extraConfigs] = configFiles;
-  const [annotationFile = null, ...extraAnnotations] = annotationCandidates(fileList, configFiles);
+  const [annotationFile = null, ...extraAnnotations] = annotationCandidates(rest, configFiles);
   const claimed = new Set<File>([
     ...configFiles,
     ...(annotationFile ? [annotationFile] : []),
     ...extraAnnotations,
   ]);
   return {
-    mediaList: fileList.filter((f) => !claimed.has(f)),
+    mediaList: rest.filter((f) => !claimed.has(f)),
     annotationFile,
     configFile,
+    metadataFile,
     unslotted: [
       ...extraAnnotations.map((f) => ({ name: f.name, reason: ONE_ANNOTATION_REASON })),
       ...extraConfigs.map((f) => ({ name: f.name, reason: ONE_CONFIG_REASON })),
+      ...extraMetadata.map((f) => ({ name: f.name, reason: ONE_METADATA_REASON })),
     ],
   };
 }
diff --git a/client/platform/web-girder/views/Upload.spec.ts b/client/platform/web-girder/views/Upload.spec.ts
index 8f08e2337..0dfcd9faf 100644
--- a/client/platform/web-girder/views/Upload.spec.ts
+++ b/client/platform/web-girder/views/Upload.spec.ts
@@ -21,6 +21,7 @@ vi.mock('platform/web-girder/api', () => ({
   deleteResources: vi.fn(),
   saveMetadata: vi.fn(),
   uploadCalibrationItem: vi.fn(),
+  uploadAndSetMetadataFile: vi.fn(),
   uploadMetadataFileItem: vi.fn(),
   validateUploadGroup: vi.fn(),
   waitForFolderDatasetReady: vi.fn(),
@@ -60,7 +61,7 @@ function file(name: string): File {
 }
 
 const emptyRoles: ValidatedUploadRoleMap = {
-  media: [], annotations: [], datasetConfig: [], ignored: [],
+  media: [], annotations: [], datasetConfig: [], frameMetadata: [], ignored: [],
 };
 
 /** A passing validation response; unnamed roles default to empty. */
@@ -129,6 +130,27 @@ describe('Upload pending rows', () => {
     expect(row.ignored).toEqual([{ name: 'camera.npz', reason: 'Unsupported side file' }]);
   });
 
+  it('reports, rather than drops, a metadata attachment on a multi-video upload', async () => {
+    pick([file('a.mp4'), file('b.mp4'), file('frame-metadata.csv')]);
+    vi.mocked(validateUploadGroup).mockResolvedValue({
+      data: validation({ roles: { media: ['a.mp4', 'b.mp4'] } }),
+    } as never);
+
+    const wrapper = mountUpload();
+    await wrapper.vm.openImport('video');
+    await nextTick();
+
+    const [row] = wrapper.vm.pendingUploads;
+    expect(row.createSubFolders).toBe(true);
+    expect(row.ignored).toEqual([{
+      name: 'frame-metadata.csv',
+      reason: 'Frame metadata is not supported when multiple videos are uploaded',
+    }]);
+    // The notice renders on a fan-out row, which has no slot editor to hide behind.
+    expect(wrapper.text()).toContain('Ignored (not uploaded):');
+    expect(wrapper.text()).toContain('frame-metadata.csv');
+  });
+
   it('creates a row in an error state when validation rejects the selection', async () => {
     pick([file('img001.png'), file('tracks.csv')]);
     vi.mocked(validateUploadGroup).mockResolvedValue({
diff --git a/client/platform/web-girder/views/Upload.vue b/client/platform/web-girder/views/Upload.vue
index 63609e896..f59998e56 100644
--- a/client/platform/web-girder/views/Upload.vue
+++ b/client/platform/web-girder/views/Upload.vue
@@ -29,6 +29,7 @@ import {
   deleteResources,
   saveMetadata,
   uploadCalibrationItem,
+  uploadAndSetMetadataFile,
   uploadMetadataFileItem,
   validateUploadGroup,
   waitForFolderDatasetReady,
@@ -81,13 +82,14 @@ export interface PendingUpload {
   name: string;
   files: InteralFiles[];
   /**
-   * Per-role upload slots. The user declares each file's role by which slot it goes in;
-   * placement is a suggestion the server re-validates at upload.
+   * Per-role upload slots. The user declares each file's role by which slot it goes in.
+   * Media/annotation/config placement is a suggestion the server re-validates at upload;
+   * the metadata attachment is uploaded separately from annotation classification.
    */
   mediaList: File[];
   annotationFile: File | null;
   configFile: File | null;
-  /** Optional dataset-level file handed to pipelines that request it. */
+  /** Optional dataset-level attachment used by pipelines and, for TXT/CSV, frame metadata. */
   metadataFile: File | null;
   /** Media/annotation/config package the server validated for upload (rebuilt at start). */
   uploadFiles: File[];
@@ -140,6 +142,8 @@ function multicamCameraSlotPercent(
   return MULTICAM_PROGRESS_START + (cameraIndex * span) + (subFraction * span);
 }
 
+const MULTI_VIDEO_METADATA_REASON = 'Frame metadata is not supported when multiple videos are uploaded';
+
 /**
  * The server names every file it did not accept, so what to upload is the validated
  * selection minus those names.
@@ -175,16 +179,20 @@ function defaultRowName(validation: ValidationResponse): string {
 }
 
 /**
- * Every picked file this row will not upload, with the reason: what the server ignored, and
- * what had no slot to go in.
+ * Every picked file this row will not upload, with the reason: what the server ignored, what
+ * had no slot, and — for a fan-out row — the metadata attachment, which cannot be frame-keyed
+ * against several videos at once.
  */
 function rowIgnoredFiles(
-  row: Pick<PendingUpload, 'unslotted'>,
+  row: Pick<PendingUpload, 'unslotted' | 'createSubFolders' | 'metadataFile'>,
   validation: ValidationResponse,
 ): IgnoredUploadFile[] {
   return [
     ...validationIgnoredFiles(validation),
     ...row.unslotted,
+    ...(row.createSubFolders && row.metadataFile
+      ? [{ name: row.metadataFile.name, reason: MULTI_VIDEO_METADATA_REASON }]
+      : []),
   ];
 }
 
@@ -317,7 +325,7 @@ export default defineComponent({
       expectedType?: DatasetType,
     ) => {
       const slots = suggestUploadSlots(allFiles);
-      // Validate the slotted selection so the media type is server-determined.
+      // Validate the media/annotation/config selection so the media type is server-determined.
       const row: PendingUpload = {
         createSubFolders: false,
         name: '',
@@ -325,7 +333,7 @@ export default defineComponent({
         mediaList: slots.mediaList,
         annotationFile: slots.annotationFile,
         configFile: slots.configFile,
-        metadataFile: null,
+        metadataFile: slots.metadataFile,
         uploadFiles: [],
         unslotted: slots.unslotted,
         ignored: [...slots.unslotted],
@@ -498,17 +506,31 @@ export default defineComponent({
           if (!folderFiles.length) {
             throw new Error(`No media files found for camera "${cameraName}"`);
           }
+          const cameraMetadataFile = source.metadataFile
+            ? getMetadataFile(source.metadataFile)
+            : undefined;
+          if (source.metadataFile && !cameraMetadataFile) {
+            throw new Error(
+              `Metadata file for camera "${cameraName}" was not found. Choose it again.`,
+            );
+          }
           // Flatten before validation so the names the server validates match the
           // names uploaded to Girder.
           const { files: cameraFiles, replaced } = getCameraPackageFiles(
             folderFiles,
             source.trackFile,
+            source.metadataFile,
           );
           // eslint-disable-next-line no-await-in-loop -- validate then upload each camera sequentially
           const validation = (await validateUploadGroup(cameraFiles.map((f) => f.name))).data;
           if (!validation.ok) {
             throw new Error(validation.message || `Invalid files for camera "${cameraName}"`);
           }
+          if (cameraMetadataFile && validation.roles.frameMetadata.length) {
+            throw new Error(
+              `Camera "${cameraName}" has more than one metadata file. Choose one file and try again.`,
+            );
+          }
           const cameraType = source.type ?? args.type;
           const uploadType = validation.type;
           const compatibleTypes = new Set([cameraType, args.type, 'large-image', 'image-sequence']);
@@ -558,6 +580,10 @@ export default defineComponent({
             requireViewableImages: uploadType === ImageSequenceType,
             requireLargeImageItems: uploadType === LargeImageType,
           }, jobIds);
+          if (cameraMetadataFile) {
+            // eslint-disable-next-line no-await-in-loop
+            await uploadAndSetMetadataFile(folder._id, cameraMetadataFile);
+          }
           setMulticamImportProgress(
             multicamCameraSlotPercent(i + 1, totalCameras, 0),
             totalCameras > 1 && i + 1 < totalCameras
@@ -1072,7 +1098,8 @@ export default defineComponent({
               v-if="!pendingUpload.createSubFolders && pendingUpload.type !== 'zip'"
               class="mt-3"
             >
-              <v-col class="py-0 mx-2">
+              <!-- pb-3 offsets the row's negative bottom margin so the card encloses the hint. -->
+              <v-col class="pt-0 pb-3 mx-2">
                 <v-row>
                   <v-file-input
                     v-model="pendingUpload.mediaList"
@@ -1119,14 +1146,21 @@ export default defineComponent({
                     :accept="filterFileUpload('meta')"
                   />
                 </v-row>
-                <v-row>
+                <!--
+                  no-gutters drops the row's negative bottom margin, which would otherwise crop
+                  the persistent hint against the card edge and the upload progress line.
+                -->
+                <v-row
+                  no-gutters
+                  class="mt-3"
+                >
                   <v-file-input
                     v-model="pendingUpload.metadataFile"
                     show-size
                     counter
                     prepend-icon="mdi-file-cog"
                     label="Metadata File (Optional)"
-                    hint="Optional. A .json, .txt, or .csv file passed to pipelines that request it."
+                    hint="Passed to pipelines that request it. CSV and TXT frame rows also appear as Frame Metadata."
                     persistent-hint
                     :disabled="pendingUpload.uploading"
                     :accept="filterFileUpload('metadata')"
diff --git a/client/platform/web-girder/views/UploadGirder.vue b/client/platform/web-girder/views/UploadGirder.vue
index a01f85052..7760b1cc1 100644
--- a/client/platform/web-girder/views/UploadGirder.vue
+++ b/client/platform/web-girder/views/UploadGirder.vue
@@ -8,7 +8,7 @@ import {
 } from 'platform/web-girder/constants';
 
 import {
-  makeViameFolder, postProcess, uploadMetadataFileItem, setDatasetMetadataFile,
+  makeViameFolder, postProcess, uploadAndSetMetadataFile,
 } from 'platform/web-girder/api';
 import { GirderUploadManager } from 'platform/web-girder/utils';
 
@@ -116,13 +116,23 @@ export default Vue.extend({
         folder = await this.createUploadFolder(name, fps, pendingUpload.type);
         if (folder) {
           await this.uploadFiles(pendingUpload.name, folder, files, uploaded, skipTranscoding);
-          if (metadataFile) {
-            const itemId = await uploadMetadataFileItem(folder._id, metadataFile);
-            await setDatasetMetadataFile(folder._id, itemId);
+          // The media dataset is created and uploaded at this point. A metadata attachment
+          // failure must not unwind the upload: doing so
+          // would orphan the finished dataset on the server and leave the pending row stuck for a
+          // duplicate retry. Surface the failure, but always retire the row and keep the dataset.
+          try {
+            if (metadataFile) {
+              await uploadAndSetMetadataFile(folder._id, metadataFile);
+            }
+          } catch (err) {
+            this.$emit('error', { err, name: pendingUpload.name });
+          } finally {
+            this.remove(pendingUpload);
           }
-          this.remove(pendingUpload);
         }
       } else {
+        // Fan-out: N videos have N independent frame numberings, so one frame-keyed metadata
+        // attachment cannot serve them. The row reports it in `ignored` instead.
         while (files.length > 0) {
           // take the file name and convert it to a folder name;
           const subfile = files.splice(0, 1);
diff --git a/server/dive_server/crud_dataset.py b/server/dive_server/crud_dataset.py
index 6d5957c04..a62f1b66c 100644
--- a/server/dive_server/crud_dataset.py
+++ b/server/dive_server/crud_dataset.py
@@ -7,9 +7,9 @@
 import cherrypy
 from girder.constants import AccessType
 from girder.exceptions import RestException
+from girder.models.file import File
 from girder.models.folder import Folder
 from girder.models.item import Item
-from girder.models.file import File
 from girder.models.token import Token
 from girder.utility import ziputil
 from pydantic.main import BaseModel
@@ -21,6 +21,7 @@
     asbool,
     calibration_format,
     constants,
+    frame_metadata,
     fromMeta,
     models,
     multicam_camera_order,
@@ -124,6 +125,8 @@ def _create_multicam_soft_clone(
         creator=owner,
     )
     cloned_folder['meta'] = copy.deepcopy(source_folder['meta'])
+    media_source_folder = crud.getCloneRoot(owner, source_folder)
+    cloned_folder[constants.ForeignMediaIdMarker] = str(media_source_folder['_id'])
     cloned_folder['meta'][constants.PublishedMarker] = False
     if constants.ConfidenceFiltersMarker not in cloned_folder['meta']:
         cloned_folder['meta'][constants.ConfidenceFiltersMarker] = {'default': 0.1}
@@ -249,6 +252,29 @@ def _multicam_camera_order(multi_cam: dict) -> List[str]:
     return multicam_camera_order(multi_cam)
 
 
+def _iter_multicam_camera_folders(
+    multi_cam: dict,
+    user: types.GirderUserModel,
+) -> Iterable[Tuple[str, types.GirderModel]]:
+    """Yield (camera_name, camera_folder) in display order, loading each child folder.
+
+    Every camera entry has a folderId (crud.verify_dataset rejects a multicam dataset
+    without one). Raises a 404 when a camera's folder cannot be loaded, e.g. a clone whose
+    source was deleted.
+    """
+    cameras_meta = multi_cam.get('cameras') or {}
+    for camera_name in _multicam_camera_order(multi_cam):
+        child = Folder().load(
+            cameras_meta[camera_name]['folderId'], level=AccessType.READ, user=user
+        )
+        if child is None:
+            raise RestException(
+                f'Camera folder for "{camera_name}" was not found',
+                code=404,
+            )
+        yield camera_name, child
+
+
 def get_multi_cam_media(
     dsFolder: types.GirderModel, user: types.GirderUserModel
 ) -> models.MultiCamMedia:
@@ -383,6 +409,178 @@ def get_media(
     )
 
 
+def _clone_root(
+    folder: types.GirderModel,
+    user: types.GirderUserModel,
+) -> types.GirderModel:
+    """The folder's media source root, or the folder itself when it is not a clone.
+
+    crud.getCloneRoot verifies the dataset before walking, and attachment resolution runs
+    mid-import (process_items) on folders that do not yet carry fps. A folder with no
+    foreign-media marker is its own root, so skipping the walk skips that verification
+    without changing the answer.
+    """
+    if not folder.get(constants.ForeignMediaIdMarker):
+        return folder
+    return crud.getCloneRoot(user, folder)
+
+
+def _metadata_attachment(
+    folder: types.GirderModel,
+    user: types.GirderUserModel,
+) -> Optional[Dict[str, str]]:
+    """Resolve one folder's explicit metadata attachment without parsing its contents.
+
+    The item id comes from folder metadata and can name any item in the instance, so
+    membership in this scope is the guard: the item must live in ``folder`` or its clone
+    root. Resolution asserts no ACL, because it cannot: a clone root is force-loaded
+    (``crud.getCloneRoot``) and may be unreadable to ``user``, exactly as ``crud.valid_images``
+    already lists that root's media. Access is enforced where the bytes are served -- the
+    Girder item download route.
+    """
+    item_id = folder.get('meta', {}).get(constants.MetadataFileItemIdMarker)
+    if not item_id:
+        return None
+    original_name = fromMeta(
+        folder,
+        constants.MetadataFileOriginalNameMarker,
+        '',
+    )
+    item = Item().load(str(item_id), force=True)
+    allowed_folder_ids = {
+        str(folder['_id']),
+        str(_clone_root(folder, user)['_id']),
+    }
+    if (
+        item is None
+        or str(item.get('folderId')) not in allowed_folder_ids
+        or not constants.metadataFileRegex.search(item['name'])
+    ):
+        return {
+            'name': original_name or 'Metadata File',
+            'error': 'Metadata attachment is unavailable.',
+        }
+    return {'itemId': str(item['_id']), 'name': original_name or item['name']}
+
+
+def _reserved_metadata_attachment(folder: types.GirderModel) -> Optional[Dict[str, str]]:
+    """Resolve the singular reserved-name fallback in one folder.
+
+    The query is the reserved-basename predicate, so every returned item is an attachment.
+    Like the explicit path this establishes identity only, and for the same reason: ``folder``
+    may be a force-loaded clone root, so there is no ACL for the resolver to assert.
+    """
+    items = list(
+        Folder().childItems(
+            folder,
+            filters=frame_metadata.frame_metadata_source_name_query(),
+        )
+    )
+    if len(items) > 1:
+        return {
+            'name': 'Metadata File',
+            'error': 'More than one reserved-name metadata attachment is available.',
+        }
+    if not items:
+        return None
+    item = items[0]
+    return {'itemId': str(item['_id']), 'name': item['name']}
+
+
+def _first_metadata_attachment(
+    folders: Iterable[Optional[types.GirderModel]],
+    user: types.GirderUserModel,
+    *,
+    reserved: bool,
+) -> Optional[Dict[str, str]]:
+    """Resolve the first attachment across placement-precedence folders."""
+    seen_folder_ids: set[str] = set()
+    for folder in folders:
+        if folder is None:
+            continue
+        folder_id = str(folder['_id'])
+        if folder_id in seen_folder_ids:
+            continue
+        seen_folder_ids.add(folder_id)
+        attachment = (
+            _reserved_metadata_attachment(folder)
+            if reserved
+            else _metadata_attachment(folder, user)
+        )
+        if attachment is not None:
+            return attachment
+    return None
+
+
+def resolve_metadata_attachment(
+    folder: types.GirderModel,
+    user: types.GirderUserModel,
+) -> Optional[Dict[str, str]]:
+    """Resolve one scope's metadata attachment identity.
+
+    The single owner of "what is this scope's attachment": an explicit marker on the folder
+    or its clone root first, then the reserved-name file in the same folders. Returns
+    ``{itemId, name}`` when resolvable, ``{name, error}`` when declared but unavailable, and
+    None when the scope has no attachment.
+    """
+    folders = [folder, _clone_root(folder, user)]
+    explicit = _first_metadata_attachment(folders, user, reserved=False)
+    if explicit is not None:
+        return explicit
+    return _first_metadata_attachment(folders, user, reserved=True)
+
+
+def resolve_metadata_attachment_item_id(
+    folder: types.GirderModel,
+    user: types.GirderUserModel,
+) -> Optional[str]:
+    """Return the resolved attachment's item id, or None when absent or unavailable."""
+    attachment = resolve_metadata_attachment(folder, user)
+    if attachment is None:
+        return None
+    return attachment.get('itemId')
+
+
+def load_frame_metadata_sources(
+    dsFolder: types.GirderModel,
+    user: types.GirderUserModel,
+) -> dict:
+    """Return one normalized metadata attachment identity per metadata scope."""
+    crud.verify_dataset(dsFolder)
+    source_type = fromMeta(dsFolder, constants.TypeMarker)
+    if source_type == constants.MultiType:
+        return _load_multicam_frame_metadata_sources(dsFolder, user)
+    if source_type not in (constants.ImageSequenceType, constants.VideoType):
+        return {'cameras': {}}
+    shared = resolve_metadata_attachment(dsFolder, user)
+    return {'shared': shared, 'cameras': {}} if shared is not None else {'cameras': {}}
+
+
+def _load_multicam_frame_metadata_sources(
+    dsFolder: types.GirderModel,
+    user: types.GirderUserModel,
+) -> dict:
+    multi_cam = fromMeta(dsFolder, constants.MultiCamMarker) or {}
+    shared = resolve_metadata_attachment(dsFolder, user)
+    cameras: Dict[str, Dict[str, str]] = {}
+    for camera_name, child in _iter_multicam_camera_folders(multi_cam, user):
+        if fromMeta(child, constants.TypeMarker) not in (
+            constants.ImageSequenceType,
+            constants.VideoType,
+        ):
+            continue
+        # A camera-local attachment replaces the shared one for that camera, whether it was
+        # declared explicitly or by reserved name.
+        attachment = resolve_metadata_attachment(child, user)
+        if attachment is not None:
+            cameras[camera_name] = attachment
+
+    response: Dict[str, Any] = {'cameras': cameras}
+    if shared is not None:
+        response['shared'] = shared
+    return response
+
+
 class MetadataMutableUpdateArgs(models.MetadataMutable):
     """Update schema for mutable metadata fields"""
 
@@ -641,24 +839,26 @@ def _yield_metadata_file(
     z: ziputil.ZipGenerator,
     zip_path: str,
     folder: types.GirderModel,
+    user: types.GirderUserModel,
 ) -> Generator[bytes, None, None]:
-    """Add the optional per-dataset metadata file when one is attached.
-
-    Mirrors calibration inclusion in full exports so pipeline sidecars
-    (e.g. flight logs) survive dataset zip round-trips.
+    """Add the folder's attachment at its archive-relative metadata path.
+
+    ``metadata/<originalName>`` is the archive's only record of the attachment; importers
+    discover it by directory, so meta.json carries no locator. Resolution already confined
+    the item to this dataset's scope, and the export walks a clone's media source the same
+    way, so the item is loaded without a second access check -- one that would raise
+    AccessException past the ``except RestException`` guard in export_datasets_zipstream and
+    abort the whole stream instead of naming the dataset in failed_datasets.txt.
     """
-    item_id = resolve_metadata_file_item_id(folder)
-    if not item_id:
+    attachment = resolve_metadata_attachment(folder, user)
+    if attachment is None or 'itemId' not in attachment:
         return
-    md_item = Item().findOne({'_id': _mongo_id(item_id)})
+    md_item = Item().load(attachment['itemId'], force=True)
     if md_item is None:
         return
-    # Prefer the preserved original filename when present so re-import can
-    # match the name users attached at import time.
-    original_name = folder.get('meta', {}).get(constants.MetadataFileOriginalNameMarker)
-    for path, file in Item().fileList(md_item):
-        out_name = original_name or path
-        for data in z.addFile(file, Path(f'{zip_path}{out_name}')):
+    original_name = Path(attachment['name']).name
+    for _path, file in Item().fileList(md_item):
+        for data in z.addFile(file, Path(f'{zip_path}metadata/{original_name}')):
             yield data
         break
 
@@ -695,13 +895,17 @@ def makeMetajson():
         """Include dataset metadata file with full export"""
         meta = get_dataset(dsFolder, user)
         media = get_media(dsFolder, user)
-        yield json.dumps(
-            {
-                **meta.dict(exclude_none=True),
-                **media.dict(exclude_none=True),
-            },
-            indent=2,
-        )
+        output = {
+            **meta.dict(exclude_none=True),
+            **media.dict(exclude_none=True),
+        }
+        # Attachment locators never travel in an archive: a server-local item id means
+        # nothing there, and the name is already carried by metadata/<originalName>, which
+        # is where both importers look. Mirrors withoutMetadataAttachment in the desktop
+        # exporter (client/platform/desktop/backend/native/multicamExport.ts).
+        output.pop(constants.MetadataFileItemIdMarker, None)
+        output.pop(constants.MetadataFileOriginalNameMarker, None)
+        yield json.dumps(output, indent=2)
 
     def makeDiveJson():
         """Include DIVE JSON output annotation file"""
@@ -749,7 +953,7 @@ def makeDiveJson():
             yield data
 
     if includeMedia:
-        for data in _yield_metadata_file(z, zip_path, dsFolder):
+        for data in _yield_metadata_file(z, zip_path, dsFolder, user):
             yield data
 
 
@@ -772,12 +976,13 @@ def makeMultiCamJson():
     for data in z.addFile(makeMultiCamJson, Path(f'{zip_path}multiCam.json')):
         yield data
 
+    # The parent has no media of its own; includeMedia governs only its shared attachment.
     for data in _yield_single_dataset_export(
         z,
         zip_path,
         dsFolder,
         user,
-        False,
+        includeMedia,
         includeDetections,
         excludeBelowThreshold,
         typeFilter,
@@ -787,11 +992,6 @@ def makeMultiCamJson():
     if includeMedia:
         for data in _yield_calibration_files(z, zip_path, str(dsFolder['_id'])):
             yield data
-        # Parent folder holds the optional metadata sidecar (not camera children).
-        # Parent _yield_single_dataset_export runs with includeMedia=False, so
-        # yield it here alongside calibration.
-        for data in _yield_metadata_file(z, zip_path, dsFolder):
-            yield data
 
     for cam_name in _multicam_camera_order(multi_cam):
         cam_info = multi_cam['cameras'][cam_name]
@@ -1114,16 +1314,12 @@ def _mark_calibration_source_and_json_item(cal_item: dict) -> None:
     )
 
 
-def _mark_metadata_file_item(md_item: dict) -> None:
-    Item().setMetadata(md_item, {constants.MetadataFileMarker: 'true'})
-
-
 def _validate_metadata_file_item(
     user: types.GirderUserModel,
     folder: types.GirderModel,
     item_id: str,
 ) -> types.GirderModel:
-    """Validate and mark a Girder item as the dataset's optional metadata file."""
+    """Validate a Girder item as the dataset's optional metadata file."""
     md_item = Item().load(item_id, level=AccessType.WRITE, user=user)
     if md_item is None:
         raise RestException('Metadata file was not found', code=404)
@@ -1131,7 +1327,6 @@ def _validate_metadata_file_item(
         raise RestException('Metadata file must be stored in the dataset folder', code=400)
     if not constants.metadataFileRegex.search(md_item['name']):
         raise RestException('Metadata file must be .json, .txt, or .csv', code=400)
-    _mark_metadata_file_item(md_item)
     return md_item
 
 
@@ -1463,22 +1658,30 @@ def validate_files(files: List[str]):
 
     ``type`` is present only when ``ok``: a rejected selection has no single media type.
     """
-    videos = [f for f in files if constants.videoRegex.search(f)]
-    images = [f for f in files if constants.imageRegex.search(f)]
-    large_images = [f for f in files if constants.largeImageRegEx.search(f)]
+    # Partition frame-metadata sidecars first so they never trip the
+    # generic csv/txt classification below.
+    frame_meta = [f for f in files if frame_metadata.is_frame_metadata_source_name(f)]
+    frame_meta_set = set(frame_meta)
+
+    videos = [f for f in files if constants.videoRegex.search(f) and f not in frame_meta_set]
+    images = [f for f in files if constants.imageRegex.search(f) and f not in frame_meta_set]
+    large_images = [
+        f for f in files if constants.largeImageRegEx.search(f) and f not in frame_meta_set
+    ]
     media = images + videos + large_images
 
-    # Dataset config JSON follows the same meta/config filename contract as the client's
-    # JsonMetaRegEx; annotation JSON is every other .json.
+    # Keep dataset config filename detection aligned with the client's JsonMetaRegEx.
     dataset_config = [
         f for f in files if constants.jsonRegex.search(f) and constants.metaRegex.search(f)
     ]
     dataset_config_set = set(dataset_config)
 
-    annotation_csvs = [f for f in files if constants.csvRegex.search(f)]
+    annotation_csvs = [f for f in files if constants.csvRegex.search(f) and f not in frame_meta_set]
     annotation_ymls = [f for f in files if constants.ymlRegex.search(f)]
     annotation_jsons = [
-        f for f in files if constants.jsonRegex.search(f) and f not in dataset_config_set
+        f
+        for f in files
+        if constants.jsonRegex.search(f) and f not in dataset_config_set and f not in frame_meta_set
     ]
     annotations = annotation_csvs + annotation_ymls + annotation_jsons
 
@@ -1502,6 +1705,9 @@ def validate_files(files: List[str]):
     elif len(annotation_csvs) > 1:
         ok = False
         message = "Can only upload a single CSV Annotation per import"
+    elif len(frame_meta) > 1:
+        ok = False
+        message = "More than one metadata file was selected. Choose one file and try again."
     elif len(dataset_config) > 1:
         ok = False
         message = "Can only upload a single configuration JSON per import"
@@ -1526,7 +1732,9 @@ def validate_files(files: List[str]):
         ok = False
         message = "No supported media-type files found"
 
-    accepted = set(media) | set(annotations) | set(dataset_config)
+    # A metadata attachment is stored for every dataset type; read time decides what to do
+    # with it, so there is no media-type gate here.
+    accepted = set(media) | set(annotations) | set(dataset_config) | frame_meta_set
     ignored = [f for f in files if f not in accepted]
 
     return {
@@ -1538,6 +1746,7 @@ def validate_files(files: List[str]):
             "media": media,
             "annotations": annotations,
             "datasetConfig": dataset_config,
+            "frameMetadata": frame_meta,
             "ignored": ignored,
         },
         "reasons": {f: UNSUPPORTED_SIDE_FILE_REASON for f in ignored},
@@ -1692,17 +1901,35 @@ def set_metadata_file(
     folder root. Handed to opt-in pipelines at run time (see the pipe
     `# Metadata File:` header).
     """
+    # Supersede cleanup removes only an attachment DIVE itself stored. A reserved-name file
+    # is the user's own folder content, uploaded with the media and merely discovered by
+    # resolution -- and process_items records what it discovers in this same marker, so the
+    # marker alone cannot tell the two apart. The name can: replacing the attachment shadows
+    # a reserved-name file, and deleting it would destroy a file the user uploaded.
+    declared_item_id = folder.get('meta', {}).get(constants.MetadataFileItemIdMarker)
+    previous_item_id = str(declared_item_id) if declared_item_id else None
     md_item = _validate_metadata_file_item(user, folder, item_id)
+    previous_item = None
+    if previous_item_id and previous_item_id != str(md_item['_id']):
+        candidate = Item().load(previous_item_id, level=AccessType.WRITE, user=user)
+        if (
+            candidate is not None
+            and str(candidate.get('folderId')) == str(folder['_id'])
+            and not frame_metadata.is_frame_metadata_source_name(candidate['name'])
+        ):
+            previous_item = candidate
     folder['meta'][constants.MetadataFileItemIdMarker] = str(md_item['_id'])
     folder['meta'][constants.MetadataFileOriginalNameMarker] = md_item['name']
     Folder().save(folder)
+    if previous_item is not None:
+        try:
+            Item().remove(previous_item)
+        except Exception:
+            cherrypy.log(
+                f'Unable to remove superseded metadata attachment {previous_item["_id"]}',
+                traceback=True,
+            )
     return {
         'metadataFileItemId': str(md_item['_id']),
         'metadataFileOriginalName': md_item['name'],
     }
-
-
-def resolve_metadata_file_item_id(folder: types.GirderModel) -> Optional[str]:
-    """Return the dataset's metadata file item id, if one is attached."""
-    item_id = folder.get('meta', {}).get(constants.MetadataFileItemIdMarker)
-    return str(item_id) if item_id else None
diff --git a/server/dive_server/crud_rpc.py b/server/dive_server/crud_rpc.py
index 7001cf3c5..cf6eb8ca4 100644
--- a/server/dive_server/crud_rpc.py
+++ b/server/dive_server/crud_rpc.py
@@ -1,7 +1,7 @@
 from datetime import datetime, timedelta
 import json
-from typing import Dict, List, Optional, Tuple, TypedDict
 from pathlib import Path
+from typing import Dict, List, Optional, Tuple, TypedDict
 
 from girder.constants import AccessType
 from girder.exceptions import RestException
@@ -20,7 +20,15 @@
 from dive_tasks import tasks
 from dive_tasks.utils import choose_annotation_fps
 from dive_tasks.multicam_pipeline import is_stereo_or_multicam_pipeline, pipeline_requires_input
-from dive_utils import TRUTHY_META_VALUES, asbool, constants, fromMeta, models, types
+from dive_utils import (
+    TRUTHY_META_VALUES,
+    asbool,
+    constants,
+    frame_metadata,
+    fromMeta,
+    models,
+    types,
+)
 from dive_utils.constants import TrainingModelExtensions
 from dive_utils.serializers import dive, kpf, kwcoco, viame
 
@@ -299,6 +307,7 @@ def run_pipeline(
     multicam_cameras: List[types.MulticamCameraJob] = []
     multicam_default_display = ''
     calibration_item_id: Optional[str] = None
+    default_camera_folder: Optional[types.GirderModel] = None
 
     if dataset_type == constants.MultiType:
         multi_cam = fromMeta(folder, constants.MultiCamMarker, required=True)
@@ -311,6 +320,8 @@ def run_pipeline(
             child = Folder().load(folder_id, level=AccessType.READ, user=user)
             if child is None:
                 raise RestException(f'Camera folder for "{name}" was not found', code=404)
+            if name == multicam_default_display:
+                default_camera_folder = child
             cam_type = cam_info.get('type') or fromMeta(child, constants.TypeMarker)
             camera_job: types.MulticamCameraJob = {
                 'name': name,
@@ -340,11 +351,21 @@ def run_pipeline(
             )
 
     # Resolve the dataset's optional metadata file for pipelines that opt in via a
-    # `# Metadata File: <block>:<key>` header. Applies to single and multicam.
+    # `# Metadata File: <block>:<key>` header. Scope precedence mirrors what the metadata
+    # panel resolves: a single-camera run prefers its own camera's attachment and falls
+    # back to the multicam parent's shared one, a stereo/multicam run prefers the shared
+    # attachment and falls back to the default display camera's. Every lookup goes through
+    # the one resolver that owns "what is this scope's attachment", so a run and the panel
+    # never disagree.
     metadata_file_key = (pipeline.get("metadata") or {}).get("metadataFileKey")
     metadata_file_item_id: Optional[str] = None
     if metadata_file_key:
-        metadata_file_item_id = crud_dataset.resolve_metadata_file_item_id(folder)
+        scope_item_ids = (
+            crud_dataset.resolve_metadata_attachment_item_id(scope, user)
+            for scope in (folder, multicam_parent, default_camera_folder)
+            if scope is not None
+        )
+        metadata_file_item_id = next((item_id for item_id in scope_item_ids if item_id), None)
 
     params: types.MulticamPipelineJob = {
         "pipeline": pipeline,
@@ -373,7 +394,6 @@ def run_pipeline(
     if metadata_file_key and metadata_file_item_id:
         params['metadata_file_key'] = metadata_file_key
         params['metadata_file_item_id'] = metadata_file_item_id
-
     job_title = f"Running {pipeline['name']} on {str(folder['name'])}"
     if multicam_parent is not None and camera_name:
         job_title = (
@@ -400,6 +420,17 @@ def run_pipeline(
             constants.JOBCONST_CREATOR: str(user['_id']),
         },
     )
+    if metadata_file_key and not metadata_file_item_id:
+        # Same shape as the missing-calibration notice the task writes: the run continues
+        # without the `-s <block>:<key>=<path>` setting, so say so instead of dropping it.
+        Job().updateJob(
+            job,
+            log=(
+                f'Warning: {pipeline["pipe"]} declares metadata file key {metadata_file_key} '
+                'but this dataset has no metadata attachment; '
+                'running without the metadata file setting\n'
+            ),
+        )
     # Inform Client of new Job added in inactive state
     Notification(
         type='job_status',
@@ -552,6 +583,11 @@ def run_training(
 )
 
 
+def _frame_metadata_kept_warning(name: str) -> str:
+    """Notice that a file was kept as a frame-metadata sidecar rather than imported."""
+    return f'{name} was stored as frame metadata, not annotations; it stays in the dataset folder.'
+
+
 def _get_data_by_type(
     file: types.GirderModel,
     image_map: Optional[Dict[str, int]] = None,
@@ -669,6 +705,19 @@ def resolve_imported_dataset_info(existing: types.DatasetInfo, meta: dict, addit
     return {**meta, 'datasetInfo': resolved}
 
 
+def _attach_swept_sidecar(folder: types.GirderModel, item: types.GirderModel):
+    """Record a swept sidecar as the folder's explicit metadata attachment.
+
+    Girder's save is a full-document replace and async jobs (convert_video) write folder
+    meta while this sweep runs, so refresh first or their keys (annotate, originalFps,
+    ffprobe_info) are replaced with this stale in-memory copy.
+    """
+    crud.refresh_folder_document(folder)
+    folder['meta'][constants.MetadataFileItemIdMarker] = str(item['_id'])
+    folder['meta'][constants.MetadataFileOriginalNameMarker] = item['name']
+    Folder().save(folder)
+
+
 def process_items(
     folder: types.GirderModel,
     user: types.GirderUserModel,
@@ -679,45 +728,129 @@ def process_items(
     """
     Discover unprocessed items in a dataset and process them by type in order of creation
     """
-    unprocessed_items = Folder().childItems(
-        folder,
-        filters={
-            "$or": [
-                {"lowerName": {"$regex": constants.csvRegex}},
-                {"lowerName": {"$regex": constants.jsonRegex}},
-                {"lowerName": {"$regex": constants.ymlRegex}},
-            ]
-        },
-        # Processing order: oldest to newest
-        sort=[("created", pymongo.ASCENDING)],
-    )
-    auxiliary = crud.get_or_create_auxiliary_folder(
-        folder,
-        user,
+    attachment_item_id = crud_dataset.resolve_metadata_attachment_item_id(folder, user)
+
+    def is_declared_sidecar(item: types.GirderModel) -> bool:
+        return str(item['_id']) == attachment_item_id or (
+            frame_metadata.is_frame_metadata_source_name(item['name'])
+        )
+
+    unprocessed_items = list(
+        Folder().childItems(
+            folder,
+            filters={
+                "$and": [
+                    {
+                        "$or": [
+                            {"lowerName": {"$regex": constants.csvRegex}},
+                            {"lowerName": {"$regex": constants.jsonRegex}},
+                            {"lowerName": {"$regex": constants.ymlRegex}},
+                            # Reserved sidecar names include .txt, which no annotation
+                            # extension covers. Sweeping them keeps all six behaving
+                            # identically instead of leaving .txt undiscovered.
+                            frame_metadata.frame_metadata_source_name_query(),
+                        ]
+                    },
+                    # Frame-metadata sidecars are marked processed but stay in the dataset
+                    # folder; excluding them here keeps a left-in-place sidecar from being
+                    # re-swept on a later postprocess.
+                    {f'meta.{constants.ProcessedMarker}': {'$ne': True}},
+                ]
+            },
+            # Processing order: oldest to newest
+            sort=[("created", pymongo.ASCENDING)],
+        )
     )
-    aggregate_warnings = []
+    aggregate_warnings: List[str] = []
+
+    # This sweep is also the convergence point for headless writers (assetstore/S3 import),
+    # where nobody picked these files and nothing can be corrected pre-upload. Attachment
+    # ambiguity degrades to a warning rather than raising: a raise strips the folder's retry
+    # marker and leaves fps at -1, so the folder would never converge.
+    reserved_items = [
+        item
+        for item in unprocessed_items
+        if frame_metadata.is_frame_metadata_source_name(item['name'])
+    ]
+    if attachment_item_id is None and len(reserved_items) > 1:
+        # The extras stay in the folder, so the remedy is to delete all but one and
+        # re-import; nothing is marked, so there is nothing to undo.
+        reserved_names = ', '.join(item['name'] for item in reserved_items)
+        aggregate_warnings.append(
+            f'More than one metadata file was found in the dataset folder: {reserved_names}. '
+            'None was attached; keep one and re-import.'
+        )
+
+    # Import the oldest annotation CSV and name the rest in a warning rather than failing.
+    annotation_csv_items = [
+        item
+        for item in unprocessed_items
+        if constants.csvRegex.search(item['name']) and not is_declared_sidecar(item)
+    ]
+    skipped_csv_items = annotation_csv_items[1:]
+    if skipped_csv_items:
+        skipped_names = ', '.join(item['name'] for item in skipped_csv_items)
+        aggregate_warnings.append(
+            f'Imported annotations from {annotation_csv_items[0]["name"]} only; '
+            f'skipped {skipped_names}. A dataset imports one annotation CSV at a time.'
+        )
+        skipped_ids = {str(item['_id']) for item in skipped_csv_items}
+        unprocessed_items = [
+            item for item in unprocessed_items if str(item['_id']) not in skipped_ids
+        ]
+
+    # image_map (extension-stripped media stems) feeds the VIAME parser and only exists for
+    # image-sequence folders. Skip the media walk entirely when only sidecars are present:
+    # a declared sidecar is classified by name and never joined here.
+    image_map = None
+    if fromMeta(folder, constants.TypeMarker) == constants.ImageSequenceType and any(
+        not is_declared_sidecar(item) for item in unprocessed_items
+    ):
+        image_map = crud.valid_image_names_dict(crud.valid_images(folder, user))
+
+    auxiliary = None
     for item in unprocessed_items:
         file: Optional[types.GirderModel] = next(Item().childFiles(item), None)
         if file is None:
             raise RestException('Item had no associated files')
 
+        # The single classification point: a declared sidecar is identified by attachment
+        # identity or reserved name and never reaches the annotation classifier. Keep it in
+        # the dataset folder for read-time discovery and mark it processed so it is not
+        # re-swept, but never import it as annotations, move it, or remove it.
+        if is_declared_sidecar(item):
+            if str(item['_id']) == attachment_item_id and not fromMeta(
+                folder, constants.MetadataFileItemIdMarker
+            ):
+                _attach_swept_sidecar(folder, item)
+            item['meta'][constants.ProcessedMarker] = True
+            Item().save(item)
+            aggregate_warnings.append(_frame_metadata_kept_warning(file['name']))
+            continue
+
         try:
-            image_map = None
-            if fromMeta(folder, constants.TypeMarker) == 'image-sequence':
-                image_map = crud.valid_image_names_dict(crud.valid_images(folder, user))
             results, warnings = _get_data_by_type(file, image_map=image_map)
             if warnings:
                 aggregate_warnings += warnings
         except Exception as e:
             Item().remove(item)
             if isinstance(e, ValueError):
-                raise RestException(f'Failed to import {file["name"]}: {e}') from e
+                hint = (
+                    ' If this file is frame metadata rather than annotations, upload it '
+                    'in the "Metadata File (Optional)" field on the upload page, or rename '
+                    'it to frame-metadata.csv and re-upload.'
+                    if constants.csvRegex.search(file['name'])
+                    else ''
+                )
+                raise RestException(f'Failed to import {file["name"]}: {e}{hint}') from e
             raise RestException(f'{file["name"]} was not a supported file type: {e}') from e
 
         if results is None:
             Item().remove(item)
             raise RestException(f'Unknown file type for {file["name"]}')
 
+        if auxiliary is None:
+            auxiliary = crud.get_or_create_auxiliary_folder(folder, user)
         item['meta'][constants.ProcessedMarker] = True
         Item().move(item, auxiliary)
         if results['annotations']:
diff --git a/server/dive_server/event.py b/server/dive_server/event.py
index c2b26dd3b..084459727 100644
--- a/server/dive_server/event.py
+++ b/server/dive_server/event.py
@@ -16,7 +16,7 @@
 from girder_plugin_worker.utils import getWorkerApiUrl
 
 from dive_tasks.dive_batch_postprocess import DIVEBatchPostprocessTaskParams
-from dive_utils import asbool, fromMeta
+from dive_utils import asbool, frame_metadata, fromMeta
 from dive_utils.constants import (
     AnnotationFileFutureProcessMarker,
     AssetstoreSourceMarker,
@@ -106,6 +106,10 @@ def process_assetstore_import(event, meta: dict):
         # Set the dataset to Video Type
         dataset_type = VideoType
     elif possibleAnnotationRegex.search(importPath):
+        if frame_metadata.is_frame_metadata_source_name(item['name']):
+            # Declared frame metadata sidecars are plain files: leave them in place for
+            # read-time discovery, no marker and no relocation.
+            return
         # Look for parent folder with same name
         parentFolder = Folder().findOne({"_id": item["folderId"]})
         userId = parentFolder['creatorId'] or parentFolder['baseParentId']
diff --git a/server/dive_server/views_dataset.py b/server/dive_server/views_dataset.py
index 5190cfd61..bc62513b0 100644
--- a/server/dive_server/views_dataset.py
+++ b/server/dive_server/views_dataset.py
@@ -41,6 +41,7 @@ def __init__(self, resourceName):
         self.route("POST", (":id", "calibration"), self.set_dataset_calibration)
         self.route("POST", (":id", "metadata_file"), self.set_dataset_metadata_file)
         self.route("GET", (":id", "media"), self.get_media)
+        self.route("GET", (":id", "frame_metadata_sources"), self.get_frame_metadata_sources)
         self.route("GET", ("export",), self.export)
         self.route("GET", (":id", "configuration"), self.get_configuration)
         self.route("GET", (":id", "media", ":mediaId", "download"), self.download_media)
@@ -203,7 +204,7 @@ def list_datasets(
     )
     def get_meta(self, folder):
         return crud_dataset.get_dataset(folder, self.getCurrentUser()).dict(exclude_none=True)
-    
+
     @access.user
     @autoDescribeRoute(
         Description("Get calibration information of dataset")
@@ -276,6 +277,17 @@ def get_configuration(self, folder):
     def get_media(self, folder):
         return crud_dataset.get_media(folder, self.getCurrentUser()).dict(exclude_none=True)
 
+    @access.user
+    @autoDescribeRoute(
+        Description(
+            "Load normalized frame-metadata attachment identities for the panel. "
+            "The server classifies sidecars by name only and never parses them; the client "
+            "downloads and parses the bytes."
+        ).modelParam("id", level=AccessType.READ, **DatasetModelParam)
+    )
+    def get_frame_metadata_sources(self, folder):
+        return crud_dataset.load_frame_metadata_sources(folder, self.getCurrentUser())
+
     @access.public(scope=TokenScope.DATA_READ, cookie=True)
     @autoDescribeRoute(
         Description("Export all selected datasets")
diff --git a/server/dive_tasks/tasks.py b/server/dive_tasks/tasks.py
index b9966fab9..1a1930166 100644
--- a/server/dive_tasks/tasks.py
+++ b/server/dive_tasks/tasks.py
@@ -313,9 +313,15 @@ def _inject_dataset_metadata_file(command, gc, working_dir: Path, params, manage
     md_item = gc.getItem(metadata_file_item_id)
     md_dir = utils.make_directory(working_dir / 'metadata_file')
     gc.downloadItem(metadata_file_item_id, str(md_dir), name=md_item.get('name'))
-    md_path = md_dir / md_item.get('name')
-    if md_path.exists():
-        append_metadata_file_kwiver_settings(command, md_path, metadata_file_key)
+    # Locate what actually landed rather than reconstructing md_dir/<item name>: girder_client
+    # nests the download under a directory of that name when the item's file is named differently
+    # from the item (a sidecar renamed after upload), and it sanitizes the name with
+    # transformFilename first. Both make the reconstructed path wrong -- and in the nested case it
+    # is a directory, so an exists() check passes and binds a directory into the KWIVER setting.
+    # md_dir is created fresh for this item, so anything under it is its content.
+    downloaded = next((path for path in sorted(md_dir.rglob('*')) if path.is_file()), None)
+    if downloaded is not None:
+        append_metadata_file_kwiver_settings(command, downloaded, metadata_file_key)
     else:
         manager.write(
             f'Warning: metadata item {metadata_file_item_id} '
@@ -958,7 +964,9 @@ def convert_calibration(self: Task, itemId: str):
         folder = gc.getFolder(folder_id)
         multi_cam = (folder.get('meta') or {}).get(constants.MultiCamMarker) or {}
         if str(multi_cam.get(constants.CalibrationItemIdMarker)) != str(itemId):
-            manager.write('Calibration source was replaced before linking JSON; discarding output.\n')
+            manager.write(
+                'Calibration source was replaced before linking JSON; discarding output.\n'
+            )
             gc.delete(f'item/{json_item_id}')
             return
 
diff --git a/server/dive_tasks/utils.py b/server/dive_tasks/utils.py
index 72e67a237..f8aed45cf 100644
--- a/server/dive_tasks/utils.py
+++ b/server/dive_tasks/utils.py
@@ -344,7 +344,13 @@ def upload_zipped_flat_media_files(
     working_directory: Path,
     create_subfolder=False,
 ):
-    """Takes a flat folder of media files and/or annotation and generates a dataset from it"""
+    """
+    Takes a flat folder of media files and/or annotation and generates a dataset from it.
+
+    validate_files is a gate on the whole zip here, not a per-file filter: the type and the
+    roles it reports are used, then every extracted file is uploaded, including anything the
+    response gives the ``ignored`` role. Only the interactive browser upload drops those.
+    """
     listOfFileNames = os.listdir(working_directory)
     validation = gc.sendRestRequest('POST', '/dive_dataset/validate_files', json=listOfFileNames)
     root_folderId = folderId
@@ -393,6 +399,54 @@ def _load_exported_dataset_meta(working_directory: Path) -> dict:
     return meta
 
 
+def _archive_metadata_attachment(scope_directory: Path) -> Optional[Path]:
+    """
+    The metadata attachment an export wrote for one dataset scope.
+
+    Attachments are discovered by directory alone: the single file anywhere under
+    ``<scope>/metadata/`` (a camera scope is the camera's own directory). meta.json
+    carries no locator, so any metadata key an older export left there is ignored.
+    The walk is recursive so an archive rewritten by a tool that nested the file is
+    still imported, matching ``archiveMetadataAttachment`` in
+    client/platform/desktop/backend/native/common.ts -- same directory rule, same two
+    error strings. Only the scoping differs: this function is reached solely through
+    ``_load_exported_dataset_meta`` callers, so an exported scope is already proven,
+    while the desktop twin runs on any picked folder and proves it itself with
+    ``isExportedDatasetDirectory``. Keep both gates when changing either side, or an
+    ordinary media folder that happens to hold a ``metadata/`` subdirectory starts
+    failing import on one platform only.
+    """
+    metadata_dir = scope_directory / 'metadata'
+    if not metadata_dir.is_dir():
+        return None
+    attachments = sorted(path for path in metadata_dir.rglob('*') if path.is_file())
+    if not attachments:
+        return None
+    if len(attachments) > 1:
+        raise ValueError(
+            'More than one metadata file was found in the archive metadata directory. '
+            'Keep one and try again.'
+        )
+    attachment = attachments[0]
+    if not constants.metadataFileRegex.search(attachment.name):
+        raise ValueError('Archive metadata attachment must be a JSON, TXT, or CSV file')
+    return attachment
+
+
+def _upload_archive_metadata_attachment(
+    gc: GirderClient,
+    dest_folder_id: str,
+    attachment: Optional[Path],
+) -> Optional[str]:
+    if attachment is None:
+        return None
+    gc.upload(str(attachment), dest_folder_id)
+    items = list(gc.listItem(dest_folder_id, name=attachment.name))
+    if len(items) != 1:
+        raise ValueError(f'Could not resolve uploaded metadata attachment {attachment.name}')
+    return str(items[0]['_id'])
+
+
 def _import_exported_dataset_directory(
     gc: GirderClient,
     manager: JobManager,
@@ -403,6 +457,7 @@ def _import_exported_dataset_directory(
     working_directory = Path(working_directory)
     list_of_names = os.listdir(working_directory)
     meta = _load_exported_dataset_meta(working_directory)
+    metadata_attachment = _archive_metadata_attachment(working_directory)
     dataset_type = meta[constants.TypeMarker]
     if dataset_type == constants.MultiType:
         raise ValueError(
@@ -425,7 +480,11 @@ def _import_exported_dataset_directory(
         shutil.rmtree(aux_path)
 
     manager.updateStatus(JobStatus.PUSHING_OUTPUT)
-    gc.upload(f'{working_directory}/*', dest_folder_id)
+    for entry in working_directory.iterdir():
+        if entry.name == 'metadata':
+            continue
+        gc.upload(str(entry), dest_folder_id)
+    metadata_item_id = _upload_archive_metadata_attachment(gc, dest_folder_id, metadata_attachment)
     all_files = list(gc.listItem(dest_folder_id))
     root_meta = {
         'type': dataset_type,
@@ -437,6 +496,9 @@ def _import_exported_dataset_directory(
         'fps': meta['fps'],
         'version': meta['version'],
     }
+    if metadata_item_id and metadata_attachment:
+        root_meta[constants.MetadataFileItemIdMarker] = metadata_item_id
+        root_meta[constants.MetadataFileOriginalNameMarker] = metadata_attachment.name
     if dataset_type == constants.VideoType:
         video = meta['video']
         transcoded_video = list(gc.listItem(dest_folder_id, name=video['filename']))
@@ -557,6 +619,10 @@ def upload_exported_multicam_zipped_dataset(
     with open(multi_cam_path) as f:
         multi_cam = json.load(f)
     parent_meta = _load_exported_dataset_meta(working_directory)
+    # Discovered before anything is created so a bad shared attachment fails the import
+    # without leaving half a dataset behind. Camera attachments live in each camera's own
+    # metadata/ directory and are restored by the per-camera import below.
+    parent_metadata_attachment = _archive_metadata_attachment(working_directory)
 
     default_display = multi_cam.get('defaultDisplay')
     cameras_meta = multi_cam.get('cameras') or {}
@@ -608,6 +674,9 @@ def upload_exported_multicam_zipped_dataset(
         calibration_file_id = _upload_stereo_calibration_files(
             gc, manager, parent_folder_id, working_directory
         )
+    metadata_file_id = _upload_archive_metadata_attachment(
+        gc, parent_folder_id, parent_metadata_attachment
+    )
 
     create_body = {
         'name': dataset_name,
@@ -620,6 +689,8 @@ def upload_exported_multicam_zipped_dataset(
     }
     if calibration_file_id:
         create_body['calibrationFileId'] = calibration_file_id
+    if metadata_file_id:
+        create_body['metadataFileId'] = metadata_file_id
 
     manager.write('Finalizing multicamera dataset…\n')
     gc.sendRestRequest(
diff --git a/server/dive_utils/constants.py b/server/dive_utils/constants.py
index 048fa68b2..91ef2f263 100644
--- a/server/dive_utils/constants.py
+++ b/server/dive_utils/constants.py
@@ -122,10 +122,9 @@
 # Girder item meta: original stereoscopic calibration upload (npz, yml, etc.)
 CalibrationFileMarker = "calibrationFile"
 # Optional per-dataset metadata file (folder marker points at a Girder item id;
-# the item itself carries MetadataFileMarker). Applies to single and multicam.
+# the owning folder carries the locator). Applies to single and multicam.
 MetadataFileItemIdMarker = "metadataFileItemId"
 MetadataFileOriginalNameMarker = "metadataFileOriginalName"
-MetadataFileMarker = "metadataFile"
 # Girder item meta: JSON camera-rig used for calibration display
 JsonCalibrationFileMarker = "jsonCalibrationFile"
 AssetstoreSourceMarker = "import_source"
diff --git a/server/dive_utils/frame_metadata.py b/server/dive_utils/frame_metadata.py
new file mode 100644
index 000000000..6c5a41194
--- /dev/null
+++ b/server/dive_utils/frame_metadata.py
@@ -0,0 +1,39 @@
+"""Reserved-name predicate for a dataset's frame metadata attachment.
+
+Keep this mirrored with ``client/dive-common/frameMetadata/naming.ts``, which implements the same
+basename predicate over the same six names for the desktop and web importers. A name in this set is
+read as a frame metadata attachment instead of being imported as annotations, so the two sides
+disagreeing means one platform imports a file the other attaches. The shared fixture
+``testutils/framemetadata.spec.json`` pins the truth table for both.
+
+One term throughout: the file is an *attachment*, and a name in this set *declares* it.
+"""
+
+import re
+
+FRAME_METADATA_SOURCE_NAMES = {
+    'frame-metadata.csv',
+    'frame-metadata.json',
+    'frame-metadata.txt',
+    'frame_metadata.csv',
+    'frame_metadata.json',
+    'frame_metadata.txt',
+}
+PATH_SPLIT_RE = re.compile(r'[/\\]')
+
+
+def is_frame_metadata_source_name(name: str) -> bool:
+    """A frame metadata sidecar is declared by basename."""
+    basename = PATH_SPLIT_RE.split(name)[-1]
+    return basename.lower() in FRAME_METADATA_SOURCE_NAMES
+
+
+def frame_metadata_source_name_query() -> dict:
+    """Mongo predicate matching a declared frame-metadata sidecar by reserved basename.
+
+    The query-side mirror of is_frame_metadata_source_name: Girder item names are basenames
+    (no path separators) and ``lowerName`` is the lowercased name, so an exact ``$in`` over the
+    reserved set is exactly that predicate -- and, unlike a regex, it can use the ``lowerName``
+    index. Deriving it from the constant keeps the query from drifting as the reserved set changes.
+    """
+    return {'lowerName': {'$in': sorted(FRAME_METADATA_SOURCE_NAMES)}}
diff --git a/server/tests/test_event_frame_metadata.py b/server/tests/test_event_frame_metadata.py
new file mode 100644
index 000000000..e5f6ab92f
--- /dev/null
+++ b/server/tests/test_event_frame_metadata.py
@@ -0,0 +1,62 @@
+import types as pytypes
+from unittest.mock import patch
+
+from dive_server import event
+from dive_utils.constants import AnnotationFileFutureProcessMarker
+
+
+def _event(info):
+    return pytypes.SimpleNamespace(info=info)
+
+
+# A real 24-hex ObjectId is required because process_assetstore_import wraps creatorId in ObjectId.
+_OWNER_ID = '000000000000000000000000'
+
+
+@patch('dive_server.event.User')
+@patch('dive_server.event.Folder')
+@patch('dive_server.event.Item')
+def test_assetstore_import_leaves_meta_sidecar_unmarked(item_cls, folder_cls, user_cls):
+    item = {'_id': 'i1', 'name': 'frame_metadata.csv', 'meta': {}, 'folderId': 'f1'}
+    item_model = item_cls.return_value
+    item_model.findOne.return_value = item
+
+    event.process_assetstore_import(
+        _event({'type': 'item', 'importPath': '/data/frame_metadata.csv', 'id': 'i1'}),
+        {},
+    )
+
+    # Declared sidecar: no future-process marker, no save, no relocation, folder untouched.
+    assert AnnotationFileFutureProcessMarker not in item['meta']
+    item_model.save.assert_not_called()
+    item_model.move.assert_not_called()
+    folder_cls.return_value.findOne.assert_not_called()
+
+
+@patch('dive_server.event.User')
+@patch('dive_server.event.Folder')
+@patch('dive_server.event.Item')
+def test_assetstore_import_marks_plain_annotation_csv(item_cls, folder_cls, user_cls):
+    item = {'_id': 'i1', 'name': 'dets.csv', 'meta': {}, 'folderId': 'f1'}
+    item_model = item_cls.return_value
+    item_model.findOne.return_value = item
+    parent_folder = {'_id': 'f1', 'creatorId': _OWNER_ID, 'baseParentId': None, 'meta': {}}
+    folder_model = folder_cls.return_value
+
+    def find_one(query):
+        if query == {'_id': 'f1'}:
+            return parent_folder
+        return None  # no co-named video folder exists
+
+    folder_model.findOne.side_effect = find_one
+    user_cls.return_value.findOne.return_value = {'_id': _OWNER_ID}
+
+    event.process_assetstore_import(
+        _event({'type': 'item', 'importPath': '/data/dets.csv', 'id': 'i1'}),
+        {},
+    )
+
+    # A plain annotation CSV is still marked for future processing, as on main.
+    assert item['meta'][AnnotationFileFutureProcessMarker] is True
+    item_model.save.assert_called_once()
+    item_model.move.assert_not_called()
diff --git a/server/tests/test_frame_metadata_naming.py b/server/tests/test_frame_metadata_naming.py
new file mode 100644
index 000000000..95602ef2d
--- /dev/null
+++ b/server/tests/test_frame_metadata_naming.py
@@ -0,0 +1,21 @@
+"""Python parity check for frame-metadata source names.
+
+``frame_metadata`` / ``frame-metadata`` with a ``.json``, ``.csv``, or ``.txt`` extension is the
+single declared-by-name flag that travels every ingestion path. The predicate is mirrored
+in Python (``dive_utils.frame_metadata``) and in the shared TypeScript module; both
+harnesses assert the same accepted/rejected truth table so the two mirrors stay aligned.
+"""
+
+import json
+from pathlib import Path
+
+from dive_utils.frame_metadata import is_frame_metadata_source_name
+
+SOURCE_NAMES_FIXTURE = Path(__file__).parents[2] / 'testutils' / 'framemetadata.spec.json'
+
+
+def test_source_names_predicate_matches_shared_truth_table():
+    truth_table = json.loads(SOURCE_NAMES_FIXTURE.read_text(encoding='utf-8'))
+    assert truth_table, 'source_names truth table fixture is empty'
+    for name, expected in truth_table.items():
+        assert is_frame_metadata_source_name(name) is expected, name
diff --git a/server/tests/test_frame_metadata_sources.py b/server/tests/test_frame_metadata_sources.py
new file mode 100644
index 000000000..a1224fe1d
--- /dev/null
+++ b/server/tests/test_frame_metadata_sources.py
@@ -0,0 +1,629 @@
+from unittest.mock import patch
+
+from girder.exceptions import AccessException, RestException
+import pytest
+
+from dive_server import crud_dataset
+from dive_server.views_dataset import DatasetResource
+from dive_utils import constants
+
+
+def _dataset_folder(dataset_type=constants.ImageSequenceType, clone_of=None):
+    folder = {
+        '_id': 'dataset-id',
+        'name': 'single-camera',
+        'meta': {'annotate': True, 'type': dataset_type, 'fps': 5},
+    }
+    if clone_of is not None:
+        # Only a clone has a media source folder distinct from itself.
+        folder[constants.ForeignMediaIdMarker] = clone_of
+    return folder
+
+
+def _root_folder(folder_id: str):
+    return {'_id': folder_id, 'name': folder_id, 'meta': {}}
+
+
+def _camera_folder(
+    folder_id: str,
+    name: str,
+    dataset_type=constants.ImageSequenceType,
+    clone_of=None,
+):
+    folder = {
+        '_id': folder_id,
+        'name': name,
+        'meta': {'annotate': True, 'type': dataset_type, 'fps': 5},
+    }
+    if clone_of is not None:
+        folder[constants.ForeignMediaIdMarker] = clone_of
+    return folder
+
+
+def _multicam_parent_folder(clone_of=None):
+    folder = {
+        '_id': 'parent-id',
+        'name': 'stereo-camera',
+        'meta': {
+            'annotate': True,
+            'type': constants.MultiType,
+            'fps': 5,
+            'multiCam': {
+                'defaultDisplay': 'port',
+                'cameraOrder': ['port', 'starboard'],
+                'cameras': {
+                    'port': {'folderId': 'port-id', 'type': constants.ImageSequenceType},
+                    'starboard': {
+                        'folderId': 'starboard-id',
+                        'type': constants.ImageSequenceType,
+                    },
+                },
+            },
+        },
+    }
+    if clone_of is not None:
+        folder[constants.ForeignMediaIdMarker] = clone_of
+    return folder
+
+
+def _source_item(name: str):
+    return {'_id': f'{name}-id', 'name': name}
+
+
+def _descriptor(name: str):
+    return {'itemId': f'{name}-id', 'name': name}
+
+
+def _child_items_by_folder(folder_model, items_by_folder_id):
+    # Apply the reserved-name filter the way Mongo does, so the mock can never hand the
+    # resolver an item the real query would have excluded.
+    def child_items(folder, filters=None):
+        items = items_by_folder_id.get(folder['_id'], [])
+        allowed = ((filters or {}).get('lowerName') or {}).get('$in')
+        if allowed is None:
+            return items
+        return [item for item in items if item['name'].lower() in allowed]
+
+    folder_model.childItems.side_effect = child_items
+
+
+def _wire_multicam_folders(folder_model, children):
+    def load_folder(folder_id, level=None, user=None):
+        return children.get(folder_id)
+
+    folder_model.load.side_effect = load_folder
+
+
+def _wire_clone_roots(get_clone_root, roots_by_folder_id):
+    def clone_root(user, folder):
+        return roots_by_folder_id[folder['_id']]
+
+    get_clone_root.side_effect = clone_root
+
+
+@patch('dive_server.crud_dataset.Folder')
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+@pytest.mark.parametrize(
+    'dataset_type',
+    [constants.ImageSequenceType, constants.VideoType],
+)
+def test_sources_single_camera_uses_one_reserved_name_fallback(
+    get_clone_root,
+    folder_cls,
+    dataset_type,
+):
+    dataset = _dataset_folder(dataset_type)
+    get_clone_root.return_value = dataset
+    folder_cls.return_value.childItems.return_value = [_source_item('frame_metadata.csv')]
+
+    assert crud_dataset.load_frame_metadata_sources(dataset, {'_id': 'user-id'}) == {
+        'shared': _descriptor('frame_metadata.csv'),
+        'cameras': {},
+    }
+    # The query is the only reserved-name filter on this path: nothing it returns is
+    # re-checked in Python, so it is pinned literally here.
+    folder_cls.return_value.childItems.assert_called_once_with(
+        dataset,
+        filters={
+            'lowerName': {
+                '$in': [
+                    'frame-metadata.csv',
+                    'frame-metadata.json',
+                    'frame-metadata.txt',
+                    'frame_metadata.csv',
+                    'frame_metadata.json',
+                    'frame_metadata.txt',
+                ]
+            }
+        },
+    )
+
+
+@patch('dive_server.crud_dataset.Folder')
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+def test_sources_report_ambiguous_reserved_name_fallback(get_clone_root, folder_cls):
+    dataset = _dataset_folder()
+    get_clone_root.return_value = dataset
+    folder_cls.return_value.childItems.return_value = [
+        _source_item('frame_metadata.csv'),
+        _source_item('frame-metadata.txt'),
+    ]
+
+    assert crud_dataset.load_frame_metadata_sources(dataset, {'_id': 'user-id'}) == {
+        'shared': {
+            'name': 'Metadata File',
+            'error': 'More than one reserved-name metadata attachment is available.',
+        },
+        'cameras': {},
+    }
+
+
+@patch('dive_server.crud_dataset.Item')
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+@pytest.mark.parametrize(
+    'dataset_type',
+    [constants.ImageSequenceType, constants.VideoType],
+)
+def test_sources_single_camera_reads_explicit_attachment_from_clone_root(
+    get_clone_root,
+    item_cls,
+    dataset_type,
+):
+    dataset = _dataset_folder(dataset_type, clone_of='source-root-id')
+    source_root = _root_folder('source-root-id')
+    source_root['meta'].update(
+        {
+            constants.MetadataFileItemIdMarker: 'source-item-id',
+            constants.MetadataFileOriginalNameMarker: 'flight.json',
+        }
+    )
+    get_clone_root.return_value = source_root
+    item_cls.return_value.load.return_value = {
+        '_id': 'source-item-id',
+        'folderId': 'source-root-id',
+        'name': 'stored.json',
+    }
+
+    assert crud_dataset.load_frame_metadata_sources(dataset, {'_id': 'user-id'}) == {
+        'shared': {'itemId': 'source-item-id', 'name': 'flight.json'},
+        'cameras': {},
+    }
+
+
+@patch('dive_server.crud_dataset.Item')
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+def test_sources_clone_root_attachment_does_not_need_the_callers_acl(
+    get_clone_root,
+    item_cls,
+):
+    """Scope membership is the guard, not the caller's access to the clone root.
+
+    getCloneRoot force-loads the source folder, so the caller may have no READ on it; an
+    access-checked item load would raise AccessException and 403 the panel for a clone whose
+    source was unshared, even though crud.valid_images already lists that root's media.
+    """
+    dataset = _dataset_folder(clone_of='source-root-id')
+    source_root = _root_folder('source-root-id')
+    source_root['meta'].update(
+        {
+            constants.MetadataFileItemIdMarker: 'source-item-id',
+            constants.MetadataFileOriginalNameMarker: 'flight.json',
+        }
+    )
+    get_clone_root.return_value = source_root
+
+    def load_item(item_id, level=None, user=None, force=False):
+        if not force:
+            raise AccessException('Read access denied for folder source-root-id.')
+        return {'_id': 'source-item-id', 'folderId': 'source-root-id', 'name': 'stored.json'}
+
+    item_cls.return_value.load.side_effect = load_item
+
+    assert crud_dataset.load_frame_metadata_sources(dataset, {'_id': 'user-id'}) == {
+        'shared': {'itemId': 'source-item-id', 'name': 'flight.json'},
+        'cameras': {},
+    }
+
+
+@patch('dive_server.crud_dataset.Folder')
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+def test_sources_single_camera_no_attachment_returns_empty(get_clone_root, folder_cls):
+    dataset = _dataset_folder()
+    get_clone_root.return_value = dataset
+    folder_cls.return_value.childItems.return_value = []
+
+    assert crud_dataset.load_frame_metadata_sources(dataset, {'_id': 'user-id'}) == {'cameras': {}}
+
+
+@patch('dive_server.crud_dataset.Folder')
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+def test_sources_large_image_returns_empty(get_clone_root, folder_cls):
+    dataset = {
+        '_id': 'ds',
+        'name': 'x',
+        'meta': {'annotate': True, 'type': constants.LargeImageType, 'fps': 5},
+    }
+
+    result = crud_dataset.load_frame_metadata_sources(dataset, {'_id': 'user-id'})
+
+    # Non-image-sequence media types never expose sidecars; no folder is even walked.
+    assert result == {'cameras': {}}
+    folder_cls.return_value.childItems.assert_not_called()
+    get_clone_root.assert_not_called()
+
+
+@patch('dive_server.crud_dataset.Folder')
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+def test_sources_multicam_returns_shared_once_and_camera_local_once(get_clone_root, folder_cls):
+    # A cloned multicam: every folder's attachment lives in its media source root.
+    parent = _multicam_parent_folder(clone_of='parent-root-id')
+    port = _camera_folder('port-id', 'port', clone_of='port-root-id')
+    starboard = _camera_folder('starboard-id', 'starboard', clone_of='starboard-root-id')
+    parent_root = _root_folder('parent-root-id')
+    port_root = _root_folder('port-root-id')
+    starboard_root = _root_folder('starboard-root-id')
+    user = {'_id': 'user-id'}
+
+    folder_model = folder_cls.return_value
+    _wire_multicam_folders(folder_model, {'port-id': port, 'starboard-id': starboard})
+    _child_items_by_folder(
+        folder_model,
+        {
+            'port-id': [_source_item('frame_metadata.csv')],
+            'port-root-id': [],
+            'starboard-id': [],
+            'starboard-root-id': [],
+            'parent-id': [],
+            'parent-root-id': [_source_item('frame-metadata.txt')],
+        },
+    )
+    _wire_clone_roots(
+        get_clone_root,
+        {
+            'parent-id': parent_root,
+            'port-id': port_root,
+            'starboard-id': starboard_root,
+        },
+    )
+
+    result = crud_dataset.load_frame_metadata_sources(parent, user)
+
+    assert result == {
+        'shared': _descriptor('frame-metadata.txt'),
+        'cameras': {
+            'port': _descriptor('frame_metadata.csv'),
+        },
+    }
+
+
+@patch('dive_server.crud_dataset.Item')
+@patch('dive_server.crud_dataset.Folder')
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+def test_sources_camera_reserved_name_replaces_shared_explicit_attachment(
+    get_clone_root,
+    folder_cls,
+    item_cls,
+):
+    """A camera-local attachment replaces the shared one for that camera, however declared."""
+    parent = _multicam_parent_folder()
+    parent['meta'].update(
+        {
+            constants.MetadataFileItemIdMarker: 'shared-id',
+            constants.MetadataFileOriginalNameMarker: 'shared.csv',
+        }
+    )
+    port = _camera_folder('port-id', 'port')
+    starboard = _camera_folder('starboard-id', 'starboard')
+    parent_root = _root_folder('parent-root-id')
+    folder_model = folder_cls.return_value
+    _wire_multicam_folders(folder_model, {'port-id': port, 'starboard-id': starboard})
+    _child_items_by_folder(
+        folder_model,
+        {
+            'port-id': [_source_item('frame_metadata.csv')],
+            'port-root-id': [],
+            'starboard-id': [],
+            'starboard-root-id': [],
+        },
+    )
+    item_cls.return_value.load.return_value = {
+        '_id': 'shared-id',
+        'folderId': 'parent-id',
+        'name': 'stored.csv',
+    }
+    _wire_clone_roots(
+        get_clone_root,
+        {
+            'parent-id': parent_root,
+            'port-id': _root_folder('port-root-id'),
+            'starboard-id': _root_folder('starboard-root-id'),
+        },
+    )
+
+    assert crud_dataset.load_frame_metadata_sources(parent, {'_id': 'user-id'}) == {
+        'shared': {'itemId': 'shared-id', 'name': 'shared.csv'},
+        'cameras': {'port': _descriptor('frame_metadata.csv')},
+    }
+
+
+@patch('dive_server.crud_dataset.Folder')
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+def test_sources_multicam_skips_large_image_camera(get_clone_root, folder_cls):
+    parent = _multicam_parent_folder()
+    port = _camera_folder('port-id', 'port')
+    starboard = {
+        '_id': 'starboard-id',
+        'name': 'starboard',
+        'meta': {'type': constants.LargeImageType},
+    }
+    parent_root = _root_folder('parent-root-id')
+    user = {'_id': 'user-id'}
+
+    folder_model = folder_cls.return_value
+    _wire_multicam_folders(folder_model, {'port-id': port, 'starboard-id': starboard})
+    _child_items_by_folder(
+        folder_model,
+        {
+            'port-id': [_source_item('frame_metadata.csv')],
+            'port-root-id': [],
+            'parent-id': [],
+            'parent-root-id': [],
+        },
+    )
+    _wire_clone_roots(
+        get_clone_root,
+        {'parent-id': parent_root, 'port-id': _root_folder('port-root-id')},
+    )
+
+    result = crud_dataset.load_frame_metadata_sources(parent, user)
+
+    assert result == {'cameras': {'port': _descriptor('frame_metadata.csv')}}
+
+
+@patch('dive_server.crud_dataset.Folder')
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+def test_sources_multicam_includes_video_camera(get_clone_root, folder_cls):
+    parent = _multicam_parent_folder()
+    port = _camera_folder('port-id', 'port', constants.VideoType)
+    starboard = _camera_folder('starboard-id', 'starboard', constants.LargeImageType)
+    parent_root = _root_folder('parent-root-id')
+    port_root = _root_folder('port-root-id')
+    user = {'_id': 'user-id'}
+
+    folder_model = folder_cls.return_value
+    _wire_multicam_folders(folder_model, {'port-id': port, 'starboard-id': starboard})
+    _child_items_by_folder(
+        folder_model,
+        {
+            'port-id': [_source_item('frame_metadata.csv')],
+            'port-root-id': [],
+            'parent-id': [],
+            'parent-root-id': [],
+        },
+    )
+    _wire_clone_roots(
+        get_clone_root,
+        {'parent-id': parent_root, 'port-id': port_root},
+    )
+
+    result = crud_dataset.load_frame_metadata_sources(parent, user)
+
+    assert result == {'cameras': {'port': _descriptor('frame_metadata.csv')}}
+
+
+@patch('dive_server.crud_dataset.Folder')
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+def test_sources_multicam_missing_camera_folder_raises_404(get_clone_root, folder_cls):
+    parent = _multicam_parent_folder()
+    user = {'_id': 'user-id'}
+    get_clone_root.return_value = _root_folder('parent-root-id')
+    _wire_multicam_folders(folder_cls.return_value, {})
+
+    with pytest.raises(RestException, match='Camera folder for "port" was not found') as exc_info:
+        crud_dataset.load_frame_metadata_sources(parent, user)
+
+    assert exc_info.value.code == 404
+
+
+@patch('dive_server.crud_dataset.Item')
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+def test_sources_expose_selected_metadata_attachment_once_as_shared(get_clone_root, item_cls):
+    dataset = _dataset_folder()
+    dataset['meta'][constants.MetadataFileItemIdMarker] = 'flight_log.csv-id'
+    dataset['meta'][constants.MetadataFileOriginalNameMarker] = 'flight_log.csv'
+    user = {'_id': 'user-id'}
+    get_clone_root.return_value = dataset
+    item_cls.return_value.load.return_value = {
+        '_id': 'flight_log.csv-id',
+        'folderId': 'dataset-id',
+        'name': 'stored.csv',
+    }
+
+    # The selected metadata attachment is a frame metadata source without another marker or
+    # association. A pipeline still receives this exact item even if its rows do not match.
+    assert crud_dataset.load_frame_metadata_sources(dataset, user) == {
+        'shared': {
+            'itemId': 'flight_log.csv-id',
+            'name': 'flight_log.csv',
+        },
+        'cameras': {},
+    }
+
+
+@patch('dive_server.crud_dataset.Item')
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+def test_sources_fall_back_to_item_name_when_original_name_is_absent(
+    get_clone_root,
+    item_cls,
+):
+    dataset = _dataset_folder()
+    dataset['meta'][constants.MetadataFileItemIdMarker] = 'flight_log.csv-id'
+    user = {'_id': 'user-id'}
+    get_clone_root.return_value = dataset
+    item_cls.return_value.load.return_value = {
+        '_id': 'flight_log.csv-id',
+        'folderId': 'dataset-id',
+        'name': 'flight_log.csv',
+    }
+
+    assert crud_dataset.load_frame_metadata_sources(dataset, user) == {
+        'shared': {
+            'itemId': 'flight_log.csv-id',
+            'name': 'flight_log.csv',
+        },
+        'cameras': {},
+    }
+
+
+@patch('dive_server.crud_dataset.Folder')
+@patch('dive_server.crud_dataset.Item')
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+def test_sources_keep_missing_explicit_attachment_visible_without_reserved_fallback(
+    get_clone_root,
+    item_cls,
+    folder_cls,
+):
+    dataset = _dataset_folder()
+    dataset['meta'][constants.MetadataFileItemIdMarker] = 'missing-id'
+    dataset['meta'][constants.MetadataFileOriginalNameMarker] = 'missing.csv'
+    get_clone_root.return_value = dataset
+    item_cls.return_value.load.return_value = None
+
+    assert crud_dataset.load_frame_metadata_sources(dataset, {'_id': 'user-id'}) == {
+        'shared': {
+            'name': 'missing.csv',
+            'error': 'Metadata attachment is unavailable.',
+        },
+        'cameras': {},
+    }
+    folder_cls.return_value.childItems.assert_not_called()
+
+
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+@patch('dive_server.crud_dataset.Folder')
+@patch('dive_server.crud_dataset.Item')
+def test_replace_attachment_removes_owned_previous_item_after_record_save(
+    item_cls,
+    folder_cls,
+    get_clone_root,
+):
+    dataset = _dataset_folder()
+    dataset['meta'][constants.MetadataFileItemIdMarker] = 'old-id'
+    get_clone_root.return_value = dataset
+    new_item = {'_id': 'new-id', 'folderId': 'dataset-id', 'name': 'new.csv'}
+    old_item = {'_id': 'old-id', 'folderId': 'dataset-id', 'name': 'old.csv'}
+    # The superseded id is read straight off the marker, so the loads are: validate the
+    # replacement, then load the superseded item for removal.
+    item_cls.return_value.load.side_effect = [new_item, old_item]
+
+    result = crud_dataset.set_metadata_file({'_id': 'user-id'}, dataset, 'new-id')
+
+    assert result == {
+        'metadataFileItemId': 'new-id',
+        'metadataFileOriginalName': 'new.csv',
+    }
+    folder_cls.return_value.save.assert_called_once_with(dataset)
+    item_cls.return_value.remove.assert_called_once_with(old_item)
+
+
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+@patch('dive_server.crud_dataset.Folder')
+@patch('dive_server.crud_dataset.Item')
+def test_replace_reserved_name_attachment_keeps_it(item_cls, folder_cls, get_clone_root):
+    """A reserved-name file is the user's own content: it is shadowed, never deleted."""
+    dataset = _dataset_folder()
+    get_clone_root.return_value = dataset
+    reserved_item = {
+        '_id': 'frame_metadata.csv-id',
+        'folderId': 'dataset-id',
+        'name': 'frame_metadata.csv',
+    }
+    new_item = {'_id': 'new-id', 'folderId': 'dataset-id', 'name': 'new.csv'}
+    folder_cls.return_value.childItems.return_value = [reserved_item]
+    item_cls.return_value.load.side_effect = [new_item]
+
+    crud_dataset.set_metadata_file({'_id': 'user-id'}, dataset, 'new-id')
+
+    item_cls.return_value.remove.assert_not_called()
+    assert dataset['meta'][constants.MetadataFileItemIdMarker] == 'new-id'
+
+
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+@patch('dive_server.crud_dataset.Folder')
+@patch('dive_server.crud_dataset.Item')
+def test_replace_marked_reserved_name_attachment_keeps_it(item_cls, folder_cls, get_clone_root):
+    """The marker cannot vouch for ownership: process_items records what it discovers in it.
+
+    A reserved-name file uploaded alongside the media is swept, marked, and left in place.
+    Deleting it here as a superseded attachment would destroy a file the user uploaded, so
+    ownership is decided by the reserved-name predicate, not by the marker's presence.
+    """
+    dataset = _dataset_folder()
+    dataset['meta'][constants.MetadataFileItemIdMarker] = 'swept-id'
+    get_clone_root.return_value = dataset
+    new_item = {'_id': 'new-id', 'folderId': 'dataset-id', 'name': 'new.csv'}
+    swept_item = {'_id': 'swept-id', 'folderId': 'dataset-id', 'name': 'frame_metadata.csv'}
+    item_cls.return_value.load.side_effect = [new_item, swept_item]
+
+    crud_dataset.set_metadata_file({'_id': 'user-id'}, dataset, 'new-id')
+
+    item_cls.return_value.remove.assert_not_called()
+    assert dataset['meta'][constants.MetadataFileItemIdMarker] == 'new-id'
+
+
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+@patch('dive_server.crud_dataset.Folder')
+@patch('dive_server.crud_dataset.Item')
+def test_replace_clone_attachment_does_not_remove_source_item(
+    item_cls,
+    folder_cls,
+    get_clone_root,
+):
+    dataset = _dataset_folder()
+    dataset[constants.ForeignMediaIdMarker] = 'source-root-id'
+    dataset['meta'][constants.MetadataFileItemIdMarker] = 'source-id'
+    get_clone_root.return_value = _root_folder('source-root-id')
+    new_item = {'_id': 'new-id', 'folderId': 'dataset-id', 'name': 'new.csv'}
+    source_item = {'_id': 'source-id', 'folderId': 'source-root-id', 'name': 'source.csv'}
+    item_cls.return_value.load.side_effect = [new_item, source_item]
+
+    crud_dataset.set_metadata_file({'_id': 'user-id'}, dataset, 'new-id')
+
+    folder_cls.return_value.save.assert_called_once_with(dataset)
+    item_cls.return_value.remove.assert_not_called()
+
+
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+@patch('dive_server.crud_dataset.cherrypy.log')
+@patch('dive_server.crud_dataset.Folder')
+@patch('dive_server.crud_dataset.Item')
+def test_replace_attachment_stays_successful_when_old_item_cleanup_fails(
+    item_cls,
+    folder_cls,
+    log,
+    get_clone_root,
+):
+    dataset = _dataset_folder()
+    dataset['meta'][constants.MetadataFileItemIdMarker] = 'old-id'
+    get_clone_root.return_value = dataset
+    new_item = {'_id': 'new-id', 'folderId': 'dataset-id', 'name': 'new.csv'}
+    old_item = {'_id': 'old-id', 'folderId': 'dataset-id', 'name': 'old.csv'}
+    item_cls.return_value.load.side_effect = [new_item, old_item]
+    item_cls.return_value.remove.side_effect = RuntimeError('cleanup failed')
+
+    result = crud_dataset.set_metadata_file({'_id': 'user-id'}, dataset, 'new-id')
+
+    assert result['metadataFileItemId'] == 'new-id'
+    folder_cls.return_value.save.assert_called_once_with(dataset)
+    log.assert_called_once()
+
+
+@patch('girder.api.rest.Resource.route')
+def test_dataset_resource_registers_frame_metadata_sources_route(route):
+    with patch('dive_server.views_dataset.Folder'):
+        resource = DatasetResource('dive_dataset')
+
+    assert any(
+        call.args == ("GET", (":id", "frame_metadata_sources"), resource.get_frame_metadata_sources)
+        for call in route.call_args_list
+    )
diff --git a/server/tests/test_inject_metadata_file.py b/server/tests/test_inject_metadata_file.py
new file mode 100644
index 000000000..0b3e0d557
--- /dev/null
+++ b/server/tests/test_inject_metadata_file.py
@@ -0,0 +1,94 @@
+"""Locating the downloaded frame metadata sidecar for an opt-in pipeline.
+
+girder_client.downloadItem writes `dest/<item name>` only when the item holds exactly one file
+whose name equals the item name. Otherwise it creates `dest/<item name>/` and writes the files
+inside. These tests pin that both shapes bind a real file to the KWIVER setting.
+"""
+
+from pathlib import Path
+
+from dive_tasks.tasks import _inject_dataset_metadata_file
+
+
+class FakeGirderClient:
+    """Reproduces downloadItem's nest-or-flatten rule over a fake item."""
+
+    def __init__(self, item_name, file_names):
+        self.item_name = item_name
+        self.file_names = file_names
+
+    def getItem(self, _item_id):
+        return {'name': self.item_name}
+
+    def downloadItem(self, _item_id, dest, name=None):
+        dest_path = Path(dest)
+        if len(self.file_names) == 1 and self.file_names[0] == self.item_name:
+            (dest_path / self.item_name).write_text('frame,lat\n0,-124.6\n')
+            return
+        nested = dest_path / self.item_name
+        nested.mkdir(parents=True, exist_ok=True)
+        for file_name in self.file_names:
+            (nested / file_name).write_text('frame,lat\n0,-124.6\n')
+
+
+class RecordingManager:
+    def __init__(self):
+        self.messages = []
+
+    def write(self, message):
+        self.messages.append(message)
+
+
+def _params():
+    return {'metadata_file_item_id': 'item-id', 'metadata_file_key': 'stabilizer:flight_log'}
+
+
+def _setting_path(command):
+    """The path bound by the single `-s key=path` entry the injection appends."""
+    assert len(command) == 1
+    return Path(command[0].split('=', 1)[1])
+
+
+def test_binds_the_file_when_girder_client_writes_it_flat(tmp_path):
+    gc = FakeGirderClient('frame-metadata.csv', ['frame-metadata.csv'])
+    command = []
+
+    _inject_dataset_metadata_file(command, gc, tmp_path, _params(), RecordingManager())
+
+    bound = _setting_path(command)
+    assert bound.is_file()
+    assert bound.name == 'frame-metadata.csv'
+
+
+def test_binds_the_file_when_girder_client_nests_it_under_the_item_name(tmp_path):
+    # Item renamed after upload: the item is 'flight-log-v2.csv' but its file is still
+    # 'frame-metadata.csv', so girder_client creates a directory. Reconstructing
+    # md_dir/<item name> would yield that directory, which exists() accepts.
+    gc = FakeGirderClient('flight-log-v2.csv', ['frame-metadata.csv'])
+    command = []
+
+    _inject_dataset_metadata_file(command, gc, tmp_path, _params(), RecordingManager())
+
+    bound = _setting_path(command)
+    assert bound.is_file(), 'must bind the contained file, never the directory'
+    assert bound.name == 'frame-metadata.csv'
+
+
+def test_warns_when_the_item_downloads_nothing(tmp_path):
+    gc = FakeGirderClient('nav.csv', [])
+    command = []
+    manager = RecordingManager()
+
+    _inject_dataset_metadata_file(command, gc, tmp_path, _params(), manager)
+
+    assert command == []
+    assert 'no downloadable file' in manager.messages[0]
+
+
+def test_is_a_no_op_when_the_pipeline_did_not_opt_in(tmp_path):
+    gc = FakeGirderClient('nav.csv', ['nav.csv'])
+    command = []
+
+    _inject_dataset_metadata_file(command, gc, tmp_path, {}, RecordingManager())
+
+    assert command == []
diff --git a/server/tests/test_multicam_export_clone.py b/server/tests/test_multicam_export_clone.py
index d91e5952d..493a95fad 100644
--- a/server/tests/test_multicam_export_clone.py
+++ b/server/tests/test_multicam_export_clone.py
@@ -2,6 +2,8 @@
 import json
 from unittest.mock import MagicMock, patch
 
+from girder.exceptions import AccessException
+
 from dive_server import crud_dataset
 from dive_utils import constants
 
@@ -48,6 +50,14 @@ def _child_folder(folder_id: str, name: str):
     }
 
 
+def _source_item(name: str):
+    return {'_id': f'{name}-id', 'name': name}
+
+
+def _descriptor(name: str):
+    return {'itemId': f'{name}-id', 'name': name}
+
+
 @patch('dive_server.crud_dataset.find_json_calibration_item_id', return_value=None)
 @patch('dive_server.crud_dataset.find_calibration_item_id', return_value=None)
 @patch('dive_server.crud_dataset.crud_annotation.clone_annotations')
@@ -129,11 +139,90 @@ def test_create_multicam_soft_clone_copies_calibration(
     clone_cals_mock.assert_called_once()
     saved_meta = folder_cls.return_value.save.call_args_list[-1][0][0]['meta']
     assert saved_meta[constants.MultiCamMarker][constants.CalibrationItemIdMarker] == 'new-cal-src'
-    assert saved_meta[constants.MultiCamMarker][constants.JsonCalibrationItemIdMarker] == 'new-cal-json'
+    assert (
+        saved_meta[constants.MultiCamMarker][constants.JsonCalibrationItemIdMarker]
+        == 'new-cal-json'
+    )
+
+
+@patch('dive_server.crud_dataset.find_json_calibration_item_id', return_value=None)
+@patch('dive_server.crud_dataset.find_calibration_item_id', return_value=None)
+@patch('dive_server.crud_dataset.crud_annotation.clone_annotations')
+@patch('dive_server.crud_dataset.crud.get_or_create_auxiliary_folder')
+@patch('dive_server.crud_dataset._create_single_camera_soft_clone')
+@patch('dive_server.crud_dataset.Item')
+@patch('dive_server.crud_dataset.Folder')
+@patch('dive_server.crud.Folder')
+def test_multicam_soft_clone_preserves_shared_parent_frame_metadata_source(
+    crud_folder_cls,
+    folder_cls,
+    item_cls,
+    create_soft_clone_mock,
+    _aux,
+    _clone_ann,
+    _find_cal,
+    _find_json_cal,
+):
+    owner = {'login': 'tester'}
+    source = _multi_parent_folder()
+    source['meta'][constants.MetadataFileItemIdMarker] = 'shared-id'
+    source['meta'][constants.MetadataFileOriginalNameMarker] = 'flight-log.csv'
+    parent = {'_id': 'dest-parent'}
+    left = _child_folder('left-id', 'left')
+    right = _child_folder('right-id', 'right')
+    cloned_left = {
+        **copy.deepcopy(left),
+        '_id': 'clone-left-id',
+        constants.ForeignMediaIdMarker: 'left-id',
+    }
+    cloned_right = {
+        **copy.deepcopy(right),
+        '_id': 'clone-right-id',
+        constants.ForeignMediaIdMarker: 'right-id',
+    }
+    cloned_parent = copy.deepcopy(source)
+    cloned_parent['_id'] = 'clone-parent-id'
+
+    folder_model = folder_cls.return_value
+    folder_model.createFolder.return_value = cloned_parent
+    folders_by_id = {
+        'parent-id': source,
+        'left-id': left,
+        'right-id': right,
+        'clone-left-id': cloned_left,
+        'clone-right-id': cloned_right,
+    }
+    folder_model.load.side_effect = lambda folder_id, **kwargs: folders_by_id.get(folder_id)
+    crud_folder_cls.return_value.load.side_effect = lambda folder_id, **kwargs: folders_by_id.get(
+        folder_id
+    )
+    item_cls.return_value.load.return_value = {
+        '_id': 'shared-id',
+        'folderId': 'parent-id',
+        'name': 'stored.csv',
+    }
+    # filters is the server-side sidecar pre-filter; the mock ignores it and returns the
+    # full per-folder list so the is_declared post-filter still decides membership.
+    folder_model.childItems.side_effect = lambda folder, filters=None: {
+        'parent-id': [],
+        'clone-parent-id': [],
+        'left-id': [],
+        'right-id': [],
+        'clone-left-id': [],
+        'clone-right-id': [],
+    }.get(folder['_id'], [])
+    create_soft_clone_mock.side_effect = [cloned_left, cloned_right]
+
+    result = crud_dataset.createSoftClone(owner, source, parent, 'Clone stereo', None)
+    sources = crud_dataset.load_frame_metadata_sources(result, owner)
+
+    assert sources == {
+        'shared': {'itemId': 'shared-id', 'name': 'flight-log.csv'},
+        'cameras': {},
+    }
 
 
 @patch('dive_server.crud_dataset._yield_single_dataset_export')
-@patch('dive_server.crud_dataset._yield_metadata_file')
 @patch('dive_server.crud_dataset._yield_calibration_files')
 @patch('dive_server.crud_dataset.get_multi_cam_media')
 @patch('dive_server.crud_dataset.Folder')
@@ -143,7 +232,6 @@ def test_export_multicam_zip_includes_multicam_json_and_cameras(
     folder_cls,
     get_multi_cam_media_mock,
     yield_cal_mock,
-    yield_metadata_mock,
     yield_single_mock,
 ):
     parent = _multi_parent_folder()
@@ -163,7 +251,6 @@ def add_file_side_effect(_maker, path):
     zip_gen_cls.return_value = z
     yield_single_mock.return_value = iter([b'camera-chunk'])
     yield_cal_mock.return_value = iter([b'cal-chunk'])
-    yield_metadata_mock.return_value = iter([b'metadata-chunk'])
     get_multi_cam_media_mock.return_value = MagicMock()
 
     stream = crud_dataset.export_datasets_zipstream(
@@ -183,12 +270,17 @@ def add_file_side_effect(_maker, path):
     assert './stereo-dataset/left/' in camera_paths
     assert './stereo-dataset/right/' in camera_paths
     yield_cal_mock.assert_called_once()
-    yield_metadata_mock.assert_called_once_with(z, './stereo-dataset/', parent)
-    assert b'metadata-chunk' in chunks
+    # The parent exports no media of its own, but includeMedia still reaches it so its
+    # shared attachment is emitted by the one owner of that decision.
+    parent_call = next(
+        call for call in yield_single_mock.call_args_list if call.args[1] == './stereo-dataset/'
+    )
+    assert parent_call.args[4] is True
 
 
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
 @patch('dive_server.crud_dataset.Item')
-def test_yield_metadata_file_uses_original_name(item_cls):
+def test_yield_metadata_file_uses_original_name(item_cls, get_clone_root):
     z = MagicMock()
 
     def add_file_side_effect(_maker, path):
@@ -202,22 +294,109 @@ def add_file_side_effect(_maker, path):
             constants.MetadataFileOriginalNameMarker: 'flight_log.csv',
         },
     }
-    item_cls.return_value.findOne.return_value = {'_id': 'md-item-id', 'name': 'renamed.csv'}
+    get_clone_root.return_value = folder
+    item_cls.return_value.load.return_value = {
+        '_id': 'md-item-id',
+        'folderId': 'parent-id',
+        'name': 'renamed.csv',
+    }
     item_cls.return_value.fileList.return_value = [('renamed.csv', MagicMock())]
 
-    chunks = list(crud_dataset._yield_metadata_file(z, './stereo-dataset/', folder))
+    chunks = list(
+        crud_dataset._yield_metadata_file(z, './stereo-dataset/', folder, {'login': 'tester'})
+    )
 
     z.addFile.assert_called_once()
-    assert str(z.addFile.call_args.args[1]) == 'stereo-dataset/flight_log.csv'
+    assert str(z.addFile.call_args.args[1]) == 'stereo-dataset/metadata/flight_log.csv'
     assert any(b'flight_log.csv' in chunk for chunk in chunks)
 
 
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+@patch('dive_server.crud_dataset.Folder')
 @patch('dive_server.crud_dataset.Item')
-def test_yield_metadata_file_skips_when_unset(item_cls):
+def test_yield_metadata_file_exports_reserved_name_attachment(
+    item_cls,
+    folder_cls,
+    get_clone_root,
+):
+    """An attachment discovered by reserved name survives an export/re-import round trip."""
+    z = MagicMock()
+
+    def add_file_side_effect(_maker, path):
+        yield str(path).encode('utf-8')
+
+    z.addFile.side_effect = add_file_side_effect
+    folder = {'_id': 'ds-id', 'meta': {}}
+    get_clone_root.return_value = folder
+    reserved_item = {
+        '_id': 'reserved-id',
+        'folderId': 'ds-id',
+        'name': 'frame_metadata.csv',
+    }
+    folder_cls.return_value.childItems.return_value = [reserved_item]
+    item_cls.return_value.load.return_value = reserved_item
+    item_cls.return_value.fileList.return_value = [('frame_metadata.csv', MagicMock())]
+
+    list(crud_dataset._yield_metadata_file(z, './ds/', folder, {'login': 'tester'}))
+
+    assert str(z.addFile.call_args.args[1]) == 'ds/metadata/frame_metadata.csv'
+
+
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+@patch('dive_server.crud_dataset.Item')
+def test_yield_metadata_file_exports_attachment_on_an_unreadable_clone_root(
+    item_cls,
+    get_clone_root,
+):
+    """A clone root the exporter cannot read still contributes its attachment.
+
+    getCloneRoot force-loads the source, so an access-checked item load there raises
+    AccessException -- which is not a RestException, so it would escape the guard in
+    export_datasets_zipstream and abort the whole stream instead of listing the dataset in
+    failed_datasets.txt. The export already streams that root's media unchecked.
+    """
+    z = MagicMock()
+
+    def add_file_side_effect(_maker, path):
+        yield str(path).encode('utf-8')
+
+    z.addFile.side_effect = add_file_side_effect
+    folder = {'_id': 'clone-id', 'meta': {}, constants.ForeignMediaIdMarker: 'source-id'}
+    source_root = {
+        '_id': 'source-id',
+        'meta': {
+            constants.MetadataFileItemIdMarker: 'md-item-id',
+            constants.MetadataFileOriginalNameMarker: 'flight_log.csv',
+        },
+    }
+    get_clone_root.return_value = source_root
+
+    def load_item(item_id, level=None, user=None, force=False):
+        if not force:
+            raise AccessException('Read access denied for folder source-id.')
+        return {'_id': 'md-item-id', 'folderId': 'source-id', 'name': 'renamed.csv'}
+
+    item_cls.return_value.load.side_effect = load_item
+    item_cls.return_value.fileList.return_value = [('renamed.csv', MagicMock())]
+
+    list(crud_dataset._yield_metadata_file(z, './ds/', folder, {'login': 'tester'}))
+
+    assert str(z.addFile.call_args.args[1]) == 'ds/metadata/flight_log.csv'
+
+
+@patch('dive_server.crud_dataset.crud.getCloneRoot')
+@patch('dive_server.crud_dataset.Folder')
+@patch('dive_server.crud_dataset.Item')
+def test_yield_metadata_file_skips_when_unset(item_cls, folder_cls, get_clone_root):
     z = MagicMock()
-    chunks = list(crud_dataset._yield_metadata_file(z, './ds/', {'_id': 'id', 'meta': {}}))
+    folder = {'_id': 'id', 'meta': {}}
+    get_clone_root.return_value = folder
+    folder_cls.return_value.childItems.return_value = []
+
+    chunks = list(crud_dataset._yield_metadata_file(z, './ds/', folder, {'login': 'tester'}))
+
     assert chunks == []
-    item_cls.return_value.findOne.assert_not_called()
+    item_cls.return_value.load.assert_not_called()
     z.addFile.assert_not_called()
 
 
@@ -243,6 +422,8 @@ def test_export_multicam_integration_zip_paths(
 ):
     """Build a minimal zip and assert multicam layout from export helpers."""
     parent = _multi_parent_folder()
+    parent['meta'][constants.MetadataFileItemIdMarker] = 'metadata-id'
+    parent['meta'][constants.MetadataFileOriginalNameMarker] = 'flight_log.csv'
     left = _child_folder('left-id', 'left')
     right = _child_folder('right-id', 'right')
     user = {'login': 'tester'}
@@ -265,7 +446,12 @@ def footer(self):
     zip_gen_cls.return_value = z
 
     get_dataset_mock.return_value = MagicMock(
-        dict=lambda exclude_none=True: {'id': 'parent-id', 'type': constants.MultiType}
+        dict=lambda exclude_none=True: {
+            'id': 'parent-id',
+            'type': constants.MultiType,
+            constants.MetadataFileItemIdMarker: 'metadata-id',
+            constants.MetadataFileOriginalNameMarker: 'flight_log.csv',
+        }
     )
     get_media_mock.return_value = MagicMock(
         dict=lambda exclude_none=True: {'imageData': [], 'video': None}
@@ -275,12 +461,24 @@ def footer(self):
     get_clone_root_mock.side_effect = lambda _user, folder: folder
     valid_images_mock.return_value = [{'_id': 'img1', 'name': 'left.png'}]
     item_cls.return_value.fileList.return_value = [('left.png', MagicMock())]
+    item_cls.return_value.load.return_value = {
+        '_id': 'metadata-id',
+        'folderId': 'parent-id',
+        'name': 'renamed.csv',
+    }
 
     def load_folder(folder_id, level=None, user=None):
         return {'left-id': left, 'right-id': right}.get(folder_id)
 
     folder_cls.return_value.load.side_effect = load_folder
-    folder_cls.return_value.childItems.return_value = [{'name': 'left.png'}]
+
+    def child_items(folder, filters=None, **kwargs):
+        # The reserved-name query is an $in over basenames; the media walk is a $regex.
+        if '$in' in (filters or {}).get('lowerName', {}):
+            return []
+        return [{'_id': 'img-item', 'name': 'left.png'}]
+
+    folder_cls.return_value.childItems.side_effect = child_items
 
     with patch('dive_server.crud_dataset.get_multi_cam_media') as get_mcm:
         get_mcm.return_value = MagicMock()
@@ -300,6 +498,13 @@ def load_folder(folder_id, level=None, user=None):
     assert 'stereo-dataset/right/meta.json' in zip_entries
     multi_cam = json.loads(zip_entries['stereo-dataset/multiCam.json'].decode())
     assert multi_cam['defaultDisplay'] == 'left'
+    parent_meta = json.loads(zip_entries['stereo-dataset/meta.json'].decode())
+    # The archive carries no attachment locator at all -- neither the server-local item id
+    # nor the name -- because it is discovered at metadata/<originalName>. Same key set the
+    # desktop exporter writes (withoutMetadataAttachment in multicamExport.ts).
+    assert constants.MetadataFileItemIdMarker not in parent_meta
+    assert constants.MetadataFileOriginalNameMarker not in parent_meta
+    assert 'stereo-dataset/metadata/flight_log.csv' in zip_entries
 
 
 @patch('dive_server.crud_dataset.Folder')
diff --git a/server/tests/test_multicam_zip_import.py b/server/tests/test_multicam_zip_import.py
index 06f7cc27e..d39744b83 100644
--- a/server/tests/test_multicam_zip_import.py
+++ b/server/tests/test_multicam_zip_import.py
@@ -16,7 +16,18 @@
 from dive_utils import constants
 
 
-def _write_image_sequence_export(target: Path, images: list[str], fps: float = 5.0):
+def _write_image_sequence_export(
+    target: Path,
+    images: list[str],
+    fps: float = 5.0,
+    metadata_name: str | None = None,
+    extra_meta: dict | None = None,
+):
+    """Write an exported image-sequence dataset directory.
+
+    The archive declares its attachment by directory alone, so meta.json carries no
+    locator: the attachment is whatever single file sits in ``metadata/``.
+    """
     target.mkdir(parents=True, exist_ok=True)
     (target / 'frame0.png').write_bytes(b'png')
     meta = {
@@ -24,14 +35,27 @@ def _write_image_sequence_export(target: Path, images: list[str], fps: float = 5
         'fps': fps,
         'version': 1,
         'imageData': [{'filename': name} for name in images],
+        **(extra_meta or {}),
     }
+    if metadata_name:
+        metadata_dir = target / 'metadata'
+        metadata_dir.mkdir()
+        (metadata_dir / metadata_name).write_text('filename,depth\nframe0.png,10\n')
     (target / 'meta.json').write_text(json.dumps(meta))
 
 
 def _write_multicam_export_tree(
-    root: Path, *, sub_type: str = 'stereo', with_calibration: bool = True
+    root: Path,
+    *,
+    sub_type: str = 'stereo',
+    with_calibration: bool = True,
+    with_metadata: bool = False,
 ):
-    _write_image_sequence_export(root / 'left', ['frame0.png'])
+    _write_image_sequence_export(
+        root / 'left',
+        ['frame0.png'],
+        metadata_name='left.csv' if with_metadata else None,
+    )
     _write_image_sequence_export(root / 'right', ['frame0.png'])
     multi_cam = {
         'defaultDisplay': 'left',
@@ -49,6 +73,10 @@ def _write_multicam_export_tree(
         'version': 1,
         'name': 'stereo-import',
     }
+    if with_metadata:
+        metadata_dir = root / 'metadata'
+        metadata_dir.mkdir()
+        (metadata_dir / 'shared.csv').write_text('filename,depth\nframe0.png,20\n')
     (root / 'meta.json').write_text(json.dumps(parent_meta))
     if with_calibration and sub_type == 'stereo':
         (root / 'calibration.npz').write_bytes(b'npz')
@@ -136,3 +164,194 @@ def test_upload_exported_zipped_dataset_redirects_when_multicam_json_present(
     utils.upload_exported_zipped_dataset(mock_gc, mock_manager, 'parent-id', root, '')
 
     multicam_mock.assert_called_once_with(mock_gc, mock_manager, 'parent-id', root, '')
+
+
+def _list_items_by_name(folder_id, name=None):
+    """Resolve an uploaded item the way girder does, with an id derived from its folder."""
+    if name:
+        return [{'_id': f'{folder_id}-{name}', 'name': name}]
+    return []
+
+
+def test_import_exported_dataset_uploads_and_links_the_metadata_directory_attachment(
+    tmp_path,
+    mock_gc,
+    mock_manager,
+):
+    root = tmp_path / 'dataset'
+    _write_image_sequence_export(root, ['frame0.png'], metadata_name='nav.csv')
+    mock_gc.listItem.side_effect = _list_items_by_name
+
+    utils._import_exported_dataset_directory(mock_gc, mock_manager, 'dest', root)
+
+    uploaded = [call_args.args[0] for call_args in mock_gc.upload.call_args_list]
+    assert str(root / 'metadata' / 'nav.csv') in uploaded
+    assert str(root / 'metadata') not in uploaded
+    folder_meta = mock_gc.addMetadataToFolder.call_args.args[1]
+    assert folder_meta[constants.MetadataFileItemIdMarker] == 'dest-nav.csv'
+    assert folder_meta[constants.MetadataFileOriginalNameMarker] == 'nav.csv'
+
+
+def test_import_exported_dataset_ignores_a_legacy_item_id_in_meta_json(
+    tmp_path,
+    mock_gc,
+    mock_manager,
+):
+    """Archives from today's upstream carry a bare item id and no metadata/ directory."""
+    root = tmp_path / 'dataset'
+    _write_image_sequence_export(
+        root,
+        ['frame0.png'],
+        extra_meta={
+            constants.MetadataFileItemIdMarker: '65a140e8a4c218785d408b42',
+            constants.MetadataFileOriginalNameMarker: 'nav.csv',
+        },
+    )
+    (root / 'nav.csv').write_text('filename,depth\nframe0.png,10\n')
+    mock_gc.listItem.side_effect = _list_items_by_name
+
+    utils._import_exported_dataset_directory(mock_gc, mock_manager, 'dest', root)
+
+    uploaded = [call_args.args[0] for call_args in mock_gc.upload.call_args_list]
+    assert str(root / 'nav.csv') in uploaded
+    folder_meta = mock_gc.addMetadataToFolder.call_args.args[1]
+    assert constants.MetadataFileItemIdMarker not in folder_meta
+    assert constants.MetadataFileOriginalNameMarker not in folder_meta
+
+
+def test_import_exported_dataset_finds_a_nested_metadata_directory_attachment(
+    tmp_path,
+    mock_gc,
+    mock_manager,
+):
+    """Discovery walks metadata/ recursively, matching desktop's archiveMetadataAttachment."""
+    root = tmp_path / 'dataset'
+    _write_image_sequence_export(root, ['frame0.png'])
+    nested = root / 'metadata' / 'sub'
+    nested.mkdir(parents=True)
+    (nested / 'nav.csv').write_text('filename,depth\nframe0.png,10\n')
+    mock_gc.listItem.side_effect = _list_items_by_name
+
+    utils._import_exported_dataset_directory(mock_gc, mock_manager, 'dest', root)
+
+    uploaded = [call_args.args[0] for call_args in mock_gc.upload.call_args_list]
+    assert str(nested / 'nav.csv') in uploaded
+    folder_meta = mock_gc.addMetadataToFolder.call_args.args[1]
+    assert folder_meta[constants.MetadataFileItemIdMarker] == 'dest-nav.csv'
+    assert folder_meta[constants.MetadataFileOriginalNameMarker] == 'nav.csv'
+
+
+@pytest.mark.parametrize('second_attachment', ['extra.csv', 'sub/extra.csv'])
+def test_import_exported_dataset_rejects_more_than_one_metadata_file(
+    tmp_path,
+    mock_gc,
+    mock_manager,
+    second_attachment,
+):
+    """Ambiguity counts across the whole metadata/ tree, flat or nested, as desktop does."""
+    root = tmp_path / 'dataset'
+    _write_image_sequence_export(root, ['frame0.png'], metadata_name='nav.csv')
+    extra = root / 'metadata' / second_attachment
+    extra.parent.mkdir(parents=True, exist_ok=True)
+    extra.write_text('filename,depth\nframe0.png,30\n')
+
+    with pytest.raises(ValueError, match='More than one metadata file was found'):
+        utils._import_exported_dataset_directory(mock_gc, mock_manager, 'dest', root)
+
+    mock_gc.upload.assert_not_called()
+
+
+def test_import_exported_dataset_rejects_an_unreadable_metadata_extension(
+    tmp_path,
+    mock_gc,
+    mock_manager,
+):
+    root = tmp_path / 'dataset'
+    _write_image_sequence_export(root, ['frame0.png'], metadata_name='notes.md')
+
+    with pytest.raises(ValueError, match='must be a JSON, TXT, or CSV file'):
+        utils._import_exported_dataset_directory(mock_gc, mock_manager, 'dest', root)
+
+    mock_gc.upload.assert_not_called()
+
+
+def test_upload_exported_multicam_ignores_a_legacy_item_id_in_meta_json(
+    tmp_path,
+    mock_gc,
+    mock_manager,
+):
+    """A multicam zip from today's upstream declares a bare item id and writes the attachment
+    at the archive root instead of in metadata/.
+
+    The import must not fail on the legacy key, and the root-level file is dropped: the
+    multicam path only uploads the calibration file and the discovered metadata/ attachment
+    from the parent directory. Pinned so the loss is a known cost of discovery-by-directory
+    rather than an accident.
+    """
+    root = tmp_path / 'multicam-dataset'
+    _write_multicam_export_tree(root, sub_type='multicam', with_calibration=False)
+    parent_meta = json.loads((root / 'meta.json').read_text())
+    parent_meta[constants.MetadataFileItemIdMarker] = '65a140e8a4c218785d408b42'
+    (root / 'meta.json').write_text(json.dumps(parent_meta))
+    (root / 'shared.csv').write_text('filename,depth\nframe0.png,20\n')
+
+    utils.upload_exported_multicam_zipped_dataset(mock_gc, mock_manager, 'parent-id', root, '')
+
+    (_, _), kwargs = mock_gc.sendRestRequest.call_args
+    assert 'metadataFileId' not in kwargs['json']
+    uploaded = [call_args.args[0] for call_args in mock_gc.upload.call_args_list]
+    assert str(root / 'shared.csv') not in uploaded
+
+
+def test_upload_exported_multicam_rejects_multiple_attachments_before_mutation(
+    tmp_path,
+    mock_gc,
+    mock_manager,
+):
+    root = tmp_path / 'multicam-dataset'
+    _write_multicam_export_tree(
+        root,
+        sub_type='multicam',
+        with_calibration=False,
+        with_metadata=True,
+    )
+    (root / 'metadata' / 'extra.csv').write_text('filename,depth\nframe0.png,30\n')
+
+    with pytest.raises(ValueError, match='More than one metadata file was found'):
+        utils.upload_exported_multicam_zipped_dataset(mock_gc, mock_manager, 'parent-id', root, '')
+
+    mock_gc.createFolder.assert_not_called()
+    mock_gc.upload.assert_not_called()
+
+
+def test_upload_exported_multicam_restores_shared_and_camera_metadata(
+    tmp_path,
+    mock_gc,
+    mock_manager,
+):
+    root = tmp_path / 'multicam-dataset'
+    _write_multicam_export_tree(
+        root,
+        sub_type='multicam',
+        with_calibration=False,
+        with_metadata=True,
+    )
+    mock_gc.listItem.side_effect = _list_items_by_name
+
+    utils.upload_exported_multicam_zipped_dataset(mock_gc, mock_manager, 'parent-id', root, '')
+
+    (_, _), kwargs = mock_gc.sendRestRequest.call_args
+    assert kwargs['json']['metadataFileId'] == 'parent-id-shared.csv'
+    left_meta = next(
+        call_args.args[1]
+        for call_args in mock_gc.addMetadataToFolder.call_args_list
+        if call_args.args[0] == 'left-id'
+    )
+    assert left_meta[constants.MetadataFileItemIdMarker] == 'left-id-left.csv'
+    assert left_meta[constants.MetadataFileOriginalNameMarker] == 'left.csv'
+    right_meta = next(
+        call_args.args[1]
+        for call_args in mock_gc.addMetadataToFolder.call_args_list
+        if call_args.args[0] == 'right-id'
+    )
+    assert constants.MetadataFileItemIdMarker not in right_meta
diff --git a/server/tests/test_pipeline_discovery.py b/server/tests/test_pipeline_discovery.py
index 09c33f761..15df3661a 100644
--- a/server/tests/test_pipeline_discovery.py
+++ b/server/tests/test_pipeline_discovery.py
@@ -94,3 +94,31 @@ def test_extract_pipe_metadata_requires_calibration(tmp_path: Path):
     assert metadata['description'] == 'stereo measurement'
     assert metadata['inputType'] == 'TRACK'
     assert metadata['outputType'] == 'TRACK'
+
+
+def test_extract_pipe_metadata_parses_metadata_file_key(tmp_path: Path):
+    pipe = tmp_path / 'detector_stabilize.pipe'
+    pipe.write_text(
+        '\n'.join(
+            [
+                '# Description: stabilized detector',
+                '# Metadata File: stabilizer:flight_log',
+                '# Input: TRACK',
+            ]
+        )
+    )
+
+    metadata = extract_pipe_metadata(pipe)
+
+    # The opt-in header binds the dataset's selected metadata attachment to this KWIVER key.
+    assert metadata['metadataFileKey'] == 'stabilizer:flight_log'
+    assert metadata['description'] == 'stabilized detector'
+    assert metadata['inputType'] == 'TRACK'
+
+
+def test_extract_pipe_metadata_absent_metadata_file_key(tmp_path: Path):
+    pipe = tmp_path / 'detector_plain.pipe'
+    pipe.write_text('# Description: plain detector\n# Input: TRACK\n')
+
+    # A pipe that does not opt in leaves the key unset, so no file is injected.
+    assert 'metadataFileKey' not in extract_pipe_metadata(pipe)
diff --git a/server/tests/test_pipeline_metadata_scope.py b/server/tests/test_pipeline_metadata_scope.py
new file mode 100644
index 000000000..16ec0a798
--- /dev/null
+++ b/server/tests/test_pipeline_metadata_scope.py
@@ -0,0 +1,184 @@
+from unittest.mock import patch
+
+import pytest
+
+from dive_server.crud_rpc import run_pipeline
+from dive_utils import constants
+
+USER = {'_id': 'user-id', 'login': 'someone'}
+DETECTOR_PIPELINE = {
+    'name': 'stabilizer',
+    'type': 'detector',
+    'pipe': 'detector_stabilizer.pipe',
+    'folderId': None,
+    'metadata': {'metadataFileKey': 'stabilizer:flight_log'},
+}
+MULTICAM_PIPELINE = {
+    'name': 'stereo stabilizer',
+    'type': '2-cam',
+    'pipe': 'detector_stereo.pipe',
+    'folderId': None,
+    'metadata': {'metadataFileKey': 'stabilizer:flight_log'},
+}
+
+
+def _image_sequence_folder(folder_id='ds'):
+    return {
+        '_id': folder_id,
+        'name': folder_id,
+        'meta': {'type': constants.ImageSequenceType, 'fps': 5},
+    }
+
+
+def _multicam_folder(camera_folder_ids):
+    return {
+        '_id': 'parent',
+        'name': 'parent',
+        'meta': {
+            'type': constants.MultiType,
+            'fps': 5,
+            constants.MultiCamMarker: {
+                'defaultDisplay': 'left',
+                'cameras': {
+                    name: {'folderId': folder_id, 'type': constants.ImageSequenceType}
+                    for name, folder_id in camera_folder_ids.items()
+                },
+            },
+        },
+    }
+
+
+@pytest.fixture
+def pipeline_run_env():
+    """Patch everything run_pipeline touches except the metadata attachment resolution."""
+    with (
+        patch('dive_server.crud_rpc.verify_pipe'),
+        patch('dive_server.crud_rpc.crud.getCloneRoot'),
+        patch('dive_server.crud_rpc.crud.get_multicam_parent_folder') as multicam_parent,
+        patch('dive_server.crud_rpc.crud.get_multicam_camera_name') as camera_name,
+        patch('dive_server.crud_rpc.crud_dataset.resolve_stereo_calibration_item_id') as cal_id,
+        patch('dive_server.crud_rpc.crud_dataset.pipeline_requires_calibration') as needs_cal,
+        patch('dive_server.crud_rpc.crud_dataset.resolve_metadata_attachment_item_id') as resolve,
+        patch('dive_server.crud_rpc.Folder') as folder_cls,
+        patch('dive_server.crud_rpc.Job') as job_cls,
+        patch('dive_server.crud_rpc.Token'),
+        patch('dive_server.crud_rpc.Notification'),
+        patch('dive_server.crud_rpc.tasks') as tasks_module,
+        patch('dive_server.crud_rpc._persist_async_job_metadata') as persist_job,
+    ):
+        multicam_parent.return_value = None
+        camera_name.return_value = None
+        cal_id.return_value = None
+        needs_cal.return_value = False
+        job_cls.return_value.findOne.return_value = None  # no outstanding job
+        persist_job.return_value = {'_id': 'job-id'}
+        yield {
+            'resolve': resolve,
+            'multicam_parent': multicam_parent,
+            'camera_name': camera_name,
+            'folder_cls': folder_cls,
+            'job_cls': job_cls,
+            'tasks': tasks_module,
+        }
+
+
+def _job_params(env):
+    return env['tasks'].run_pipeline.apply_async.call_args.kwargs['kwargs']['params']
+
+
+def test_single_dataset_run_binds_its_own_attachment(pipeline_run_env):
+    folder = _image_sequence_folder()
+    pipeline_run_env['resolve'].return_value = 'nav-item'
+
+    run_pipeline(USER, folder, DETECTOR_PIPELINE)
+
+    params = _job_params(pipeline_run_env)
+    assert params['metadata_file_key'] == 'stabilizer:flight_log'
+    assert params['metadata_file_item_id'] == 'nav-item'
+    pipeline_run_env['resolve'].assert_called_once_with(folder, USER)
+
+
+def test_camera_run_falls_back_to_the_shared_parent_attachment(pipeline_run_env):
+    # A single-camera run on a camera folder must still see the attachment the parent owns:
+    # the panel shows it for that camera, so the pipeline gets the same file.
+    camera = _image_sequence_folder('left')
+    parent = _multicam_folder({'left': 'left', 'right': 'right'})
+    pipeline_run_env['multicam_parent'].return_value = parent
+    pipeline_run_env['camera_name'].return_value = 'left'
+    pipeline_run_env['resolve'].side_effect = lambda scope, user: (
+        'shared-item' if scope is parent else None
+    )
+
+    run_pipeline(USER, camera, DETECTOR_PIPELINE)
+
+    assert _job_params(pipeline_run_env)['metadata_file_item_id'] == 'shared-item'
+    # Camera-local first, shared parent second.
+    assert [call.args[0] for call in pipeline_run_env['resolve'].call_args_list] == [
+        camera,
+        parent,
+    ]
+
+
+def test_camera_run_prefers_its_own_camera_attachment(pipeline_run_env):
+    camera = _image_sequence_folder('left')
+    parent = _multicam_folder({'left': 'left', 'right': 'right'})
+    pipeline_run_env['multicam_parent'].return_value = parent
+    pipeline_run_env['camera_name'].return_value = 'left'
+    pipeline_run_env['resolve'].side_effect = lambda scope, user: (
+        'camera-item' if scope is camera else 'shared-item'
+    )
+
+    run_pipeline(USER, camera, DETECTOR_PIPELINE)
+
+    assert _job_params(pipeline_run_env)['metadata_file_item_id'] == 'camera-item'
+
+
+def test_multicam_run_falls_back_to_the_default_display_camera_attachment(pipeline_run_env):
+    # A stereo/multicam run reads the shared attachment first, but a dataset whose only
+    # attachment sits on the default display camera must not run without it.
+    parent = _multicam_folder({'left': 'left-id', 'right': 'right-id'})
+    camera_folders = {
+        'left-id': _image_sequence_folder('left-id'),
+        'right-id': _image_sequence_folder('right-id'),
+    }
+    pipeline_run_env['folder_cls'].return_value.load.side_effect = (
+        lambda folder_id, level=None, user=None: camera_folders[folder_id]
+    )
+    pipeline_run_env['resolve'].side_effect = lambda scope, user: (
+        'camera-item' if scope is camera_folders['left-id'] else None
+    )
+
+    run_pipeline(USER, parent, MULTICAM_PIPELINE)
+
+    assert _job_params(pipeline_run_env)['metadata_file_item_id'] == 'camera-item'
+    assert [call.args[0] for call in pipeline_run_env['resolve'].call_args_list] == [
+        parent,
+        camera_folders['left-id'],
+    ]
+
+
+def test_declared_key_without_an_attachment_is_reported_in_the_job_log(pipeline_run_env):
+    # The setting is dropped, so say so in the job log the way the missing-calibration
+    # notice does, instead of running silently without it.
+    folder = _image_sequence_folder()
+    pipeline_run_env['resolve'].return_value = None
+
+    run_pipeline(USER, folder, DETECTOR_PIPELINE)
+
+    params = _job_params(pipeline_run_env)
+    assert 'metadata_file_item_id' not in params
+    assert 'metadata_file_key' not in params
+    log = pipeline_run_env['job_cls'].return_value.updateJob.call_args.kwargs['log']
+    assert 'stabilizer:flight_log' in log
+    assert 'no metadata attachment' in log
+
+
+def test_pipeline_without_a_metadata_key_resolves_nothing(pipeline_run_env):
+    folder = _image_sequence_folder()
+    pipeline = {**DETECTOR_PIPELINE, 'metadata': {}}
+
+    run_pipeline(USER, folder, pipeline)
+
+    assert 'metadata_file_key' not in _job_params(pipeline_run_env)
+    pipeline_run_env['resolve'].assert_not_called()
+    pipeline_run_env['job_cls'].return_value.updateJob.assert_not_called()
diff --git a/server/tests/test_process_items.py b/server/tests/test_process_items.py
new file mode 100644
index 000000000..dc49d5de6
--- /dev/null
+++ b/server/tests/test_process_items.py
@@ -0,0 +1,453 @@
+from unittest.mock import patch
+
+from girder.exceptions import RestException
+import pytest
+
+from dive_server.crud_rpc import process_items
+from dive_utils import constants, frame_metadata
+
+VIAME_HEADER = (
+    '# 1: Detection or Track-id, 2: Video or Image Identifier, 3: Unique Frame Identifier, '
+    '4-7: Img-bbox(TL_x,TL_y,BR_x,BR_y), 8: Detection or Length Confidence, '
+    '9: Fish Length, 10-11+: Repeated Species'
+)
+
+
+def _viame_csv(filename='image_0001.jpg'):
+    """A minimal, well-formed VIAME annotation CSV with the DIVE comment header."""
+    return f'{VIAME_HEADER}\n0,{filename},0,10,10,50,50,1.0,-1,fish,0.9\n'
+
+
+def _download_side_effect(bytes_by_file_id):
+    def download(file, headers=False):
+        return lambda: [bytes_by_file_id[file['_id']]]
+
+    return download
+
+
+def _childfiles_side_effect(file_by_item_id):
+    def child_files(item):
+        return iter([file_by_item_id[item['_id']]])
+
+    return child_files
+
+
+@pytest.mark.parametrize(
+    'dataset_type',
+    [constants.VideoType, constants.LargeImageType, constants.ImageSequenceType],
+)
+@patch('dive_server.crud_rpc.crud_dataset.resolve_metadata_attachment_item_id')
+@patch('dive_server.crud_rpc.crud.refresh_folder_document')
+@patch('dive_server.crud_rpc.crud_annotation.save_annotations')
+@patch('dive_server.crud_rpc.crud.get_or_create_auxiliary_folder')
+@patch('dive_server.crud_rpc.File')
+@patch('dive_server.crud_rpc.Item')
+@patch('dive_server.crud_rpc.Folder')
+def test_frame_metadata_csv_is_kept_in_place_for_every_media_type(
+    folder_cls,
+    item_cls,
+    file_cls,
+    get_auxiliary_folder,
+    save_annotations,
+    refresh_folder_document,
+    resolve_attachment_item_id,
+    dataset_type,
+):
+    folder = {'_id': 'ds', 'meta': {'type': dataset_type, 'fps': 5}}
+    item = {'_id': 'item-id', 'name': 'frame_metadata.csv', 'meta': {}}
+    file = {'_id': 'file-id', 'name': 'frame_metadata.csv', 'exts': ['csv']}
+
+    resolve_attachment_item_id.return_value = 'item-id'
+    folder_cls.return_value.childItems.return_value = [item]
+    item_cls.return_value.childFiles.side_effect = _childfiles_side_effect({'item-id': file})
+
+    warnings = process_items(folder, {'_id': 'user-id'})
+
+    # Declared by name: marked processed and left in the dataset folder, never imported as
+    # annotations, moved, or removed. The bytes are never even downloaded.
+    assert len(warnings) == 1
+    assert 'frame_metadata.csv' in warnings[0]
+    assert 'stays in the dataset folder' in warnings[0]
+    assert item['meta'][constants.ProcessedMarker] is True
+    item_cls.return_value.save.assert_called_once_with(item)
+    item_cls.return_value.move.assert_not_called()
+    item_cls.return_value.remove.assert_not_called()
+    save_annotations.assert_not_called()
+    file_cls.return_value.download.assert_not_called()
+    # The resolved attachment is recorded on the folder so later consumers need no rescan.
+    assert folder['meta'][constants.MetadataFileItemIdMarker] == 'item-id'
+    assert folder['meta'][constants.MetadataFileOriginalNameMarker] == 'frame_metadata.csv'
+
+
+@patch('dive_server.crud_rpc.crud_dataset.resolve_metadata_attachment_item_id')
+@patch('dive_server.crud_rpc.crud.refresh_folder_document')
+@patch('dive_server.crud_rpc.Item')
+@patch('dive_server.crud_rpc.Folder')
+def test_reserved_txt_sidecar_is_swept_like_the_other_reserved_names(
+    folder_cls, item_cls, refresh_folder_document, resolve_attachment_item_id
+):
+    folder = {'_id': 'ds', 'meta': {'type': constants.ImageSequenceType, 'fps': 5}}
+    item = {'_id': 'item-id', 'name': 'frame_metadata.txt', 'meta': {}}
+    file = {'_id': 'file-id', 'name': 'frame_metadata.txt', 'exts': ['txt']}
+
+    resolve_attachment_item_id.return_value = 'item-id'
+    folder_cls.return_value.childItems.return_value = [item]
+    item_cls.return_value.childFiles.side_effect = _childfiles_side_effect({'item-id': file})
+
+    warnings = process_items(folder, {'_id': 'user-id'})
+
+    # .txt matches none of the annotation extension regexes, so the reserved-name predicate
+    # has to be part of the sweep query or a reserved .txt attachment is never discovered
+    # (AUV flight logs are .txt).
+    filters = folder_cls.return_value.childItems.call_args.kwargs['filters']
+    assert frame_metadata.frame_metadata_source_name_query() in filters['$and'][0]['$or']
+    assert len(warnings) == 1
+    assert 'frame_metadata.txt' in warnings[0]
+    assert item['meta'][constants.ProcessedMarker] is True
+    assert folder['meta'][constants.MetadataFileItemIdMarker] == 'item-id'
+
+
+@patch('dive_server.crud_rpc.crud_dataset.resolve_metadata_attachment_item_id')
+@patch('dive_server.crud_rpc.crud.refresh_folder_document')
+@patch('dive_server.crud_rpc.Item')
+@patch('dive_server.crud_rpc.Folder')
+def test_swept_sidecar_write_keeps_concurrently_written_folder_keys(
+    folder_cls, item_cls, refresh_folder_document, resolve_attachment_item_id
+):
+    # An async convert_video job writes annotate / originalFps / ffprobe_info onto the folder
+    # while this sweep runs. Girder's save is a full-document replace, so the attachment write
+    # must refresh first or it replaces the folder with its pre-dispatch copy.
+    folder = {'_id': 'ds', 'meta': {'type': constants.VideoType, 'fps': 5}}
+    item = {'_id': 'item-id', 'name': 'frame_metadata.csv', 'meta': {}}
+    file = {'_id': 'file-id', 'name': 'frame_metadata.csv', 'exts': ['csv']}
+
+    def concurrent_job_write(target):
+        target['meta']['annotate'] = True
+        target['meta']['originalFps'] = 30
+
+    resolve_attachment_item_id.return_value = 'item-id'
+    refresh_folder_document.side_effect = concurrent_job_write
+    folder_cls.return_value.childItems.return_value = [item]
+    item_cls.return_value.childFiles.side_effect = _childfiles_side_effect({'item-id': file})
+
+    process_items(folder, {'_id': 'user-id'})
+
+    refresh_folder_document.assert_called_once_with(folder)
+    saved = folder_cls.return_value.save.call_args.args[0]
+    assert saved['meta']['annotate'] is True
+    assert saved['meta']['originalFps'] == 30
+    assert saved['meta'][constants.MetadataFileItemIdMarker] == 'item-id'
+
+
+@patch('dive_server.crud_rpc.crud_dataset.resolve_metadata_attachment_item_id')
+@patch('dive_server.crud_rpc.crud.refresh_folder_document')
+@patch('dive_server.crud_rpc.crud.get_or_create_auxiliary_folder')
+@patch('dive_server.crud_rpc.File')
+@patch('dive_server.crud_rpc.Item')
+@patch('dive_server.crud_rpc.Folder')
+def test_frame_metadata_csv_marked_processed_is_not_reswept(
+    folder_cls,
+    item_cls,
+    file_cls,
+    get_auxiliary_folder,
+    refresh_folder_document,
+    resolve_attachment_item_id,
+):
+    folder = {'_id': 'ds', 'meta': {'type': constants.ImageSequenceType, 'fps': 5}}
+    item = {'_id': 'item-id', 'name': 'frame_metadata.csv', 'meta': {}}
+    file = {'_id': 'file-id', 'name': 'frame_metadata.csv', 'exts': ['csv']}
+
+    # Emulate the ProcessedMarker "$ne: True" query filter: a marked sidecar is no longer
+    # listed, so a later process_items call never re-adjudicates it.
+    def child_items(_folder, filters=None, sort=None):
+        if item['meta'].get(constants.ProcessedMarker) is True:
+            return []
+        return [item]
+
+    resolve_attachment_item_id.return_value = 'item-id'
+    folder_cls.return_value.childItems.side_effect = child_items
+    item_cls.return_value.childFiles.side_effect = _childfiles_side_effect({'item-id': file})
+
+    warnings = process_items(folder, {'_id': 'user-id'})
+    assert len(warnings) == 1
+    assert item['meta'][constants.ProcessedMarker] is True
+    item_cls.return_value.save.assert_called_once_with(item)
+
+    # Second pass: the marked sidecar is excluded, so it is not re-saved or re-warned.
+    second_warnings = process_items(folder, {'_id': 'user-id'})
+    assert second_warnings == []
+    item_cls.return_value.save.assert_called_once()
+
+
+@patch('dive_server.crud_rpc.crud_dataset.resolve_metadata_attachment_item_id')
+@patch('dive_server.crud_rpc.crud_annotation.save_annotations')
+@patch('dive_server.crud_rpc.crud.valid_images')
+@patch('dive_server.crud_rpc.crud.get_or_create_auxiliary_folder')
+@patch('dive_server.crud_rpc.File')
+@patch('dive_server.crud_rpc.Item')
+@patch('dive_server.crud_rpc.Folder')
+def test_plain_annotation_csv_still_imports(
+    folder_cls,
+    item_cls,
+    file_cls,
+    get_auxiliary_folder,
+    valid_images,
+    save_annotations,
+    resolve_attachment_item_id,
+):
+    # The keep-in-place guard must not intercept an ordinary annotation CSV: it is still
+    # moved to the auxiliary folder and its tracks saved.
+    folder = {'_id': 'ds', 'meta': {'type': constants.ImageSequenceType, 'fps': 5}}
+    item = {'_id': 'item-id', 'name': 'annotations.csv', 'meta': {}}
+    file = {'_id': 'file-id', 'name': 'annotations.csv', 'exts': ['csv']}
+
+    resolve_attachment_item_id.return_value = None
+    folder_cls.return_value.childItems.return_value = [item]
+    item_cls.return_value.childFiles.side_effect = _childfiles_side_effect({'item-id': file})
+    file_cls.return_value.download.side_effect = _download_side_effect(
+        {'file-id': _viame_csv().encode()}
+    )
+    get_auxiliary_folder.return_value = {'_id': 'aux-id'}
+    valid_images.return_value = [{'name': 'image_0001.jpg'}, {'name': 'image_0002.jpg'}]
+
+    warnings = process_items(folder, {'_id': 'user-id'})
+
+    assert warnings == []
+    item_cls.return_value.move.assert_called_once_with(item, {'_id': 'aux-id'})
+    save_annotations.assert_called_once()
+    # An imported annotation is not tagged as a kept-in-place sidecar.
+    item_cls.return_value.save.assert_not_called()
+
+
+@patch('dive_server.crud_rpc.crud_dataset.resolve_metadata_attachment_item_id')
+@patch('dive_server.crud_rpc.crud_annotation.save_annotations')
+@patch('dive_server.crud_rpc.crud.valid_images')
+@patch('dive_server.crud_rpc.crud.get_or_create_auxiliary_folder')
+@patch('dive_server.crud_rpc.File')
+@patch('dive_server.crud_rpc.Item')
+@patch('dive_server.crud_rpc.Folder')
+def test_two_plain_csvs_import_the_oldest_and_warn_about_the_rest(
+    folder_cls,
+    item_cls,
+    file_cls,
+    get_auxiliary_folder,
+    valid_images,
+    save_annotations,
+    resolve_attachment_item_id,
+):
+    # This sweep is the convergence point for headless writers (assetstore/S3), where nobody
+    # picked these files: two annotation CSVs must not fail the folder. The oldest imports and
+    # the rest are named in a warning, left untouched for a later sweep.
+    folder = {'_id': 'ds', 'meta': {'type': constants.ImageSequenceType, 'fps': 5}}
+    oldest = {'_id': 'a', 'name': 'detections.csv', 'meta': {}}
+    newer = {'_id': 'b', 'name': 'tracks.csv', 'meta': {}}
+    file_a = {'_id': 'fa', 'name': 'detections.csv', 'exts': ['csv']}
+    file_b = {'_id': 'fb', 'name': 'tracks.csv', 'exts': ['csv']}
+
+    resolve_attachment_item_id.return_value = None
+    folder_cls.return_value.childItems.return_value = [oldest, newer]
+    item_cls.return_value.childFiles.side_effect = _childfiles_side_effect(
+        {'a': file_a, 'b': file_b}
+    )
+    file_cls.return_value.download.side_effect = _download_side_effect(
+        {'fa': _viame_csv('image_0001.jpg').encode(), 'fb': _viame_csv('image_0002.jpg').encode()}
+    )
+    get_auxiliary_folder.return_value = {'_id': 'aux-id'}
+    valid_images.return_value = [{'name': 'image_0001.jpg'}, {'name': 'image_0002.jpg'}]
+
+    warnings = process_items(folder, {'_id': 'user-id'})
+
+    assert len(warnings) == 1
+    assert 'detections.csv' in warnings[0]
+    assert 'tracks.csv' in warnings[0]
+    save_annotations.assert_called_once()
+    item_cls.return_value.move.assert_called_once_with(oldest, {'_id': 'aux-id'})
+    item_cls.return_value.remove.assert_not_called()
+    # The skipped CSV is untouched: unmarked, unmoved, and still available to import.
+    assert newer['meta'] == {}
+
+
+@patch('dive_server.crud_rpc.crud_dataset.resolve_metadata_attachment_item_id')
+@patch('dive_server.crud_rpc.crud_annotation.save_annotations')
+@patch('dive_server.crud_rpc.Item')
+@patch('dive_server.crud_rpc.Folder')
+def test_more_than_one_reserved_metadata_item_warns_and_attaches_none(
+    folder_cls,
+    item_cls,
+    save_annotations,
+    resolve_attachment_item_id,
+):
+    folder = {'_id': 'ds', 'meta': {'type': constants.ImageSequenceType, 'fps': 5}}
+    items = [
+        {'_id': 'a', 'name': 'frame_metadata.csv', 'meta': {}},
+        {'_id': 'b', 'name': 'frame-metadata.json', 'meta': {}},
+    ]
+    files = {
+        'a': {'_id': 'f-a', 'name': 'frame_metadata.csv', 'exts': ['csv']},
+        'b': {'_id': 'f-b', 'name': 'frame-metadata.json', 'exts': ['json']},
+    }
+    resolve_attachment_item_id.return_value = None
+    folder_cls.return_value.childItems.return_value = items
+    item_cls.return_value.childFiles.side_effect = _childfiles_side_effect(files)
+
+    warnings = process_items(folder, {'_id': 'user-id'})
+
+    # The assetstore/S3 sweep has no file picker and nothing to correct pre-upload, so
+    # ambiguity degrades to a warning: raising here would strip the folder's retry marker
+    # and skip the fps finalize. Both files stay put, so deleting one and re-importing lets
+    # the reserved-name fallback resolve the survivor.
+    ambiguity = next(w for w in warnings if 'More than one metadata file' in w)
+    assert 'frame_metadata.csv' in ambiguity
+    assert 'frame-metadata.json' in ambiguity
+    assert 'None was attached' in ambiguity
+    assert constants.MetadataFileItemIdMarker not in folder['meta']
+    # Neither is imported as annotations, moved, or removed.
+    save_annotations.assert_not_called()
+    item_cls.return_value.move.assert_not_called()
+    item_cls.return_value.remove.assert_not_called()
+    folder_cls.return_value.save.assert_not_called()
+    assert all(item['meta'][constants.ProcessedMarker] is True for item in items)
+
+
+@patch('dive_server.crud_rpc.crud_dataset.resolve_metadata_attachment_item_id')
+@patch('dive_server.crud_rpc.crud.refresh_folder_document')
+@patch('dive_server.crud_rpc.crud_annotation.save_annotations')
+@patch('dive_server.crud_rpc.crud.get_or_create_auxiliary_folder')
+@patch('dive_server.crud_rpc.File')
+@patch('dive_server.crud_rpc.Item')
+@patch('dive_server.crud_rpc.Folder')
+def test_attached_item_short_circuits_sweep(
+    folder_cls,
+    item_cls,
+    file_cls,
+    get_auxiliary_folder,
+    save_annotations,
+    refresh_folder_document,
+    resolve_attachment_item_id,
+):
+    folder = {
+        '_id': 'ds',
+        'meta': {
+            'type': constants.ImageSequenceType,
+            'fps': 5,
+            constants.MetadataFileItemIdMarker: 'item-id',
+        },
+    }
+    item = {
+        '_id': 'item-id',
+        'name': 'nav_2024.csv',
+        'meta': {},
+    }
+    file = {'_id': 'file-id', 'name': 'nav_2024.csv', 'exts': ['csv']}
+
+    resolve_attachment_item_id.return_value = 'item-id'
+    folder_cls.return_value.childItems.return_value = [item]
+    item_cls.return_value.childFiles.side_effect = _childfiles_side_effect({'item-id': file})
+
+    warnings = process_items(folder, {'_id': 'user-id'})
+
+    assert len(warnings) == 1
+    assert 'stays in the dataset folder' in warnings[0]
+    assert item['meta'][constants.ProcessedMarker] is True
+    item_cls.return_value.save.assert_called_once_with(item)
+    item_cls.return_value.move.assert_not_called()
+    item_cls.return_value.remove.assert_not_called()
+    file_cls.return_value.download.assert_not_called()
+    save_annotations.assert_not_called()
+    # The attachment is already recorded, so the sweep writes nothing to the folder.
+    refresh_folder_document.assert_not_called()
+    folder_cls.return_value.save.assert_not_called()
+
+
+@patch('dive_server.crud_rpc.crud_dataset.resolve_metadata_attachment_item_id')
+@patch('dive_server.crud_rpc.crud_annotation.save_annotations')
+@patch('dive_server.crud_rpc.crud.valid_images')
+@patch('dive_server.crud_rpc.crud.get_or_create_auxiliary_folder')
+@patch('dive_server.crud_rpc.File')
+@patch('dive_server.crud_rpc.Item')
+@patch('dive_server.crud_rpc.Folder')
+def test_attached_csv_does_not_trip_two_csv_guard(
+    folder_cls,
+    item_cls,
+    file_cls,
+    get_auxiliary_folder,
+    valid_images,
+    save_annotations,
+    resolve_attachment_item_id,
+):
+    # An attached CSV alongside one plain annotation CSV is not "two
+    # annotation CSVs": the annotation imports and the sidecar stays put.
+    folder = {
+        '_id': 'ds',
+        'meta': {
+            'type': constants.ImageSequenceType,
+            'fps': 5,
+            constants.MetadataFileItemIdMarker: 'nav',
+        },
+    }
+    marked = {
+        '_id': 'nav',
+        'name': 'nav_2024.csv',
+        'meta': {},
+    }
+    plain = {'_id': 'ann', 'name': 'annotations.csv', 'meta': {}}
+    file_marked = {'_id': 'f-nav', 'name': 'nav_2024.csv', 'exts': ['csv']}
+    file_plain = {'_id': 'f-ann', 'name': 'annotations.csv', 'exts': ['csv']}
+
+    resolve_attachment_item_id.return_value = 'nav'
+    folder_cls.return_value.childItems.return_value = [marked, plain]
+    item_cls.return_value.childFiles.side_effect = _childfiles_side_effect(
+        {'nav': file_marked, 'ann': file_plain}
+    )
+    file_cls.return_value.download.side_effect = _download_side_effect(
+        {'f-ann': _viame_csv().encode()}
+    )
+    get_auxiliary_folder.return_value = {'_id': 'aux-id'}
+    valid_images.return_value = [{'name': 'image_0001.jpg'}]
+
+    warnings = process_items(folder, {'_id': 'user-id'})
+
+    assert len(warnings) == 1
+    assert 'nav_2024.csv' in warnings[0]
+    item_cls.return_value.move.assert_called_once_with(plain, {'_id': 'aux-id'})
+    save_annotations.assert_called_once()
+    assert marked['meta'][constants.ProcessedMarker] is True
+
+
+@patch('dive_server.crud_rpc.crud_dataset.resolve_metadata_attachment_item_id')
+@patch('dive_server.crud_rpc.crud_annotation.save_annotations')
+@patch('dive_server.crud_rpc.crud.valid_images')
+@patch('dive_server.crud_rpc.crud.get_or_create_auxiliary_folder')
+@patch('dive_server.crud_rpc.File')
+@patch('dive_server.crud_rpc.Item')
+@patch('dive_server.crud_rpc.Folder')
+def test_undecodable_plain_csv_fails_loudly_with_rename_hint(
+    folder_cls,
+    item_cls,
+    file_cls,
+    get_auxiliary_folder,
+    valid_images,
+    save_annotations,
+    resolve_attachment_item_id,
+):
+    # A plain .csv whose bytes are not valid UTF-8 fails the annotation decode; the loud
+    # failure carries the hint pointing frame metadata users at the upload page field and
+    # the reserved name.
+    folder = {'_id': 'ds', 'meta': {'type': constants.ImageSequenceType, 'fps': 5}}
+    item = {'_id': 'item-id', 'name': 'annotations.csv', 'meta': {}}
+    file = {'_id': 'file-id', 'name': 'annotations.csv', 'exts': ['csv']}
+    raw = 'filename,species\nimage_0001.jpg,poisson-\xe9p\xe9e\n'.encode('latin-1')
+
+    resolve_attachment_item_id.return_value = None
+    folder_cls.return_value.childItems.return_value = [item]
+    item_cls.return_value.childFiles.side_effect = _childfiles_side_effect({'item-id': file})
+    file_cls.return_value.download.side_effect = _download_side_effect({'file-id': raw})
+    valid_images.return_value = [{'name': 'image_0001.jpg'}, {'name': 'image_0002.jpg'}]
+
+    with pytest.raises(RestException, match='Failed to import annotations.csv') as excinfo:
+        process_items(folder, {'_id': 'user-id'})
+
+    assert 'Metadata File (Optional)' in str(excinfo.value)
+    assert 'frame-metadata.csv' in str(excinfo.value)
+    item_cls.return_value.remove.assert_called_once_with(item)
+    save_annotations.assert_not_called()
diff --git a/server/tests/test_update_metadata.py b/server/tests/test_update_metadata.py
index 29a7a8ea3..8c8e166f0 100644
--- a/server/tests/test_update_metadata.py
+++ b/server/tests/test_update_metadata.py
@@ -202,6 +202,7 @@ def test_resolve_imported_dataset_info_does_not_mutate_inputs():
         ),
     ],
 )
+@patch('dive_server.crud_rpc.crud_dataset.resolve_metadata_attachment_item_id')
 @patch('dive_server.crud_rpc.crud_dataset.update_metadata')
 @patch('dive_server.crud_rpc.crud.get_or_create_auxiliary_folder')
 @patch('dive_server.crud_rpc.File')
@@ -213,6 +214,7 @@ def test_process_items_resolves_dataset_info_from_dive_configuration_import(
     file_cls,
     get_auxiliary_folder,
     update_metadata,
+    resolve_attachment_item_id,
     additive,
     expected,
 ):
@@ -233,6 +235,9 @@ def test_process_items_resolves_dataset_info_from_dive_configuration_import(
         }
     }
 
+    # The attachment resolver reaches Mongo through crud_dataset for its reserved-name
+    # fallback, so it is stubbed here like every other process_items unit test.
+    resolve_attachment_item_id.return_value = None
     folder_cls.return_value.childItems.return_value = [item]
     item_cls.return_value.childFiles.return_value = iter([file])
     file_cls.return_value.download.return_value = lambda: [json.dumps(payload).encode()]
@@ -250,6 +255,7 @@ def test_process_items_resolves_dataset_info_from_dive_configuration_import(
     assert verify is False
 
 
+@patch('dive_server.crud_rpc.crud_dataset.resolve_metadata_attachment_item_id')
 @patch('dive_server.crud_rpc.crud_dataset.update_metadata')
 @patch('dive_server.crud_rpc.crud.saveImportAttributes')
 @patch('dive_server.crud_rpc.crud.get_multicam_parent_folder')
@@ -265,6 +271,7 @@ def test_process_items_syncs_mutable_config_to_multicam_parent(
     get_multicam_parent,
     save_import_attributes,
     update_metadata,
+    resolve_attachment_item_id,
 ):
     """Camera-targeted DIVE config also updates the multicam parent the viewer reads."""
     # Use video so process_items skips valid_images (needs Mongo).
@@ -300,6 +307,7 @@ def test_process_items_syncs_mutable_config_to_multicam_parent(
         'cameraRegistrationSource': {'model': 'from-import'},
     }
 
+    resolve_attachment_item_id.return_value = None
     folder_cls.return_value.childItems.return_value = [item]
     item_cls.return_value.childFiles.return_value = iter([file])
     file_cls.return_value.download.return_value = lambda: [json.dumps(payload).encode()]
@@ -335,6 +343,7 @@ def test_process_items_syncs_mutable_config_to_multicam_parent(
     assert parent_call.args[2] is False
 
 
+@patch('dive_server.crud_rpc.crud_dataset.resolve_metadata_attachment_item_id')
 @patch('dive_server.crud_rpc.crud_annotation.save_annotations')
 @patch('dive_server.crud_rpc.dive.migrate')
 @patch('dive_server.crud_rpc.viame.load_json_as_track_and_attributes')
@@ -356,6 +365,7 @@ def test_process_items_syncs_track_attributes_to_multicam_parent(
     load_json,
     migrate,
     save_annotations,
+    resolve_attachment_item_id,
 ):
     """Annotation imports that derive attributes also union them onto the parent."""
     camera_folder = {
@@ -392,6 +402,7 @@ def test_process_items_syncs_track_attributes_to_multicam_parent(
         }
     }
 
+    resolve_attachment_item_id.return_value = None
     folder_cls.return_value.childItems.return_value = [item]
     item_cls.return_value.childFiles.return_value = iter([file])
     file_cls.return_value.download.return_value = lambda: [json.dumps(payload).encode()]
diff --git a/server/tests/test_validate_files.py b/server/tests/test_validate_files.py
index dc68fef15..f452ce3bf 100644
--- a/server/tests/test_validate_files.py
+++ b/server/tests/test_validate_files.py
@@ -8,7 +8,51 @@ def test_response_shape():
     result = validate_files(['image_0001.jpg', 'tracks.csv'])
 
     assert set(result) == {"ok", "message", "type", "roles", "reasons"}
-    assert set(result["roles"]) == {"media", "annotations", "datasetConfig", "ignored"}
+    assert set(result["roles"]) == {
+        "media",
+        "annotations",
+        "datasetConfig",
+        "frameMetadata",
+        "ignored",
+    }
+
+
+def test_image_sequence_with_annotation_csv_and_frame_metadata_csv():
+    result = validate_files(['image_0001.jpg', 'tracks.csv', 'frame_metadata.csv'])
+
+    assert result['ok'] is True
+    assert result['type'] == constants.ImageSequenceType
+    assert 'tracks.csv' in result['roles']['annotations']
+    assert 'frame_metadata.csv' in result['roles']['frameMetadata']
+    # The annotation CSV is not misclassified as a sidecar, and the sidecar is not an annotation.
+    assert 'frame_metadata.csv' not in result['roles']['annotations']
+    assert 'tracks.csv' not in result['roles']['frameMetadata']
+    assert result['roles']['ignored'] == []
+
+
+def test_image_sequence_rejects_multiple_reserved_metadata_attachments():
+    result = validate_files(
+        [
+            'image_0001.jpg',
+            'frame_metadata.csv',
+            'frame_metadata.txt',
+            'frame-metadata.csv',
+            'frame-metadata.txt',
+        ]
+    )
+
+    assert result['ok'] is False
+    assert result['message'] == (
+        'More than one metadata file was selected. Choose one file and try again.'
+    )
+
+
+def test_image_sequence_classifies_reserved_json_only_as_metadata():
+    result = validate_files(['image_0001.jpg', 'frame_metadata.json'])
+
+    assert result['ok'] is True
+    assert result['roles']['frameMetadata'] == ['frame_metadata.json']
+    assert result['roles']['annotations'] == []
 
 
 def test_image_sequence_with_yaml_annotation():
@@ -63,14 +107,33 @@ def test_annotation_json_and_config_json_are_distinguished():
     assert 'config.json' not in result['roles']['annotations']
 
 
-def test_every_role_is_populated_for_a_full_selection():
-    result = validate_files(['image_0001.jpg', 'tracks.csv', 'meta.json'])
+def test_video_with_frame_metadata_csv_accepts_sidecar():
+    result = validate_files(['movie.mp4', 'frame_metadata.csv'])
+
+    assert result['ok'] is True
+    assert result['type'] == constants.VideoType
+    assert result['roles']['frameMetadata'] == ['frame_metadata.csv']
+    assert 'frame_metadata.csv' not in result['roles']['ignored']
+
+
+def test_large_image_with_frame_metadata_csv_accepts_sidecar():
+    # The attachment is stored for every dataset type; read time decides what to do with it.
+    result = validate_files(['mosaic.tif', 'frame_metadata.csv'])
 
     assert result['ok'] is True
+    assert result['type'] == constants.LargeImageType
+    assert result['roles']['frameMetadata'] == ['frame_metadata.csv']
+    assert result['roles']['ignored'] == []
+
+
+def test_every_role_is_populated_for_a_full_selection():
+    result = validate_files(['image_0001.jpg', 'tracks.csv', 'meta.json', 'frame_metadata.csv'])
+
     assert result['roles'] == {
         'media': ['image_0001.jpg'],
         'annotations': ['tracks.csv'],
         'datasetConfig': ['meta.json'],
+        'frameMetadata': ['frame_metadata.csv'],
         'ignored': [],
     }
     assert result['reasons'] == {}
@@ -112,7 +175,9 @@ def test_multiple_videos_with_config_json_is_rejected():
     result = validate_files(['a.mp4', 'b.mp4', 'config.json'])
 
     assert result['ok'] is False
-    assert result['message'] == "Annotation upload is not supported when multiple videos are uploaded"
+    assert (
+        result['message'] == "Annotation upload is not supported when multiple videos are uploaded"
+    )
 
 
 def test_multiple_videos_without_annotations_is_allowed():
@@ -160,12 +225,13 @@ def test_validate_files_nitf_remains_large_image():
 def test_ignored_is_the_exact_complement_of_the_accepted_roles():
     # The web client uploads the selection minus `ignored`, so a file that is neither given a
     # role nor listed as ignored would silently not upload. Pin the partition over a selection
-    # that reaches every branch: media, annotations, dataset config, and two side files.
+    # that reaches every branch: media, annotations, dataset config, sidecar, and two side files.
     files = [
         'image_0001.jpg',
         'image_0002.jpg',
         'tracks.csv',
         'config.json',
+        'frame_metadata.csv',
         'notes.md',
         'thumbnail.png.bak',
     ]
diff --git a/testutils/framemetadata.spec.json b/testutils/framemetadata.spec.json
new file mode 100644
index 000000000..647e5b274
--- /dev/null
+++ b/testutils/framemetadata.spec.json
@@ -0,0 +1,21 @@
+{
+  "frame-metadata.txt": true,
+  "frame-metadata.csv": true,
+  "frame-metadata.json": true,
+  "FRAME-METADATA.TXT": true,
+  "frame_metadata.csv": true,
+  "frame_metadata.json": true,
+  "frame_metadata.txt": true,
+  "FRAME_METADATA.CSV": true,
+  "left/frame-metadata.txt": true,
+  "left/frame-metadata.csv": true,
+  "right\\frame_metadata.csv": true,
+  "right\\frame_metadata.txt": true,
+  "nav.meta.csv": false,
+  "a.b.meta.txt": false,
+  "nav.csv": false,
+  "nav.txt": false,
+  "prefix-frame-metadata.txt": false,
+  "frame_metadata.csv.bak": false,
+  ".meta.csv": false
+}
diff --git a/testutils/multicam.spec.json b/testutils/multicam.spec.json
index 95fccfe52..ce35aa4a1 100644
--- a/testutils/multicam.spec.json
+++ b/testutils/multicam.spec.json
@@ -9,6 +9,41 @@
       }
     },
     "/home/user/data": {
+      "local.csv": "filename,depth\nleft.png,10\n",
+      "sharedVideos": {
+        "left.mp4": "",
+        "right.mp4": "",
+        "frame_metadata.csv": "filename,depth\nleft.mp4,10\nright.mp4,20\n"
+      },
+      "archiveMulticam": {
+        "meta.json": "{\"metadataFile\":\"metadata/shared.csv\",\"metadataOriginalName\":\"shared.csv\"}",
+        "metadata": {
+          "shared.csv": "filename,depth\nleft1.png,20\n"
+        },
+        "left": {
+          "left1.png": "",
+          "meta.json": "{\"metadataFile\":\"metadata/local.csv\",\"metadataOriginalName\":\"local.csv\"}",
+          "metadata": {
+            "local.csv": "filename,depth\nleft1.png,10\n"
+          }
+        },
+        "right": {
+          "right1.png": "",
+          "meta.json": "{}"
+        }
+      },
+      "upstreamArchiveMulticam": {
+        "meta.json": "{\"metadataFileItemId\": \"64b8f0c2e1d3a40001abcdef\", \"metadataFileOriginalName\": \"flight_log.csv\"}",
+        "flight_log.csv": "filename,depth\nleft1.png,10\n",
+        "left": {
+          "left1.png": "",
+          "meta.json": "{\"metadataFileItemId\": \"64b8f0c2e1d3a40001abcdee\"}"
+        },
+        "right": {
+          "right1.png": "",
+          "meta.json": "{}"
+        }
+      },
       "stereoLeftRightCombinedImages": {
         "left1.png": "",
         "left2.png": "",