diff --git a/invokeai/frontend/webv2/public/locales/en.json b/invokeai/frontend/webv2/public/locales/en.json
index a98c3237249..35fa8bebfaf 100644
--- a/invokeai/frontend/webv2/public/locales/en.json
+++ b/invokeai/frontend/webv2/public/locales/en.json
@@ -3110,6 +3110,7 @@
       "initialFrames": "Start & End Images",
       "initialVideo": "Initial Video",
       "initialVideoBlocked": "Clear the first frame to extend a video instead.",
+      "initialVideoCapBlocked": "All 3 video reference slots are in use, so there is no room for the continuity reference this clip needs. Remove a video reference first.",
       "lastFrame": "Last Frame",
       "lastFrameExtendHelp": "Optional destination: the extension ends on this image.",
       "lastFrameHelp": "Optional: the video ends on this image (interpolates from the first frame).",
@@ -3163,6 +3164,12 @@
       "referenceConditioningVideoAudio": "Video + audio",
       "referenceDetailMatch": "Match generation size",
       "referenceDetailMax": "Max detail (2048px, slower)",
+      "referenceExtendCapFull": "Initial video not set",
+      "referenceExtendCapFullDescription": "All 3 video reference slots are in use, so there is no room for the continuity reference this clip needs. Remove a video reference, then drop the clip again.",
+      "referenceExtendHelp": "The generated video is appended to this clip at its End Frame. A linked video reference samples up to the last ~5 seconds before that cutpoint for continuity — never more than the generated clip's own length, since the model discards the overrun at the seam. Its trim re-derives whenever the cutpoints or the frame count change.",
+      "referenceImageCapRace": "All {{max}} image reference slots filled while this one was loading, so it was not added.",
+      "referenceVideoCapRace": "All {{max}} video reference slots filled while this one was loading, so it was not added.",
+      "referenceFromInitialVideo": "Initial video",
       "references": "References",
       "referencesHelp": "Up to 3 videos and 9 images condition the generation, in order — reordering references changes the result. A video reference can contribute its image track, its soundtrack, or both.",
       "removeReference": "Remove reference",
diff --git a/invokeai/frontend/webv2/src/features/upscale/ui/UpscaleWidgetView.tsx b/invokeai/frontend/webv2/src/features/upscale/ui/UpscaleWidgetView.tsx
index f53f959cc2b..e1ae5ebed83 100644
--- a/invokeai/frontend/webv2/src/features/upscale/ui/UpscaleWidgetView.tsx
+++ b/invokeai/frontend/webv2/src/features/upscale/ui/UpscaleWidgetView.tsx
@@ -52,7 +52,7 @@ import { Combobox, Field, IconButton, Select, Tooltip } from '@platform/ui';
 import { SliderNumberField } from '@platform/ui/SliderNumberField';
 import { toaster } from '@platform/ui/toaster';
 import { DicesIcon } from 'lucide-react';
-import { memo, useCallback, useMemo } from 'react';
+import { memo, useCallback, useId, useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
 
 import { areInputImagesEquivalent, valuesAreEqual } from './upscaleComparators';
@@ -284,6 +284,13 @@ export const UpscaleWidgetView = () => {
     [t, values]
   );
   const patch = useCallback((next: Partial<UpscaleWidgetValues>) => patchValues(next), [patchValues]);
+  // Chakra's `Field.Root` hands its single `ids.control` to EVERY control
+  // inside it, and the seed Field holds the NumberInput, the shuffle button
+  // and this switch. Without an id of its own the switch's hidden input
+  // collides with the seed input, so the `<label>` Switch.Root renders points
+  // at the seed field and clicking the toggle only moved focus.
+  const seedSwitchId = useId();
+  const seedSwitchIds = useMemo(() => ({ hiddenInput: `${seedSwitchId}-randomize-seed` }), [seedSwitchId]);
   const patchPromptDraft = useCallback((next: ProjectPromptDraftPatch) => patchDraft(next), [patchDraft]);
 
   useMountEffect(() => {
@@ -639,7 +646,12 @@ export const UpscaleWidgetView = () => {
                   <DicesIcon />
                 </IconButton>
               </Tooltip>
-              <Switch.Root checked={values.shouldRandomizeSeed} size="sm" onCheckedChange={set.randomizeSeed}>
+              <Switch.Root
+                checked={values.shouldRandomizeSeed}
+                ids={seedSwitchIds}
+                size="sm"
+                onCheckedChange={set.randomizeSeed}
+              >
                 <Switch.HiddenInput />
                 <Switch.Control _checked={SWITCH_CHECKED_PROPS}>
                   <Switch.Thumb />
diff --git a/invokeai/frontend/webv2/src/features/video/core/graph.test.ts b/invokeai/frontend/webv2/src/features/video/core/graph.test.ts
index 448ed53f836..04676668921 100644
--- a/invokeai/frontend/webv2/src/features/video/core/graph.test.ts
+++ b/invokeai/frontend/webv2/src/features/video/core/graph.test.ts
@@ -557,10 +557,108 @@ describe('compileVideoGraph — MiniMax H3 Ref2VA', () => {
     );
   });
 
+  it('reference-extend: only the linked tail window is anchored to the clip end', () => {
+    const linked = (clip: Record<string, unknown>, flag = true) => ({
+      clip: { fps: 24, height: 480, numFrames: 402, video_name: 'long.mp4', width: 832, ...clip },
+      conditioning: 'video_audio' as const,
+      ...(flag ? { fromSourceVideo: true } : {}),
+      kind: 'video' as const,
+    });
+    const startOf = (reference: unknown) =>
+      nodeOfType(
+        compileVideoGraph({ ...referenceSettings, references: [reference] } as never, model).backendGraph,
+        'minimax_h3_video_reference'
+      ).start_frame;
+
+    // A user's own reference keeps an absolute start: their trim is a position,
+    // not a length, and re-anchoring it would drift with the estimate.
+    expect(startOf(linked({ endFrame: 400, startFrame: 260 }, false))).toBe(260);
+    // A start at or inside the estimate's slop stays ABSOLUTE: the relative
+    // form resolves to `startFrame + (real - estimate)`, and the backend
+    // rejects a negative index rather than clamping, so an estimate that
+    // overshoots by more than `startFrame` would fail the whole generation.
+    expect(startOf(linked({ endFrame: 400, startFrame: 0 }))).toBe(0);
+    expect(startOf(linked({ endFrame: 400, startFrame: 1 }))).toBe(1);
+    expect(startOf(linked({ endFrame: 400, startFrame: 3 }))).toBe(3);
+    // Clear of the slop, the window rides the negative anchor again.
+    expect(startOf(linked({ endFrame: 400, startFrame: 4 }))).toBe(-398);
+    // A cutpoint far enough from the end that BOTH bounds keep the estimate.
+    expect(startOf(linked({ endFrame: 300, startFrame: 160 }))).toBe(160);
+    // The tail case: end went negative, so the start follows it.
+    expect(startOf(linked({ endFrame: 400, startFrame: 260 }))).toBe(-142);
+  });
+
   it('fl2va graphs are unchanged by the ref2va machinery', () => {
     const { backendGraph } = compileVideoGraph(settingsFor(componentSource), componentSource);
 
     expect(nodesOfType(backendGraph, 'minimax_h3_reference_conditioning')).toHaveLength(0);
     expect(nodesOfType(backendGraph, 'collect')).toHaveLength(0);
   });
+
+  it('reference-extend: appends the new clip to the initial video without frame conditioning', () => {
+    const initialVideo = {
+      endFrame: 400,
+      fps: 24,
+      height: 480,
+      numFrames: 402,
+      startFrame: 10,
+      video_name: 'long.mp4',
+      width: 832,
+    };
+    const settings = {
+      ...referenceSettings,
+      references: [
+        // The linked tail reference (as the setter derives it) plus a user reference.
+        {
+          clip: { ...initialVideo, endFrame: 400, startFrame: 260 },
+          conditioning: 'video_audio' as const,
+          fromSourceVideo: true,
+          kind: 'video' as const,
+        },
+        ...referenceSettings.references,
+      ],
+      sourceVideo: initialVideo,
+    };
+    const { backendGraph } = compileVideoGraph(settings, model);
+
+    // The new clip is intermediate; the crossfade concat is the output, fed
+    // [trimmed source, new clip]; the source is retimed to H3's fixed 24 fps.
+    expect(nodeOfType(backendGraph, 'minimax_h3_latents_to_video')).toMatchObject({
+      id: 'extension_clip',
+      is_intermediate: true,
+    });
+    expect(nodeOfType(backendGraph, 'video_concat')).toMatchObject({ id: 'video_output', transition: 'crossfade' });
+    expect(nodeOfType(backendGraph, 'extract_video_range')).toMatchObject({ end_frame: -2, fps: 24, start_frame: 10 });
+    expect(hasEdge(backendGraph, 'source_video', 'video', 'source_clip_collect', 'item')).toBe(true);
+    expect(hasEdge(backendGraph, 'extension_clip', 'video', 'clips_to_join', 'item')).toBe(true);
+
+    // Continuity comes from the references — no frame conditioning, no last-frame extraction.
+    expect(nodesOfType(backendGraph, 'minimax_h3_frame_conditioning')).toHaveLength(0);
+    expect(nodesOfType(backendGraph, 'video_frame_extract')).toHaveLength(0);
+
+    // The linked reference is an ordinary first reference; the flag never reaches metadata.
+    const videoReferences = nodesOfType(backendGraph, 'minimax_h3_video_reference');
+
+    // Both bounds ride the SAME negative anchor, so the extracted window keeps
+    // its exact length whatever the clip's real frame count turns out to be.
+    // A positive start would have made it `tail + (real - estimate)` frames,
+    // and the overrun is discarded at the seam.
+    expect(videoReferences[0]).toMatchObject({ end_frame: -2, id: 'reference_1', start_frame: -142 });
+    expect((videoReferences[0].end_frame as number) - (videoReferences[0].start_frame as number)).toBe(140);
+    const metadata = nodeOfType(backendGraph, 'core_metadata');
+
+    expect(metadata.generation_mode).toBe('minimax_h3_ref2v');
+    expect(metadata).toMatchObject({
+      source_video: { video_name: 'long.mp4' },
+      source_video_end_frame: 400,
+      source_video_start_frame: 10,
+    });
+    expect((metadata.minimax_h3_references as Record<string, unknown>[])[0]).toEqual({
+      conditioning: 'video_audio',
+      end_frame: 260 + 140,
+      kind: 'video',
+      start_frame: 260,
+      video_name: 'long.mp4',
+    });
+  });
 });
diff --git a/invokeai/frontend/webv2/src/features/video/core/graph.ts b/invokeai/frontend/webv2/src/features/video/core/graph.ts
index 08fc2509444..6334b7ecd2f 100644
--- a/invokeai/frontend/webv2/src/features/video/core/graph.ts
+++ b/invokeai/frontend/webv2/src/features/video/core/graph.ts
@@ -66,24 +66,7 @@ const addReferenceNodes = (
 ): BackendInvocationContract => {
   let chain: BackendInvocationContract | null = null;
   references.forEach((reference, index) => {
-    const node =
-      reference.kind === 'image'
-        ? addNode(graph, {
-            detail: reference.detail,
-            id: `reference_${index + 1}`,
-            image: toImageField(reference.image),
-            type: 'minimax_h3_image_reference',
-          })
-        : addNode(graph, {
-            conditioning: reference.conditioning,
-            // Same estimate-overshoot protection as the extend path: tail-window bounds
-            // compile as negative indices the backend resolves against the REAL count.
-            end_frame: toTailAwareIndex(reference.clip.endFrame, reference.clip.numFrames),
-            id: `reference_${index + 1}`,
-            start_frame: toTailAwareIndex(reference.clip.startFrame, reference.clip.numFrames),
-            type: 'minimax_h3_video_reference',
-            video: { video_name: reference.clip.video_name },
-          });
+    const node = addReferenceNode(graph, reference, index);
     const collect = addNode(graph, { id: `reference_collect_${index + 1}`, type: 'collect' });
 
     if (chain) {
@@ -100,6 +83,78 @@ const addReferenceNodes = (
   return chain;
 };
 
+const addReferenceNode = (
+  graph: BackendGraphContract,
+  reference: VideoReferenceItem,
+  index: number
+): BackendInvocationContract => {
+  if (reference.kind === 'image') {
+    return addNode(graph, {
+      detail: reference.detail,
+      id: `reference_${index + 1}`,
+      image: toImageField(reference.image),
+      type: 'minimax_h3_image_reference',
+    });
+  }
+  // Same estimate-overshoot protection as the extend path: tail-window bounds
+  // compile as negative indices the backend resolves against the REAL count.
+  const endFrame = toTailAwareIndex(reference.clip.endFrame, reference.clip.numFrames);
+
+  return addNode(graph, {
+    conditioning: reference.conditioning,
+    end_frame: endFrame,
+    id: `reference_${index + 1}`,
+    start_frame: toReferenceStartIndex(reference, endFrame),
+    type: 'minimax_h3_video_reference',
+    video: { video_name: reference.clip.video_name },
+  });
+};
+
+/**
+ * A video reference's start bound, measured from the same end as its other bound.
+ *
+ * `toTailAwareIndex` sends a near-the-end bound out NEGATIVE, resolved against
+ * the clip's REAL frame count, and leaves anything further back POSITIVE, taken
+ * from the panel's ESTIMATE. That split is right for a hand-picked trim, whose
+ * start is an absolute position the estimate must not drift — but the linked
+ * tail window straddles it: the cutpoint end goes negative while the start,
+ * ~124 frames back, stays positive, so what the backend extracts is
+ * `tail + (real - estimate)` frames rather than `tail`. That length is a budget
+ * the backend enforces by discarding the overrun at the SEAM (see
+ * `deriveReferenceExtendClip`), so it has to survive an inexact estimate.
+ *
+ * The linked entry's start is not an absolute pick — it is defined as
+ * `tail - 1` frames before the cutpoint — so it rides the same negative anchor
+ * and the window keeps its length whatever the real count turns out to be.
+ *
+ * Two cases stay absolute. A cutpoint far enough from the end leaves both
+ * bounds on the estimate already. And a start within `TAIL_INDEX_SLOP` of the
+ * clip's own beginning stays absolute because the relative form resolves to
+ * `startFrame + (real - estimate)`, which goes NEGATIVE once the estimate
+ * overshoots by more than `startFrame` — and `_ResolvedVideoRange.resolve`
+ * rejects an out-of-range index outright rather than clamping, failing the
+ * whole generation. That can only arise when the window fills nearly the entire
+ * clip, where its length cannot be honoured anyway; below the slop the absolute
+ * form is always in range, and the drift it costs is the estimate error itself,
+ * a frame or two.
+ *
+ * DECIDED: the slop is not widened beyond 3. An estimate error past the slop
+ * can still fail the relative form, but only on a clip barely longer than the
+ * window (it needs `error > startFrame`), and `TAIL_INDEX_SLOP` is this file's
+ * declared bound on how wrong the estimate gets. A wider guard would not
+ * remove the cliff — it would move it, and pay for the move with silent length
+ * drift on every clip inside the wider margin.
+ */
+const toReferenceStartIndex = (reference: Extract<VideoReferenceItem, { kind: 'video' }>, endIndex: number): number => {
+  const { clip } = reference;
+
+  if (reference.fromSourceVideo !== true || endIndex >= 0 || clip.startFrame <= TAIL_INDEX_SLOP) {
+    return toTailAwareIndex(clip.startFrame, clip.numFrames);
+  }
+
+  return endIndex - (clip.endFrame - clip.startFrame);
+};
+
 const addPromptAndSeedNodes = (graph: BackendGraphContract) => ({
   negativePrompt: addNode(graph, { id: 'negative_prompt', type: 'string' }),
   positivePrompt: addNode(graph, { id: 'positive_prompt', type: 'string' }),
@@ -125,13 +180,25 @@ const toImageField = (image: { image_name: string }) => ({ image_name: image.ima
 // start is always below the end, so the pair keeps its order when both go
 // negative). Mid-clip picks stay positive: a negative offset computed from
 // an overshooting estimate would drift them instead.
+/**
+ * How wrong the panel's `duration x fps` frame-count estimate is allowed to be.
+ * VFR containers overshoot it by a frame or two, so bounds within this many
+ * frames of the estimated end are emitted relative to the REAL end instead.
+ */
+const TAIL_INDEX_SLOP = 3;
+
 const toTailAwareIndex = (frame: number, estimatedNumFrames: number): number => {
   const tailOffset = estimatedNumFrames - 1 - frame;
 
-  return tailOffset <= 3 ? -(tailOffset + 1) : frame;
+  return tailOffset <= TAIL_INDEX_SLOP ? -(tailOffset + 1) : frame;
 };
 
-const addExtendScaffolding = (
+/**
+ * Trimmed source extraction + [source, new clip] crossfade join — the shared
+ * core of FL2VA/Wan extend and Ref2VA reference-extend. video_concat rebuilds
+ * the soundtrack from every input, so both clips' audio survives the join.
+ */
+const addSourceJoin = (
   graph: BackendGraphContract,
   sourceVideo: NonNullable<VideoSettings['sourceVideo']>,
   newClip: BackendInvocationContract,
@@ -147,13 +214,6 @@ const addExtendScaffolding = (
     video: { video_name: sourceVideo.video_name },
     ...(options.extractFps === undefined ? {} : { fps: options.extractFps }),
   });
-  const lastFrame = addNode(graph, {
-    frame_index: -1,
-    id: 'source_last_frame',
-    is_intermediate: true,
-    type: 'video_frame_extract',
-    use_cache: false,
-  });
   const sourceCollect = addNode(graph, { id: 'source_clip_collect', type: 'collect' });
   const clipsCollect = addNode(graph, { id: 'clips_to_join', type: 'collect' });
   const concat = addNode(graph, {
@@ -166,13 +226,32 @@ const addExtendScaffolding = (
     use_cache: false,
   });
 
-  addEdge(graph, extract, 'video', lastFrame, 'video');
   // Chained collectors keep the join order deterministic: [trimmed source, new clip].
   addEdge(graph, extract, 'video', sourceCollect, 'item');
   addEdge(graph, sourceCollect, 'collection', clipsCollect, 'collection');
   addEdge(graph, newClip, 'video', clipsCollect, 'item');
   addEdge(graph, clipsCollect, 'collection', concat, 'videos');
 
+  return { concat, extract };
+};
+
+const addExtendScaffolding = (
+  graph: BackendGraphContract,
+  sourceVideo: NonNullable<VideoSettings['sourceVideo']>,
+  newClip: BackendInvocationContract,
+  options: { extractFps?: number } = {}
+) => {
+  const { concat, extract } = addSourceJoin(graph, sourceVideo, newClip, options);
+  const lastFrame = addNode(graph, {
+    frame_index: -1,
+    id: 'source_last_frame',
+    is_intermediate: true,
+    type: 'video_frame_extract',
+    use_cache: false,
+  });
+
+  addEdge(graph, extract, 'video', lastFrame, 'video');
+
   return { concat, extract, lastFrame };
 };
 
@@ -527,6 +606,7 @@ const buildMiniMaxH3VideoGraph = (settings: VideoSettings, model: MainModelConfi
 
   let output: BackendInvocationContract;
   let extendParts: { lastFrame: BackendInvocationContract; newClip: BackendInvocationContract } | null = null;
+  let referenceExtendClip: BackendInvocationContract | null = null;
 
   if (mode === 'extend' && settings.sourceVideo && frameConditioning) {
     const newClip = addLatentsToVideo('extension_clip', true);
@@ -538,6 +618,15 @@ const buildMiniMaxH3VideoGraph = (settings: VideoSettings, model: MainModelConfi
     addEdge(graph, lastFrame, 'image', frameConditioning, 'first_image');
     output = concat;
     extendParts = { lastFrame, newClip };
+  } else if (mode === 'reference' && settings.sourceVideo) {
+    // Reference-extend: the new clip is appended to the trimmed Initial
+    // Video. Continuity comes from the references (typically the linked tail
+    // reference), not from frame conditioning, so no last frame is extracted.
+    const newClip = addLatentsToVideo('extension_clip', true);
+    const { concat } = addSourceJoin(graph, settings.sourceVideo, newClip, { extractFps: 24 });
+
+    output = concat;
+    referenceExtendClip = newClip;
   } else {
     output = addLatentsToVideo('video_output', false);
   }
@@ -567,7 +656,11 @@ const buildMiniMaxH3VideoGraph = (settings: VideoSettings, model: MainModelConfi
     height: dimensions.height,
     model,
     negativeWired: false,
-    outputs: extendParts ? [output, extendParts.newClip] : [output],
+    outputs: extendParts
+      ? [output, extendParts.newClip]
+      : referenceExtendClip
+        ? [output, referenceExtendClip]
+        : [output],
     settings,
     width: dimensions.width,
   });
diff --git a/invokeai/frontend/webv2/src/features/video/core/settings.test.ts b/invokeai/frontend/webv2/src/features/video/core/settings.test.ts
index e217bf361c3..19f0ac57711 100644
--- a/invokeai/frontend/webv2/src/features/video/core/settings.test.ts
+++ b/invokeai/frontend/webv2/src/features/video/core/settings.test.ts
@@ -1,11 +1,17 @@
 import { describe, expect, it } from 'vitest';
 
-import type { VideoSettings } from './types';
+import type { VideoReferenceItem, VideoSettings } from './types';
 
+import { MINIMAX_H3_NUM_FRAMES_CHOICES } from './dimensions';
 import {
+  applyReferenceExtendSourceVideo,
+  applyReferenceExtendNumFrames,
+  canPlaceReferenceExtendAnchor,
+  pinReferenceExtendAnchor,
   clearDeletedVideoMedia,
   cloneVideoWidgetValues,
   createVideoSourceClip,
+  deriveReferenceExtendClip,
   isVideoSettings,
   isVideoSourceClip,
   normalizeVideoSettings,
@@ -319,17 +325,21 @@ describe('references', () => {
     );
   });
 
-  it('normalization drops frame/source media when references are present', () => {
+  it('normalization drops frame media when references are present, keeping the source video', () => {
     const normalized = normalizeVideoSettings(
       createSettings({ firstFrameImage: FIRST_FRAME, references: [IMAGE_REFERENCE], sourceVideo: SOURCE_VIDEO })
     );
 
     expect(normalized?.references).toEqual([IMAGE_REFERENCE]);
     expect(normalized?.firstFrameImage).toBeNull();
-    expect(normalized?.sourceVideo).toBeNull();
+    // References + source video is the Ref2VA reference-extend shape;
+    // validation rejects the pair on models that cannot consume it.
+    expect(normalized?.sourceVideo).toEqual(SOURCE_VIDEO);
   });
 
   it('normalization drops malformed entries and enforces the caps, preserving order', () => {
+    // Videos over the cap drop the NEWEST non-anchor entries — the surplus is
+    // whatever arrived last. See the over-cap tests below.
     const tooMany = [
       ...Array.from({ length: 4 }, (_, index) => ({
         ...VIDEO_REFERENCE,
@@ -348,6 +358,77 @@ describe('references', () => {
     ]);
   });
 
+  it('over-cap overflow drops the newest videos but never the anchor', () => {
+    const named = (entry: { kind: string; clip?: { video_name: string } }) =>
+      entry.kind === 'video' ? entry.clip!.video_name : 'img';
+    const tooMany = [
+      IMAGE_REFERENCE,
+      ...Array.from({ length: 5 }, (_unused, index) => ({
+        ...VIDEO_REFERENCE,
+        clip: { ...VIDEO_REFERENCE.clip, video_name: `v${index}.mp4` },
+      })),
+    ];
+    const normalized = normalizeVideoSettings(createSettings({ references: tooMany as never }));
+
+    expect(normalized?.references.map(named as never)).toEqual(['img', 'v0.mp4', 'v1.mp4', 'v2.mp4']);
+
+    // The race shape: an add slipped past the render-time cap gate while the
+    // Initial Video was placing its anchor. The surplus is the racing add (D),
+    // not the user's oldest reference (B) — a plain front-drop deleted B.
+    const anchor = {
+      ...VIDEO_REFERENCE,
+      clip: { ...VIDEO_REFERENCE.clip, video_name: 'anchor.mp4' },
+      fromSourceVideo: true,
+    };
+    const raced = ['b.mp4', 'c.mp4'].map((video_name) => ({
+      ...VIDEO_REFERENCE,
+      clip: { ...VIDEO_REFERENCE.clip, video_name },
+    }));
+    const healed = normalizeVideoSettings(
+      createSettings({
+        references: [
+          ...raced,
+          anchor,
+          { ...VIDEO_REFERENCE, clip: { ...VIDEO_REFERENCE.clip, video_name: 'd.mp4' } },
+        ] as never,
+      })
+    );
+
+    expect(healed?.references.map(named as never)).toEqual(['b.mp4', 'c.mp4', 'anchor.mp4']);
+    expect(healed?.references.at(-1)).toMatchObject({ fromSourceVideo: true });
+  });
+
+  it('normalization heals a panel saved with the anchor prepended', () => {
+    // The build before the anchor was pinned PREPENDED it, so those projects
+    // load with it at index 0. Normalization must move it last -- otherwise the
+    // generated frames continue from whatever reference follows it -- and it
+    // must do so BEFORE the cap trim, or the front-drop deletes the anchor.
+    const anchor = {
+      ...VIDEO_REFERENCE,
+      clip: { ...VIDEO_REFERENCE.clip, video_name: 'anchor.mp4' },
+      fromSourceVideo: true,
+    };
+    const named = (entry: { kind: string; clip?: { video_name: string } }) =>
+      entry.kind === 'video' ? entry.clip!.video_name : 'img';
+
+    const healed = normalizeVideoSettings(createSettings({ references: [anchor, IMAGE_REFERENCE] as never }));
+
+    expect(healed?.references.map(named as never)).toEqual(['img', 'anchor.mp4']);
+
+    // Over the cap, with the anchor in the position the old build left it.
+    const stale = [
+      anchor,
+      ...Array.from({ length: 3 }, (_unused, index) => ({
+        ...VIDEO_REFERENCE,
+        clip: { ...VIDEO_REFERENCE.clip, video_name: `v${index}.mp4` },
+      })),
+    ];
+    const trimmed = normalizeVideoSettings(createSettings({ references: stale as never }));
+
+    expect(trimmed?.references.map(named as never)).toEqual(['v0.mp4', 'v1.mp4', 'anchor.mp4']);
+    expect(trimmed?.references.at(-1)).toMatchObject({ fromSourceVideo: true });
+  });
+
   it('isVideoSettings rejects references combined with frame media', () => {
     expect(isVideoSettings(createSettings({ firstFrameImage: FIRST_FRAME, references: [IMAGE_REFERENCE] }))).toBe(
       false
@@ -378,3 +459,413 @@ describe('references', () => {
     expect(sweptVideo.references).toEqual([IMAGE_REFERENCE]);
   });
 });
+
+describe('reference-extend linkage', () => {
+  // H3 generates at a fixed 24 fps; SOURCE_VIDEO runs at 16, so the two rates
+  // are exercised separately.
+  const longSource = { ...SOURCE_VIDEO, endFrame: 400, numFrames: 402, video_name: 'long.mp4' };
+  const source24 = { ...longSource, fps: 24 };
+  // The panel's default; every choice is on the 17n+5 grid.
+  const FRAMES = 141;
+
+  it('derives the tail trim: the window ending at the cutpoint, clamped at 0', () => {
+    expect(deriveReferenceExtendClip(source24, FRAMES)).toMatchObject({ endFrame: 400, startFrame: 260 });
+    // Shorter than the tail window: fall back to the largest ON-GRID budget the
+    // clip supports (80 frames -> 73) so the window still ENDS on the cutpoint.
+    // Starting at 0 kept the same 73 frames but stopped 7 short of the seam.
+    expect(deriveReferenceExtendClip({ ...SOURCE_VIDEO, fps: 24 }, FRAMES)).toMatchObject({
+      endFrame: 79,
+      startFrame: 7,
+    });
+  });
+
+  it('budgets the window against the generated frame count', () => {
+    // `normalize_reference_video_frames` truncates a reference to the generated
+    // frame count keeping the FRONT, so a window longer than the generation
+    // loses its tail — the frames at the seam. It must never outrun the count.
+    expect(deriveReferenceExtendClip(source24, 124)).toMatchObject({ endFrame: 400, startFrame: 277 });
+    expect(deriveReferenceExtendClip(source24, 90)).toMatchObject({ endFrame: 400, startFrame: 311 });
+    // Above the tail window the budget stops binding: ~5s of lead-in is the cap.
+    expect(deriveReferenceExtendClip(source24, 345)).toMatchObject({ endFrame: 400, startFrame: 260 });
+  });
+
+  it('lands the window ON the 17n+5 grid the backend keeps, at every source rate', () => {
+    // The real test of the window: run it through ALL THREE backend rules.
+    // `resample_video_frame_repeats` onto 24 fps, `frames[:num_frames]`, then
+    // `snap_reference_num_frames` DOWN to 17n+5 — every one of which cuts the
+    // seam end. Rounding the fps conversion DOWN satisfied the first two and
+    // failed the third, losing 17 frames at 23.976 fps at every frame count.
+    const resample = (n: number, fps: number) => Math.floor((n * 24) / fps + 0.5);
+    const snapDown = (n: number) => Math.max(1, Math.floor((n - 5) / 17)) * 17 + 5;
+
+    for (const fps of [10, 12, 15, 16, 18, 20, 23.976, 24, 25, 29.97, 30, 60]) {
+      for (const numFrames of MINIMAX_H3_NUM_FRAMES_CHOICES) {
+        const clip = deriveReferenceExtendClip({ ...longSource, fps }, numFrames);
+        const budget = Math.min(141, numFrames);
+        const kept = snapDown(Math.min(resample(clip.endFrame - clip.startFrame + 1, fps), numFrames));
+
+        expect({ fps, kept, numFrames }).toEqual({ fps, kept: budget, numFrames });
+      }
+    }
+  });
+
+  it('a clip SHORTER than the window still ends its tail on the cutpoint', () => {
+    // The clamped branch used to take the whole clip, whose length is
+    // arbitrary: off the 17n+5 grid, so the snap-down cut the difference from
+    // the END. Nothing about it needs an inexact estimate — it was the common
+    // case for any source under ~5.9s at 24 fps, and the sweep above could not
+    // see it because it only runs a 402-frame clip.
+    const resample = (n: number, fps: number) => Math.floor((n * 24) / fps + 0.5);
+    const snapDown = (n: number) => Math.max(1, Math.floor((n - 5) / 17)) * 17 + 5;
+
+    for (const fps of [12, 16, 23.976, 24, 25, 30]) {
+      for (const total of [40, 60, 80, 100, 120, 141, 200]) {
+        for (const numFrames of [90, 124, 141, 345]) {
+          const source = { ...longSource, endFrame: total - 1, fps, numFrames: total };
+          const clip = deriveReferenceExtendClip(source, numFrames);
+          const window = clip.endFrame - clip.startFrame + 1;
+          const kept = snapDown(Math.min(resample(window, fps), numFrames));
+
+          const discarded = Math.min(resample(window, fps), numFrames) - kept;
+
+          // At most a single frame is trimmed off the seam end -- the source's
+          // own frame boundaries sometimes cannot land on the grid exactly (12
+          // fps cannot reach an odd 141 at all). The old clamp shed up to 16.
+          expect({ discarded: discarded <= 1, fps, numFrames, total }).toEqual({
+            discarded: true,
+            fps,
+            numFrames,
+            total,
+          });
+          // And the window always still ends where it was asked to.
+          expect(clip.endFrame).toBe(source.endFrame);
+        }
+      }
+    }
+  });
+
+  it('converts the window into the source clip fps', () => {
+    // 141 frames of 24 fps material is 94 frames of a 16 fps clip — the same
+    // 5.875s of wall time, which is what the tail window actually means.
+    expect(deriveReferenceExtendClip(longSource, FRAMES)).toMatchObject({ endFrame: 400, startFrame: 307 });
+    // A clip whose probe recorded no usable rate falls back to a no-op
+    // conversion rather than collapsing to the 2-frame floor.
+    expect(deriveReferenceExtendClip({ ...longSource, fps: 0 }, FRAMES)).toMatchObject({ startFrame: 260 });
+    expect(deriveReferenceExtendClip({ ...longSource, fps: -30 }, FRAMES)).toMatchObject({ startFrame: 260 });
+  });
+
+  it('appends a linked video+audio reference and re-derives it on cutpoint changes', () => {
+    // Appended, not prepended: request order is rotary order and the generated
+    // rows continue from the LAST reference block, so the continuity anchor
+    // has to be the final entry.
+    const added = applyReferenceExtendSourceVideo([IMAGE_REFERENCE], source24, 3, FRAMES);
+
+    expect(added).toHaveLength(2);
+    expect(added[0]).toBe(IMAGE_REFERENCE);
+    expect(added[1]).toMatchObject({
+      clip: { endFrame: 400, startFrame: 260, video_name: 'long.mp4' },
+      conditioning: 'video_audio',
+      fromSourceVideo: true,
+      kind: 'video',
+    });
+
+    // The user tunes the conditioning, then moves the cutpoint: the trim
+    // re-derives, the position and conditioning survive.
+    const tuned = added.map((entry, index) =>
+      index === 1 && entry.kind === 'video' ? { ...entry, conditioning: 'video' as const } : entry
+    );
+    const retrimmed = applyReferenceExtendSourceVideo(tuned, { ...source24, endFrame: 300 }, 3, FRAMES);
+
+    expect(retrimmed[1]).toMatchObject({
+      clip: { endFrame: 300, startFrame: 160 },
+      conditioning: 'video',
+      fromSourceVideo: true,
+    });
+    expect(retrimmed[0]).toBe(added[0]);
+  });
+
+  it('clearing the initial video removes only the linked reference (identity-preserving when none)', () => {
+    const list = applyReferenceExtendSourceVideo([VIDEO_REFERENCE, IMAGE_REFERENCE], source24, 3, FRAMES);
+
+    expect(applyReferenceExtendSourceVideo(list, null, 3, FRAMES)).toEqual([VIDEO_REFERENCE, IMAGE_REFERENCE]);
+
+    const unlinked = [VIDEO_REFERENCE, IMAGE_REFERENCE];
+
+    expect(applyReferenceExtendSourceVideo(unlinked, null, 3, FRAMES)).toBe(unlinked);
+  });
+
+  it('normalization re-establishes the linkage recall drops, and the invariants reach it', () => {
+    // `fromSourceVideo` never reaches metadata, so a recalled reference-extend
+    // panel arrives with its anchor UNFLAGGED beside the source video. Every
+    // invariant keys on the flag, so before this: not pinned (the model
+    // continued from whatever followed it), and not re-budgeted (a Frames
+    // change left the window overrunning -- 2s cut off the seam at 345 -> 90).
+    const recalled = { ...VIDEO_REFERENCE, clip: { ...VIDEO_REFERENCE.clip, video_name: 'long.mp4' } };
+    const normalized = normalizeVideoSettings(
+      createSettings({ references: [recalled, IMAGE_REFERENCE], sourceVideo: source24 })
+    );
+
+    // Flagged by clip identity -- the same rule the setter adopts by -- and pinned.
+    expect(normalized?.references).toHaveLength(2);
+    expect(normalized?.references[0]).toBe(IMAGE_REFERENCE);
+    expect(normalized?.references[1]).toMatchObject({
+      clip: { video_name: 'long.mp4' },
+      fromSourceVideo: true,
+    });
+
+    // The frame-count re-budget now reaches the recalled window.
+    const rebudgeted = applyReferenceExtendNumFrames(normalized!.references, 90);
+
+    expect(rebudgeted[1]).toMatchObject({ clip: { endFrame: 47, startFrame: 9 } });
+
+    // A flagged entry stays authoritative: an unflagged same-name entry beside
+    // it is NOT a second anchor.
+    const flaggedElsewhere = normalizeVideoSettings(
+      createSettings({
+        references: [recalled, { ...VIDEO_REFERENCE, fromSourceVideo: true }],
+        sourceVideo: source24,
+      })
+    );
+
+    expect(
+      flaggedElsewhere?.references.filter((entry) => entry.kind === 'video' && entry.fromSourceVideo === true)
+    ).toHaveLength(1);
+    expect(flaggedElsewhere?.references[1]).toMatchObject({ clip: { video_name: 'ref.mp4' }, fromSourceVideo: true });
+
+    // No source video: nothing to link, nothing flagged.
+    const unlinked = normalizeVideoSettings(createSettings({ references: [recalled] }));
+
+    expect(unlinked?.references[0]).not.toHaveProperty('fromSourceVideo');
+  });
+
+  it('adopts the LAST same-name entry: the pin invariant records the anchor last', () => {
+    // Recorded metadata can hold a user's OWN reference to the source clip
+    // ahead of the anchor -- the pin forces the anchor last, so it is always
+    // the later same-name entry. A first-match flagged the user's reference:
+    // their trim got re-budgeted, the list reordered against the recording,
+    // and the true tail window sat unprotected at the seam.
+    const userRef = {
+      ...VIDEO_REFERENCE,
+      clip: { ...VIDEO_REFERENCE.clip, endFrame: 20, startFrame: 0, video_name: 'long.mp4' },
+    };
+    const tailRef = { ...VIDEO_REFERENCE, clip: { ...VIDEO_REFERENCE.clip, video_name: 'long.mp4' } };
+    const normalized = normalizeVideoSettings(
+      createSettings({ references: [userRef, tailRef], sourceVideo: source24 })
+    );
+
+    expect(normalized?.references[0]).toBe(userRef);
+    expect(normalized?.references[1]).toMatchObject({ clip: { endFrame: 47 }, fromSourceVideo: true });
+  });
+
+  it('canonicalizes the flag to at most one entry and keeps normalization stable', () => {
+    // Two flagged entries (a corrupt or hand-merged record) used to oscillate:
+    // the pin moves the FIRST flagged entry last, swapping the pair on every
+    // pass -- and the overflow trim exempts every flagged entry, so an
+    // over-cap list of them could never come back under the cap.
+    const flaggedNamed = (video_name: string) => ({
+      ...VIDEO_REFERENCE,
+      clip: { ...VIDEO_REFERENCE.clip, video_name },
+      fromSourceVideo: true,
+    });
+    const once = normalizeVideoSettings(createSettings({ references: [flaggedNamed('a.mp4'), flaggedNamed('b.mp4')] }));
+    const twice = normalizeVideoSettings(createSettings({ references: once!.references }));
+
+    expect(once?.references.filter((entry) => entry.kind === 'video' && entry.fromSourceVideo === true)).toHaveLength(
+      1
+    );
+    expect(once?.references.at(-1)).toMatchObject({ clip: { video_name: 'b.mp4' }, fromSourceVideo: true });
+    expect(twice?.references).toEqual(once?.references);
+
+    // All-flagged over the cap: the exemption can no longer make the surplus
+    // immortal -- the cap holds, and the surviving flag is the last one.
+    const overCap = normalizeVideoSettings(
+      createSettings({ references: ['a', 'b', 'c', 'd'].map((name) => flaggedNamed(`${name}.mp4`)) })
+    );
+
+    expect(overCap?.references).toHaveLength(3);
+    expect(
+      overCap?.references.filter((entry) => entry.kind === 'video' && entry.fromSourceVideo === true)
+    ).toHaveLength(1);
+    expect(overCap?.references.at(-1)).toMatchObject({ clip: { video_name: 'd.mp4' }, fromSourceVideo: true });
+  });
+
+  it('an absurd probed frame rate falls back to 24 instead of hanging', () => {
+    // Past ~2^53 source frames, tailSourceFrames' adjustment loops cannot even
+    // step (tail + 1 === tail in floats) -- fps 1e17 froze the tab. Any rate
+    // no real container produces now takes the same fallback as a broken one.
+    expect(deriveReferenceExtendClip({ ...source24, fps: 1e17 }, 141)).toMatchObject({
+      endFrame: 400,
+      startFrame: 260,
+    });
+    // Below the bound, a genuinely high-rate clip still gets its REAL window:
+    // 1200 fps needs 7025 source frames for 141 resampled ones. A 1000-fps
+    // bound sent this through the 24 fallback, and the backend -- which
+    // resamples at the rate it probes itself -- collapsed the 141-source-frame
+    // window to 3 frames and raised under text conditioning's 13-frame floor.
+    const highRate = { ...source24, endFrame: 50000, fps: 1200, numFrames: 50001 };
+
+    expect(deriveReferenceExtendClip(highRate, 141)).toMatchObject({ endFrame: 50000, startFrame: 42976 });
+    expect(deriveReferenceExtendClip({ ...highRate, fps: 1e17 }, 141)).toMatchObject({ startFrame: 49860 });
+  });
+
+  it('adopts an unflagged reference for the same clip instead of duplicating it (recall shape)', () => {
+    const recalled = { ...VIDEO_REFERENCE, clip: { ...VIDEO_REFERENCE.clip, video_name: 'long.mp4' } };
+    const result = applyReferenceExtendSourceVideo([IMAGE_REFERENCE, recalled], source24, 3, FRAMES);
+
+    expect(result).toHaveLength(2);
+    expect(result[1]).toMatchObject({
+      clip: { endFrame: 400, startFrame: 260, video_name: 'long.mp4' },
+      fromSourceVideo: true,
+    });
+  });
+
+  it('prefers the flagged entry over an earlier same-name reference on a source swap', () => {
+    // User: linked ref for clip A, plus their OWN hand-trimmed reference for
+    // clip B sitting above it. Swapping the Initial Video to clip B must
+    // update the FLAGGED entry — not rewrite the user's B reference.
+    const linkedA = applyReferenceExtendSourceVideo([], source24, 3, FRAMES)[0];
+    const handTrimmedB = {
+      ...VIDEO_REFERENCE,
+      clip: { ...VIDEO_REFERENCE.clip, endFrame: 200, numFrames: 300, startFrame: 100, video_name: 'b.mp4' },
+    };
+    const sourceB = { ...source24, endFrame: 290, numFrames: 300, video_name: 'b.mp4' };
+    const result = applyReferenceExtendSourceVideo([handTrimmedB, linkedA!], sourceB, 3, FRAMES);
+
+    expect(result[0]).toBe(handTrimmedB);
+    expect(result[1]).toMatchObject({
+      clip: { endFrame: 290, startFrame: 150, video_name: 'b.mp4' },
+      fromSourceVideo: true,
+    });
+    expect(result.filter((entry) => entry.kind === 'video' && entry.fromSourceVideo === true)).toHaveLength(1);
+  });
+
+  it('leaves a full video-reference list unchanged instead of overflowing the cap', () => {
+    const full = [
+      VIDEO_REFERENCE,
+      { ...VIDEO_REFERENCE, clip: { ...VIDEO_REFERENCE.clip, video_name: 'b.mp4' } },
+      { ...VIDEO_REFERENCE, clip: { ...VIDEO_REFERENCE.clip, video_name: 'c.mp4' } },
+    ];
+
+    expect(applyReferenceExtendSourceVideo(full, source24, 3, FRAMES)).toBe(full);
+  });
+
+  it('applyReferenceExtendNumFrames re-derives the window and is idempotent', () => {
+    const linked = applyReferenceExtendSourceVideo([IMAGE_REFERENCE], source24, 3, FRAMES);
+
+    expect(linked[1]).toMatchObject({ clip: { startFrame: 260 } });
+
+    const at124 = applyReferenceExtendNumFrames(linked, 124);
+
+    expect(at124[1]).toMatchObject({ clip: { endFrame: 400, startFrame: 277 }, fromSourceVideo: true });
+    expect(at124[0]).toBe(linked[0]);
+    // Idempotent, and identity-preserving when nothing moves.
+    expect(applyReferenceExtendNumFrames(at124, 124)).toBe(at124);
+    expect(applyReferenceExtendNumFrames(linked, FRAMES)).toBe(linked);
+  });
+
+  it('applyReferenceExtendNumFrames does not ratchet: the window re-widens', () => {
+    // The Frames number input emits a value per keystroke, unclamped, so typing
+    // "345" arrives as 3, then 34, then 345. A shrink-only rule would pin the
+    // window at the 3-frame budget for the rest of the session.
+    const linked = applyReferenceExtendSourceVideo([], source24, 3, 345);
+    const typed = [3, 34, 345].reduce(applyReferenceExtendNumFrames, linked);
+
+    expect(typed[0]).toMatchObject({ clip: { endFrame: 400, startFrame: 260 } });
+    // And a slider dragged down and back up ends where it started.
+    expect([90, 124, 345].reduce(applyReferenceExtendNumFrames, linked)[0]).toMatchObject({
+      clip: { startFrame: 260 },
+    });
+  });
+
+  it('an updater applied after a concurrent write keeps both changes', () => {
+    // The reference field hands `setReferences` an UPDATER because its add
+    // handlers await a gallery resolve before writing. Modelled here: the
+    // handler captures the list, the Initial Video field places the anchor
+    // during the await, then the resolve lands. A captured-array write would
+    // drop the anchor entirely; an updater over live state keeps both.
+    const captured: VideoReferenceItem[] = [];
+    const add = (current: VideoReferenceItem[]): VideoReferenceItem[] => [...current, IMAGE_REFERENCE];
+
+    // ...the Initial Video lands mid-flight.
+    const live = applyReferenceExtendSourceVideo(captured, source24, 3, FRAMES);
+
+    expect(live.some((entry) => entry.kind === 'video' && entry.fromSourceVideo === true)).toBe(true);
+
+    // ...then the resolve writes, against LIVE state rather than `captured`.
+    const merged = pinReferenceExtendAnchor(add(live));
+
+    expect(merged).toHaveLength(2);
+    expect(merged[0]).toBe(IMAGE_REFERENCE);
+    expect(merged[1]).toMatchObject({ fromSourceVideo: true, kind: 'video' });
+
+    // The snapshot write this replaced would have produced just the image.
+    expect(add(captured)).toEqual([IMAGE_REFERENCE]);
+  });
+
+  it('pins the continuity anchor last, whatever the add or drag order', () => {
+    // Request order is rotary order: the generated frames continue from the
+    // LAST reference block. An image added after the Initial Video would
+    // otherwise take a rotary slot between the initial video's tail and the
+    // first generated frame.
+    const linked = applyReferenceExtendSourceVideo([], source24, 3, FRAMES);
+    const anchor = linked[0]!;
+
+    expect(pinReferenceExtendAnchor([anchor, IMAGE_REFERENCE])).toEqual([IMAGE_REFERENCE, anchor]);
+    expect(pinReferenceExtendAnchor([IMAGE_REFERENCE, VIDEO_REFERENCE, anchor])).toEqual([
+      IMAGE_REFERENCE,
+      VIDEO_REFERENCE,
+      anchor,
+    ]);
+    // Identity-preserving when already last, and when there is no anchor.
+    const settled = [IMAGE_REFERENCE, anchor];
+
+    expect(pinReferenceExtendAnchor(settled)).toBe(settled);
+    const none = [IMAGE_REFERENCE, VIDEO_REFERENCE];
+
+    expect(pinReferenceExtendAnchor(none)).toBe(none);
+
+    // Adopting a recalled entry re-pins it rather than leaving it in place.
+    const recalled = { ...VIDEO_REFERENCE, clip: { ...VIDEO_REFERENCE.clip, video_name: 'long.mp4' } };
+    const adopted = applyReferenceExtendSourceVideo([recalled, IMAGE_REFERENCE], source24, 3, FRAMES);
+
+    expect(adopted[1]).toMatchObject({ fromSourceVideo: true, kind: 'video' });
+  });
+
+  it('canPlaceReferenceExtendAnchor agrees with the setter in every state', () => {
+    const video = (name: string, flagged = false) => ({
+      ...VIDEO_REFERENCE,
+      clip: { ...VIDEO_REFERENCE.clip, video_name: name },
+      ...(flagged ? { fromSourceVideo: true } : {}),
+    });
+    const states: VideoReferenceItem[][] = [
+      [],
+      [IMAGE_REFERENCE],
+      [video('a.mp4')],
+      [video('a.mp4'), video('b.mp4')],
+      [video('a.mp4'), video('b.mp4'), video('c.mp4')],
+      // Recall's shape: three unflagged videos, one naming the source clip.
+      [video('long.mp4'), video('b.mp4'), video('c.mp4')],
+      [video('a.mp4'), video('b.mp4'), video('long.mp4', true)],
+    ];
+
+    for (const references of states) {
+      const placed = applyReferenceExtendSourceVideo(references, source24, 3, FRAMES);
+      // The setter signals refusal by returning the input array unchanged.
+      const setterAccepted = placed !== references;
+
+      expect({
+        references: references.map((e) => (e.kind === 'video' ? e.clip.video_name : 'img')),
+        placed: canPlaceReferenceExtendAnchor(references, source24.video_name, 3),
+      }).toEqual({
+        references: references.map((e) => (e.kind === 'video' ? e.clip.video_name : 'img')),
+        placed: setterAccepted,
+      });
+    }
+  });
+
+  it('applyReferenceExtendNumFrames leaves unlinked references alone', () => {
+    const unlinked = [VIDEO_REFERENCE, IMAGE_REFERENCE];
+
+    expect(applyReferenceExtendNumFrames(unlinked, 90)).toBe(unlinked);
+  });
+});
diff --git a/invokeai/frontend/webv2/src/features/video/core/settings.ts b/invokeai/frontend/webv2/src/features/video/core/settings.ts
index 9aa2152a9c1..4cbc9cd8558 100644
--- a/invokeai/frontend/webv2/src/features/video/core/settings.ts
+++ b/invokeai/frontend/webv2/src/features/video/core/settings.ts
@@ -26,6 +26,8 @@ import type {
   WanTargetResolution,
 } from './types';
 
+import { MINIMAX_H3_FPS } from './dimensions';
+
 const isRecord = (value: unknown): value is Record<string, unknown> => Boolean(value) && typeof value === 'object';
 
 const hasFiniteNumber = (record: Record<string, unknown>, key: string): boolean =>
@@ -99,28 +101,110 @@ export const isVideoReferenceItem = (value: unknown): value is VideoReferenceIte
   return false;
 };
 
-/** Drops invalid entries and enforces the per-kind caps, preserving order. */
-const sanitizeVideoReferences = (value: unknown): VideoReferenceItem[] => {
+/**
+ * Drops invalid entries and enforces the per-kind caps, preserving order.
+ *
+ * An over-cap list should never reach here — the add paths re-check the cap
+ * against the live list at apply time and the Initial Video field disables
+ * itself when the video slots are full — so this is the guard for a stale or
+ * hand-edited project record.
+ *
+ * Video overflow drops the NEWEST non-anchor entries: the surplus is whatever
+ * arrived last, and a plain front-drop deleted the user's OLDEST reference
+ * whenever a racing add slipped past the cap. The anchor is exempt whatever
+ * its position — request order is rotary order and the generated frames
+ * continue from the LAST block, so it is the one entry the extension depends
+ * on. Images carry no ordering role and keep the front.
+ */
+const sanitizeVideoReferences = (value: unknown, sourceVideoName?: string): VideoReferenceItem[] => {
   if (!Array.isArray(value)) {
     return [];
   }
+  let valid = value.filter((entry) => isVideoReferenceItem(entry));
+
+  // Canonicalize the flag to AT MOST ONE entry, keeping the LAST. Only a
+  // corrupt or hand-merged record carries two, but two is a poisoned state:
+  // the pin moves the FIRST flagged entry last, so normalization oscillates
+  // between the pair on alternate passes, and the overflow trim below exempts
+  // every flagged entry, so an over-cap list of them could never be brought
+  // under the cap again. The last one matches the pin invariant every healthy
+  // record was written under.
+  let flagged = -1;
+  for (let index = valid.length - 1; index >= 0; index -= 1) {
+    const entry = valid[index]!;
+
+    if (entry.kind === 'video' && entry.fromSourceVideo === true) {
+      flagged = index;
+      break;
+    }
+  }
+  valid = valid.map((entry, index) =>
+    index !== flagged && entry.kind === 'video' && entry.fromSourceVideo === true
+      ? { ...entry, fromSourceVideo: false }
+      : entry
+  );
+
+  // Re-establish the linkage recall drops. `fromSourceVideo` is panel state
+  // and never reaches metadata, so a recalled panel arrives with its anchor
+  // UNFLAGGED beside the source video -- and every invariant keyed on the flag
+  // (the pin, the frame-count re-budget, the seam-anchored start index)
+  // silently lapses: a Frames change left the recalled window unbudgeted and
+  // the backend cut 2s off the seam. The flag is derivable, not just
+  // storable: the video reference naming the Initial Video's clip IS the
+  // anchor. An already-flagged entry stays authoritative.
+  //
+  // Adopt the LAST same-name entry, not the first. The pin invariant means
+  // the anchor is always recorded last, and recorded metadata can hold a
+  // user's OWN reference to the same clip ahead of it -- a first-match
+  // flagged that one instead: the user's trim got re-budgeted, the list
+  // reordered against the recording, and the true tail window was left
+  // unprotected at the seam.
+  if (flagged === -1 && sourceVideoName !== undefined) {
+    for (let index = valid.length - 1; index >= 0; index -= 1) {
+      const entry = valid[index]!;
+
+      if (entry.kind === 'video' && entry.clip.video_name === sourceVideoName) {
+        valid = valid.map((candidate, candidateIndex) =>
+          candidateIndex === index && candidate.kind === 'video' ? { ...candidate, fromSourceVideo: true } : candidate
+        );
+        break;
+      }
+    }
+  }
+
+  // Pin BEFORE the cap trim. The front-drop below assumes the anchor is last,
+  // but a project saved by the build that PREPENDED it loads with the anchor
+  // first -- so without this the overflow rule deletes the one entry it exists
+  // to protect. Pinning here also heals those panels on load: normalization
+  // runs on every read, whereas `setReferences` only fires once the user
+  // touches the reference list.
+  valid = pinReferenceExtendAnchor(valid);
+
+  // Keyed by INDEX, not object identity: a hand-edited record can alias the
+  // same entry object twice, and an identity Set would drop both copies.
+  // With the flag canonicalized to at most one entry above, the flag
+  // exemption can never leave the surplus undroppable.
+  let videosToDrop = Math.max(0, valid.filter((entry) => entry.kind === 'video').length - VIDEO_REFERENCE_MAX_VIDEOS);
+  const dropped = new Set<number>();
+  for (let index = valid.length - 1; index >= 0 && videosToDrop > 0; index -= 1) {
+    const entry = valid[index]!;
+
+    if (entry.kind === 'video' && entry.fromSourceVideo !== true) {
+      dropped.add(index);
+      videosToDrop -= 1;
+    }
+  }
+
   const result: VideoReferenceItem[] = [];
-  let videos = 0;
   let images = 0;
-  for (const entry of value) {
-    if (!isVideoReferenceItem(entry)) {
-      continue;
-    }
+  for (const [index, entry] of valid.entries()) {
     if (entry.kind === 'image') {
       if (images >= VIDEO_REFERENCE_MAX_IMAGES) {
         continue;
       }
       images += 1;
-    } else {
-      if (videos >= VIDEO_REFERENCE_MAX_VIDEOS) {
-        continue;
-      }
-      videos += 1;
+    } else if (dropped.has(index)) {
+      continue;
     }
     result.push(entry);
   }
@@ -145,7 +229,9 @@ const areAcceleratorLorasPresent = (keys: readonly string[], loras: readonly Gen
  * frame and a source video never coexist (normalization and the setters both
  * enforce it), and a last frame refines whichever mode its partner implies:
  * with a first frame it becomes FLF2V interpolation, with a source video it is
- * the destination the extension should land on.
+ * the destination the extension should land on. References always win: with a
+ * source video alongside them (Ref2VA reference-extend) the mode stays
+ * `reference` and the graph appends the new clip to the source.
  */
 export const resolveVideoMode = (
   settings: Pick<VideoSettings, 'firstFrameImage' | 'lastFrameImage' | 'sourceVideo' | 'references'>
@@ -199,16 +285,19 @@ export const normalizeVideoSettings = (values: unknown): VideoSettings | null =>
     return null;
   }
 
-  // References are mutually exclusive with every frame/source-video slot; when a stale
-  // record somehow holds both, the references win deterministically (mirroring the
-  // first-frame-beats-source rule below).
-  const references = sanitizeVideoReferences(values.references);
+  // References are mutually exclusive with the frame slots; when a stale
+  // record somehow holds both, the references win deterministically. A source
+  // video COEXISTS with references (Ref2VA reference-extend) — validation
+  // rejects the pair on models that cannot consume it.
+  const references = sanitizeVideoReferences(
+    values.references,
+    isVideoSourceClip(values.sourceVideo) ? values.sourceVideo.video_name : undefined
+  );
   const hasReferences = references.length > 0;
   const firstFrameImage = !hasReferences && isImageWithDims(values.firstFrameImage) ? values.firstFrameImage : null;
   // A first frame and a source video are mutually exclusive; if a stale
   // project somehow holds both, the first frame wins deterministically.
-  const sourceVideo =
-    !firstFrameImage && !hasReferences && isVideoSourceClip(values.sourceVideo) ? values.sourceVideo : null;
+  const sourceVideo = !firstFrameImage && isVideoSourceClip(values.sourceVideo) ? values.sourceVideo : null;
   const loras = Array.isArray(values.loras) ? values.loras.filter(isVideoLora) : [];
   const acceleratorLoraKeys = getStringArray(values.acceleratorLoraKeys);
   // The flag means "the accelerator LoRAs the toggle added are active": if any
@@ -294,7 +383,7 @@ export const isVideoSettings = (values: unknown): values is VideoSettings => {
     values.references.every(isVideoReferenceItem) &&
     !(
       (values.references as unknown[]).length > 0 &&
-      (values.firstFrameImage !== null || values.lastFrameImage !== null || values.sourceVideo !== null)
+      (values.firstFrameImage !== null || values.lastFrameImage !== null)
     ) &&
     Array.isArray(values.loras) &&
     values.loras.every(isVideoLora) &&
@@ -384,6 +473,284 @@ export const createVideoSourceClip = (item: {
 /** The minimum frames a trim must keep — video_concat's crossfade consumes a 2-frame tail. */
 export const MIN_VIDEO_TRIM_FRAMES = 2;
 
+/**
+ * The MAXIMUM lead-in the reference-extend tail reference samples ahead of the
+ * cutpoint, expressed at 24 fps: ~5s, and exactly on the 17n+5 frame grid
+ * (17*8+5) so the backend's 24 fps resample + snap-down keeps all of it.
+ *
+ * The window is a DURATION — `deriveReferenceExtendClip` scales it to the
+ * source clip's own frame rate, so a 16 fps source samples 94 frames of the
+ * same ~5.9 s rather than 141 frames of ~8.8 s. It is also a CEILING, not a
+ * fixed size: the generated frame count is the other bound, and the smaller of
+ * the two wins.
+ */
+export const VIDEO_REFERENCE_EXTEND_TAIL_FRAMES = 141;
+
+/**
+ * The tail reference's default trim: the frames right before the cutpoint,
+ * sized so the backend keeps ALL of them.
+ *
+ * Three backend rules bound the window, and every one of them discards from
+ * the END — the frames adjacent to the cutpoint, the only ones continuity
+ * depends on. `normalize_reference_video_frames` resamples onto H3's fixed
+ * 24 fps and truncates to the GENERATED frame count keeping the FRONT
+ * (`frames[:num_frames]`); `encode_reference_video` then snaps what survives
+ * DOWN to the `17n + 5` grid the video VAE encodes without padding.
+ *
+ * The budget is therefore `min(TAIL, numFrames)` frames of 24 fps material,
+ * and both of those sit ON that grid already (141 = 17*8+5; every frame choice
+ * is 90 + 17i). The conversion into the source clip's own frame space rounds
+ * UP: overshooting is free, because the truncation cuts the window back to
+ * exactly `numFrames` and the snap then keeps it whole, while undershooting
+ * lands OFF the grid and the snap eats up to 16 frames at the seam. Rounding
+ * down looks safer and is not — it cost 17 frames at 23.976 fps (NTSC film) at
+ * every frame count on offer, and 17 at 16 fps at the 124-frame default.
+ */
+export const deriveReferenceExtendClip = (sourceVideo: VideoSourceClip, numFrames: number): VideoSourceClip => ({
+  ...sourceVideo,
+  endFrame: sourceVideo.endFrame,
+  // Deliberately unclamped by the Initial Video's START cutpoint: the
+  // reference samples the original clip for continuity, independent of which
+  // portion the extension keeps.
+  startFrame: referenceExtendStartFrame(sourceVideo, numFrames),
+});
+
+/**
+ * The highest source frame rate the tail-window math accepts as real; see the
+ * fps guard below. The float plateau it guards (`tail + 1 === tail`) starts
+ * around fps 1.5e15, so 1e6 keeps nine orders of margin — a tighter bound of
+ * 1000 turned real high-rate containers (probe-reported 1200 fps decoded fine
+ * before) into backend hard failures: the 24 fps fallback sized a 141-SOURCE-
+ * frame window that the backend, resampling at the rate it probes itself,
+ * collapsed to 3 frames, under text conditioning's 13-frame minimum.
+ */
+const MAX_REFERENCE_SOURCE_FPS = 1e6;
+
+/** `snap_reference_num_frames`: down to the `17n + 5` grid the video VAE encodes whole. */
+const snapReferenceFrames = (frames: number): number => Math.max(1, Math.floor((frames - 5) / 17)) * 17 + 5;
+
+/** Source frames -> frames after the backend's 24 fps resample (ffmpeg's fps-filter count). */
+const resampledFrameCount = (sourceFrames: number, fps: number): number =>
+  Math.floor((sourceFrames * MINIMAX_H3_FPS) / fps + 0.5);
+
+/** The tail window's start index — see `deriveReferenceExtendClip`. */
+const referenceExtendStartFrame = (clip: VideoSourceClip, numFrames: number): number => {
+  // A clip whose probe recorded no usable rate: the backend resamples at the
+  // rate it probes, so 24 — a no-op conversion — is the only safe assumption.
+  // A zero or negative rate would otherwise collapse the window to the 2-frame
+  // floor, which is below the 13 frames text conditioning needs. The upper
+  // bound is a hang guard: past ~2^53 source frames, `tailSourceFrames`'
+  // adjustment loops cannot even step (`tail + 1 === tail` in floats) and spin
+  // forever on the main thread — a hand-edited record with fps 1e17 froze the
+  // tab on the first Frames keystroke.
+  const fps =
+    Number.isFinite(clip.fps) && clip.fps > 0 && clip.fps <= MAX_REFERENCE_SOURCE_FPS ? clip.fps : MINIMAX_H3_FPS;
+  const requested = Number.isFinite(numFrames)
+    ? Math.min(VIDEO_REFERENCE_EXTEND_TAIL_FRAMES, Math.trunc(numFrames))
+    : VIDEO_REFERENCE_EXTEND_TAIL_FRAMES;
+  // A clip shorter than the window cannot supply the whole budget, and simply
+  // taking what is there leaves the window OFF the 17n+5 grid — so the
+  // snap-down cuts the difference from the END, the frames at the cutpoint.
+  // (24 fps, a 120-frame clip, numFrames 345: a [0,118] window keeps 107 of
+  // its 119 frames and stops half a second short of the seam.) Falling back to
+  // the largest on-grid budget the clip DOES support keeps the same frames and
+  // lands them on the seam. Both bounds are already on the grid in the normal
+  // case, so this is an identity there.
+  const budget = Math.min(
+    requested,
+    snapReferenceFrames(Math.min(resampledFrameCount(clip.endFrame + 1, fps), requested))
+  );
+
+  return Math.max(0, clip.endFrame - (tailSourceFrames(budget, fps) - 1));
+};
+
+/**
+ * The fewest source frames that still resample to at least `budget` frames.
+ *
+ * `floor(t * 24/fps + 0.5) >= budget` is, for an integer budget, exactly
+ * `t >= (budget - 0.5) * fps / 24` — so the smallest such `t` has a closed
+ * form. The two bounded loops absorb the last-ulp disagreements between that
+ * expression and `resampledFrameCount`'s association of the same arithmetic;
+ * each runs at most a step or two. (An earlier version walked down from
+ * `ceil(budget * fps / 24)` instead, which is `~fps / 24` iterations — 124 ms
+ * per Frames keystroke at an absurd-but-probeable rate.)
+ *
+ * Landing short is what matters: the resample is a step function, and every
+ * frame past the budget is discarded from the END — the seam. The minimum
+ * lands on the budget exactly wherever the source's frame boundaries allow,
+ * and within a frame where they cannot (12 fps cannot hit an odd 141 at all).
+ */
+const tailSourceFrames = (budget: number, fps: number): number => {
+  let tail = Math.max(MIN_VIDEO_TRIM_FRAMES, Math.ceil(((budget - 0.5) * fps) / MINIMAX_H3_FPS));
+
+  while (resampledFrameCount(tail, fps) < budget) {
+    tail += 1;
+  }
+  while (tail > MIN_VIDEO_TRIM_FRAMES && resampledFrameCount(tail - 1, fps) >= budget) {
+    tail -= 1;
+  }
+
+  return tail;
+};
+
+/**
+ * Re-derives the linked tail reference's window for a generated frame count.
+ *
+ * The window is a function of that count, so a frame-count change has to move
+ * it. This RE-DERIVES rather than shrinks-to-fit: a shrink-only rule ratchets.
+ * The Frames number input emits a value per keystroke, unclamped, so typing
+ * "345" passes through 3 — and a shrink-only window would collapse to 3 frames
+ * and never come back, silently, for the rest of the session. Dragging the
+ * slider down and back up does the same. Re-deriving is idempotent in
+ * `numFrames`, so the values a keystroke or a drag passes through leave no
+ * trace.
+ *
+ * The cost is that a hand-tuned linked trim resets on a frame-count change as
+ * well as on a cutpoint change — the same bargain the section's help text
+ * already describes, and the backend leaves no alternative: a window that does
+ * not fit the budget loses its seam end.
+ */
+export const applyReferenceExtendNumFrames = (
+  references: VideoReferenceItem[],
+  numFrames: number
+): VideoReferenceItem[] => {
+  let changed = false;
+  const next = references.map((entry) => {
+    if (entry.kind !== 'video' || entry.fromSourceVideo !== true) {
+      return entry;
+    }
+    const startFrame = referenceExtendStartFrame(entry.clip, numFrames);
+
+    if (startFrame === entry.clip.startFrame) {
+      return entry;
+    }
+    changed = true;
+
+    return { ...entry, clip: { ...entry.clip, startFrame } };
+  });
+
+  return changed ? next : references;
+};
+
+/**
+ * Moves the linked tail reference to the end of the list.
+ *
+ * Request order is rotary order: `build_ref2va_packed_sequence` lays the
+ * reference blocks out in order, each advancing a shared clock, and the
+ * generated rows start at the position the LAST block left behind. The
+ * continuity anchor only anchors anything if it IS that block — an image
+ * dropped afterwards wedges itself (a whole rotary slot) between the initial
+ * video's tail and the first generated frame, and the model continues from the
+ * image instead.
+ *
+ * Add order and drag order must not decide that, so the anchor's position is
+ * derived like its trim: last, always. Identity-preserving when it is already
+ * last, or when there is no anchor.
+ */
+export const pinReferenceExtendAnchor = (references: VideoReferenceItem[]): VideoReferenceItem[] => {
+  const index = references.findIndex((entry) => entry.kind === 'video' && entry.fromSourceVideo === true);
+
+  if (index < 0 || index === references.length - 1) {
+    return references;
+  }
+  const pinned = references[index]!;
+
+  return [...references.slice(0, index), ...references.slice(index + 1), pinned];
+};
+
+/**
+ * Whether setting `videoName` as the Initial Video could place its anchor.
+ *
+ * Mirrors `applyReferenceExtendSourceVideo`'s refusal condition so the UI gate
+ * cannot drift from what the setter actually does. An adoptable entry consumes
+ * no slot: the flagged anchor is rewritten in place, and so is an unflagged
+ * reference already naming the same clip -- which is exactly the shape recall
+ * restores, since `fromSourceVideo` is panel state and never reaches metadata.
+ *
+ * `videoName` is the clip currently set; for a clip not yet dropped its name is
+ * unknowable, so the answer is the conservative one -- whether a NEW anchor
+ * would fit.
+ */
+export const canPlaceReferenceExtendAnchor = (
+  references: VideoReferenceItem[],
+  videoName: string | undefined,
+  maxVideos: number
+): boolean => {
+  const videos = references.filter(
+    (entry): entry is Extract<VideoReferenceItem, { kind: 'video' }> => entry.kind === 'video'
+  );
+
+  return (
+    videos.some(
+      (entry) => entry.fromSourceVideo === true || (videoName !== undefined && entry.clip.video_name === videoName)
+    ) || videos.length < maxVideos
+  );
+};
+
+/**
+ * Keeps the reference list in step with the Initial Video on a reference-extend
+ * panel (pure; the setter and the model-selection transition both use it):
+ *
+ * - clearing the Initial Video removes its linked reference;
+ * - setting or re-trimming it re-derives the linked reference's default trim
+ *   (the tail window ending on the cutpoint) — a manually tuned trim
+ *   therefore holds only until the next cutpoint change, which the section's
+ *   help text says;
+ * - with no linked entry yet, an existing video reference for the same clip
+ *   is adopted (recall restores the pair without the linkage flag; adopting
+ *   avoids a duplicate), else a new one is APPENDED — unless the video cap is
+ *   already full, in which case the list is returned unchanged and the
+ *   extension simply runs without a tail reference.
+ *
+ * Appended, not prepended, because request order IS rotary order:
+ * `build_ref2va_packed_sequence` lays the reference blocks out in order, each
+ * advancing a shared clock, and the generated rows then start at the position
+ * the LAST block left behind. The reference the model continues from is
+ * therefore the final one, so the continuity anchor belongs at the end. (The
+ * entry stays reorderable and keeps its place on a re-derive; only the
+ * default position is fixed here.)
+ */
+export const applyReferenceExtendSourceVideo = (
+  references: VideoReferenceItem[],
+  sourceVideo: VideoSourceClip | null,
+  maxVideos: number,
+  numFrames: number
+): VideoReferenceItem[] => {
+  if (!sourceVideo) {
+    const kept = references.filter((entry) => !(entry.kind === 'video' && entry.fromSourceVideo === true));
+
+    return kept.length === references.length ? references : kept;
+  }
+
+  const linked: VideoReferenceItem = {
+    clip: deriveReferenceExtendClip(sourceVideo, numFrames),
+    conditioning: 'video_audio',
+    fromSourceVideo: true,
+    kind: 'video',
+  };
+  // The flagged entry is THE linked reference; adopt-by-name only when none
+  // exists (a recall-restored pair carries no flag). A flag-or-name findIndex
+  // would rewrite a user's own same-clip reference — hand trim and all —
+  // whenever it sat above the flagged one.
+  const flaggedIndex = references.findIndex((entry) => entry.kind === 'video' && entry.fromSourceVideo === true);
+  const linkedIndex =
+    flaggedIndex >= 0
+      ? flaggedIndex
+      : references.findIndex((entry) => entry.kind === 'video' && entry.clip.video_name === sourceVideo.video_name);
+
+  if (linkedIndex >= 0) {
+    return pinReferenceExtendAnchor(
+      references.map((entry, index) =>
+        index === linkedIndex && entry.kind === 'video' ? { ...linked, conditioning: entry.conditioning } : entry
+      )
+    );
+  }
+
+  const videoCount = references.filter((entry) => entry.kind === 'video').length;
+
+  return videoCount >= maxVideos ? references : [...references, linked];
+};
+
 /**
  * Clears conditioning media that no longer exists in the gallery. Returns the
  * input object untouched when nothing changes.
diff --git a/invokeai/frontend/webv2/src/features/video/core/types.ts b/invokeai/frontend/webv2/src/features/video/core/types.ts
index 09ec62cd988..6758cae4b67 100644
--- a/invokeai/frontend/webv2/src/features/video/core/types.ts
+++ b/invokeai/frontend/webv2/src/features/video/core/types.ts
@@ -40,7 +40,21 @@ export type VideoReferenceImageDetail = 'max' | 'match';
  * kind. A video reference reuses `VideoSourceClip` for its trim bounds.
  */
 export type VideoReferenceItem =
-  | { kind: 'video'; clip: VideoSourceClip; conditioning: VideoReferenceConditioning }
+  | {
+      kind: 'video';
+      clip: VideoSourceClip;
+      conditioning: VideoReferenceConditioning;
+      /**
+       * True on the reference the panel derives from the Initial Video in
+       * Ref2VA extend mode: it tracks that clip's identity, and its trim
+       * defaults re-derive from the cutpoint (up to ~5s of lead-in at 24 fps,
+       * capped at the generated frame count so the backend keeps the whole
+       * window) whenever the Initial Video trim or the frame count changes.
+       * It is an ordinary reference otherwise — reorderable, trimmable,
+       * removable — and the flag is panel state only, never in metadata.
+       */
+      fromSourceVideo?: boolean;
+    }
   | { kind: 'image'; image: ImageWithDims; detail: VideoReferenceImageDetail };
 
 export type WanTargetResolution = '480p' | '720p' | '1080p';
@@ -72,11 +86,17 @@ export interface VideoSettings {
    * either `firstFrameImage` or `sourceVideo`.
    */
   lastFrameImage: ImageWithDims | null;
-  /** The clip to extend. Mutually exclusive with `firstFrameImage`. */
+  /**
+   * The clip to extend. Mutually exclusive with `firstFrameImage`. On an
+   * FL2VA model this drives extend mode; on a Ref2VA model it coexists with
+   * `references` (reference-extend: the new clip is appended to it, and a
+   * linked tail reference provides continuity).
+   */
   sourceVideo: VideoSourceClip | null;
   /**
-   * Ref2VA references, in conditioning order (up to 3 videos and 9 images). Mutually
-   * exclusive with `firstFrameImage`/`lastFrameImage`/`sourceVideo`; only a Ref2VA
+   * Ref2VA references, in conditioning order (up to 3 videos and 9 images).
+   * Mutually exclusive with `firstFrameImage`/`lastFrameImage`; `sourceVideo`
+   * may coexist on a Ref2VA model (reference-extend). Only a Ref2VA
    * transformer consumes them — see `resolveVideoMode` and the `reference` mode.
    */
   references: VideoReferenceItem[];
diff --git a/invokeai/frontend/webv2/src/features/video/core/videoPolicies.test.ts b/invokeai/frontend/webv2/src/features/video/core/videoPolicies.test.ts
index 2fe220b4cd8..5435c605456 100644
--- a/invokeai/frontend/webv2/src/features/video/core/videoPolicies.test.ts
+++ b/invokeai/frontend/webv2/src/features/video/core/videoPolicies.test.ts
@@ -1093,7 +1093,7 @@ describe('reference mode policy', () => {
     const settings = settingsFor(model);
 
     expect(getVideoModelPolicy(model, settings).modes).toEqual(['reference']);
-    expect(getVideoModelPolicy(model, settings).references).toEqual({ maxImages: 9, maxVideos: 3 });
+    expect(getVideoModelPolicy(model, settings).references).toEqual({ extend: true, maxImages: 9, maxVideos: 3 });
     expect(getVideoModelPolicy(h3Model(), settingsFor(h3Model())).references).toBeNull();
   });
 
@@ -1247,3 +1247,106 @@ describe('H3 component-source seeding', () => {
     expect(explicit.settings.componentSourceModel?.key).toBe(componentsOnly.key);
   });
 });
+
+describe('reference-extend policy', () => {
+  const initialVideo = {
+    endFrame: 400,
+    fps: 24,
+    height: 480,
+    numFrames: 402,
+    startFrame: 0,
+    video_name: 'long.mp4',
+    width: 832,
+  };
+
+  it('accepts references alongside an initial video on ref2va, rejecting the pair elsewhere', () => {
+    const ref2va = ref2vaTransformer();
+    const combined = settingsFor(ref2va, {
+      componentSourceModel: h3Model(),
+      references: [imageReference],
+      sourceVideo: initialVideo,
+    });
+
+    expect(getVideoValidationReasons(ref2va, combined)).toEqual([]);
+
+    // FL2VA (and any non-reference model) still rejects the combination.
+    const fl2va = h3Model();
+    const reasons = getVideoValidationReasons(
+      fl2va,
+      settingsFor(fl2va, { references: [imageReference], sourceVideo: initialVideo })
+    );
+
+    expect(reasons).toContainEqual(expect.stringContaining('cannot be combined with an initial video on this model'));
+  });
+
+  it('a Wan -> Ref2VA switch snaps the frame count BEFORE sizing the tail window', () => {
+    // Wan's grid starts at 5 frames. Deriving the window before the snap sized
+    // it for that count, and the repair only ever shrank — so the panel landed
+    // on a 90-frame H3 generation with a 5-frame anchor, below the 13 frames
+    // `sample_text_conditioning_frames` needs. Generate failed outright.
+    for (const wanFrames of [5, 9, 21, 81]) {
+      const wan = wanModel('i2v-14b');
+      const toRef = getVideoModelSelectionResult({
+        currentSettings: settingsFor(wan, { modelKey: wan.key, numFrames: wanFrames, sourceVideo: initialVideo }),
+        model: ref2vaTransformer(),
+        models: [wan],
+      });
+      const linked = toRef.settings.references.find(
+        (entry) => entry.kind === 'video' && entry.fromSourceVideo === true
+      );
+
+      expect(toRef.settings.numFrames).toBe(90);
+      // 90 frames of 24 fps material off a 24 fps clip, whatever Wan was on.
+      expect(linked).toMatchObject({ clip: { endFrame: 400, startFrame: 311 } });
+    }
+  });
+
+  it('an FL2VA -> Ref2VA switch keeps the initial video and derives its linked tail reference', () => {
+    const fl2va = h3Model();
+    const toRef = getVideoModelSelectionResult({
+      currentSettings: settingsFor(fl2va, { modelKey: fl2va.key, sourceVideo: initialVideo }),
+      model: ref2vaTransformer(),
+      models: [fl2va],
+    });
+
+    expect(toRef.settings.sourceVideo).toEqual(initialVideo);
+    expect(toRef.clearedLabels).not.toContain('Initial video');
+    // The window is budgeted against the frame count the switch lands on
+    // (H3's 124-frame default, snapped AFTER the derivation): a reference
+    // longer than the generation is truncated at its seam end.
+    expect(toRef.settings.numFrames).toBe(124);
+    expect(toRef.settings.references[0]).toMatchObject({
+      clip: { endFrame: 400, startFrame: 277, video_name: 'long.mp4' },
+      conditioning: 'video_audio',
+      fromSourceVideo: true,
+      kind: 'video',
+    });
+
+    // A task-neutral re-selection of the same model must NOT re-derive a
+    // hand-tuned linked trim (only cutpoint changes do, via the setter).
+    const tuned = {
+      ...toRef.settings,
+      references: toRef.settings.references.map((entry, index) =>
+        index === 0 && entry.kind === 'video' ? { ...entry, clip: { ...entry.clip, startFrame: 300 } } : entry
+      ),
+    };
+    const reselected = getVideoModelSelectionResult({
+      currentSettings: tuned,
+      model: ref2vaTransformer(),
+      models: [fl2va],
+    });
+
+    expect(reselected.settings.references[0]).toMatchObject({ clip: { startFrame: 300 } });
+
+    // And back: the references (linked one included) clear; the clip stays
+    // for FL2VA's own extend mode.
+    const backToFl = getVideoModelSelectionResult({
+      currentSettings: toRef.settings,
+      model: fl2va,
+      models: [fl2va],
+    });
+
+    expect(backToFl.settings.references).toEqual([]);
+    expect(backToFl.settings.sourceVideo).toEqual(initialVideo);
+  });
+});
diff --git a/invokeai/frontend/webv2/src/features/video/core/videoPolicies.ts b/invokeai/frontend/webv2/src/features/video/core/videoPolicies.ts
index 8bda24cadf9..873d77622ed 100644
--- a/invokeai/frontend/webv2/src/features/video/core/videoPolicies.ts
+++ b/invokeai/frontend/webv2/src/features/video/core/videoPolicies.ts
@@ -38,7 +38,13 @@ import {
   WAN_TI2V_PIXEL_MULTIPLE,
   type VideoDimensions,
 } from './dimensions';
-import { MIN_VIDEO_TRIM_FRAMES, resolveVideoMode, VIDEO_ASPECT_RATIO_IDS } from './settings';
+import {
+  applyReferenceExtendSourceVideo,
+  applyReferenceExtendNumFrames,
+  MIN_VIDEO_TRIM_FRAMES,
+  resolveVideoMode,
+  VIDEO_ASPECT_RATIO_IDS,
+} from './settings';
 
 // Video capabilities registry keyed by model base AND variant: unlike still-image
 // generation, Wan's variants differ structurally (which conditioning modes exist,
@@ -118,7 +124,7 @@ interface VideoVariantConfig {
   accelerator: VideoAcceleratorConfig | null;
   audioOutput: boolean;
   /** Ref2VA reference caps; present only on variants whose modes include 'reference'. */
-  references?: { maxVideos: number; maxImages: number };
+  references?: { maxVideos: number; maxImages: number; extend?: boolean };
 }
 
 export const WAN_LIGHTNING_ACCELERATOR: VideoAcceleratorConfig = {
@@ -232,7 +238,10 @@ const MINIMAX_H3_REF2VA: VideoVariantConfig = {
   ...MINIMAX_H3_FL2VA,
   accelerator: MINIMAX_H3_REF2V_TURBO_ACCELERATOR,
   modes: ['reference'],
-  references: { maxImages: 9, maxVideos: 3 },
+  // `extend` = reference-extend: an Initial Video the new clip is appended to,
+  // with a linked tail reference for continuity (no frame conditioning — the
+  // panel derives a reference from the clip instead).
+  references: { extend: true, maxImages: 9, maxVideos: 3 },
 };
 
 export const VIDEO_GENERATION: Record<
@@ -455,7 +464,7 @@ export interface VideoModelPolicy {
     negativeHelpText?: string;
   };
   /** Ref2VA reference caps; null unless the effective variant has a reference mode. */
-  references: { maxVideos: number; maxImages: number } | null;
+  references: { maxVideos: number; maxImages: number; extend?: boolean } | null;
   ui: {
     cfgVisible: boolean;
     cfgLowNoiseVisible: boolean;
@@ -1400,11 +1409,49 @@ export const getVideoModelSelectionResult = ({
     addClearedLabel(clearedLabels, 'References');
   }
 
-  if (next.sourceVideo && !modes.includes('extend')) {
+  if (next.sourceVideo && !modes.includes('extend') && !config.references?.extend) {
     next.sourceVideo = null;
     addClearedLabel(clearedLabels, 'Initial video');
   }
 
+  // The frame count is snapped BEFORE the tail reference is derived: the window
+  // is budgeted against it, and deriving first left a Wan panel's count (as low
+  // as 5) sizing a window for a 90-frame H3 generation — under the 13 frames
+  // text conditioning needs, so Generate failed outright.
+  const snappedFrames = snapVideoNumFrames(model, next.numFrames);
+  const framesChanged = snappedFrames !== next.numFrames;
+
+  if (framesChanged) {
+    next.numFrames = snappedFrames;
+    addClearedLabel(clearedLabels, 'Frames');
+  }
+
+  // Reference-extend: a surviving Initial Video (e.g. carried over from an
+  // FL2VA extend setup) gets its linked tail reference derived, so the switch
+  // lands on a generatable panel. Only when none exists yet: the transition
+  // also runs on task-neutral edits (a same-model re-selection, a component
+  // change), and re-deriving there would reset a hand-tuned trim the help
+  // text only promises to reset on cutpoint changes.
+  if (
+    config.references?.extend &&
+    next.sourceVideo &&
+    !next.references.some((entry) => entry.kind === 'video' && entry.fromSourceVideo === true)
+  ) {
+    next.references = applyReferenceExtendSourceVideo(
+      next.references,
+      next.sourceVideo,
+      config.references.maxVideos,
+      next.numFrames
+    );
+  }
+
+  // A tail reference carried in from another model keeps a window budgeted for
+  // that model's frame count. Only when the count actually moved: otherwise a
+  // task-neutral re-selection would reset a hand-tuned trim.
+  if (config.references?.extend && framesChanged) {
+    next.references = applyReferenceExtendNumFrames(next.references, next.numFrames);
+  }
+
   if (next.firstFrameImage && !modes.includes('first-frame') && !modes.includes('first-last')) {
     next.firstFrameImage = null;
     addClearedLabel(clearedLabels, 'First frame');
@@ -1427,13 +1474,6 @@ export const getVideoModelSelectionResult = ({
     addClearedLabel(clearedLabels, 'Target resolution');
   }
 
-  const snappedFrames = snapVideoNumFrames(model, next.numFrames);
-
-  if (snappedFrames !== next.numFrames) {
-    next.numFrames = snappedFrames;
-    addClearedLabel(clearedLabels, 'Frames');
-  }
-
   const clampedFps =
     config.fps.editable && Number.isFinite(next.fps)
       ? Math.min(config.fps.max, Math.max(config.fps.min, Math.round(next.fps)))
@@ -1575,8 +1615,12 @@ export const getVideoValidationReasons = (model: MainModelConfig, settings: Vide
     reasons.push('A first frame and an initial video cannot be combined. Clear one of them.');
   }
 
-  if (settings.references.length > 0 && (settings.firstFrameImage || settings.lastFrameImage || settings.sourceVideo)) {
-    reasons.push('References cannot be combined with first/last frames or an initial video. Clear one side.');
+  if (settings.references.length > 0 && (settings.firstFrameImage || settings.lastFrameImage)) {
+    reasons.push('References cannot be combined with first/last frames. Clear one side.');
+  }
+
+  if (settings.references.length > 0 && settings.sourceVideo && !config.references?.extend) {
+    reasons.push('References cannot be combined with an initial video on this model. Clear one side.');
   }
 
   if (!config.modes.includes(mode)) {
diff --git a/invokeai/frontend/webv2/src/features/video/ui/VideoReferenceListField.tsx b/invokeai/frontend/webv2/src/features/video/ui/VideoReferenceListField.tsx
index 438617a1c15..e9df66c6f4f 100644
--- a/invokeai/frontend/webv2/src/features/video/ui/VideoReferenceListField.tsx
+++ b/invokeai/frontend/webv2/src/features/video/ui/VideoReferenceListField.tsx
@@ -67,8 +67,8 @@ const ReferenceCard = memo(function ReferenceCard({
   collections,
   disabled,
   index,
-  isFirst,
-  isLast,
+  canMoveDown,
+  canMoveUp,
   onMove,
   onRemove,
   onUpdate,
@@ -77,8 +77,8 @@ const ReferenceCard = memo(function ReferenceCard({
   collections: ReferenceCollections;
   disabled: boolean;
   index: number;
-  isFirst: boolean;
-  isLast: boolean;
+  canMoveDown: boolean;
+  canMoveUp: boolean;
   onMove: (index: number, direction: -1 | 1) => void;
   onRemove: (index: number) => void;
   onUpdate: (index: number, reference: VideoReferenceItem) => void;
@@ -150,6 +150,11 @@ const ReferenceCard = memo(function ReferenceCard({
           <HStack gap="1">
             {reference.kind === 'video' ? <FilmIcon size={12} /> : <ImagePlusIcon size={12} />}
             <MiddleTruncate flex="1" fontSize="xs" text={name} />
+            {reference.kind === 'video' && reference.fromSourceVideo === true ? (
+              <Badge flexShrink={0} size="xs" variant="outline">
+                {t('widgets.video.referenceFromInitialVideo')}
+              </Badge>
+            ) : null}
           </HStack>
           <Select
             collection={reference.kind === 'video' ? collections.conditioning : collections.detail}
@@ -184,7 +189,7 @@ const ReferenceCard = memo(function ReferenceCard({
         <Stack gap="0">
           <IconButton
             aria-label={t('widgets.video.moveReferenceUp')}
-            disabled={disabled || isFirst}
+            disabled={disabled || !canMoveUp}
             size="2xs"
             variant="ghost"
             onClick={handleMoveUp}
@@ -193,7 +198,7 @@ const ReferenceCard = memo(function ReferenceCard({
           </IconButton>
           <IconButton
             aria-label={t('widgets.video.moveReferenceDown')}
-            disabled={disabled || isLast}
+            disabled={disabled || !canMoveDown}
             size="2xs"
             variant="ghost"
             onClick={handleMoveDown}
@@ -225,7 +230,13 @@ export const VideoReferenceListField = memo(function VideoReferenceListField({
   disabled?: boolean;
   maxImages: number;
   maxVideos: number;
-  onChange: (references: VideoReferenceItem[]) => void;
+  /**
+   * Accepts an UPDATER, not a snapshot. The add handlers `await` a gallery
+   * resolve before writing, and the Initial Video field and Frames slider both
+   * write references too -- a captured array would clobber whichever of those
+   * landed during the await.
+   */
+  onChange: (update: (current: VideoReferenceItem[]) => VideoReferenceItem[]) => void;
   references: VideoReferenceItem[];
 }) {
   const { t } = useTranslation();
@@ -235,6 +246,12 @@ export const VideoReferenceListField = memo(function VideoReferenceListField({
   const [isLoading, setIsLoading] = useState(false);
   const [errorMessage, setErrorMessage] = useState<string | null>(null);
 
+  // The continuity anchor is pinned last, so any move that would displace it is
+  // reverted the moment it is written -- the button fired a patch and the list
+  // came back unchanged. Present those as disabled rather than inert.
+  const anchorIndex = references.findIndex(
+    (reference) => reference.kind === 'video' && reference.fromSourceVideo === true
+  );
   const videoCount = references.filter((reference) => reference.kind === 'video').length;
   const imageCount = references.length - videoCount;
   const canAddVideo = videoCount < maxVideos;
@@ -284,14 +301,32 @@ export const VideoReferenceListField = memo(function VideoReferenceListField({
         const [resolved] = await galleryImages.resolveMany([imageName]);
 
         if (resolved) {
-          onChange([
-            ...references,
-            {
-              detail: 'max',
-              image: { height: resolved.height, image_name: resolved.imageName, width: resolved.width },
-              kind: 'image',
-            },
-          ]);
+          // Re-check the cap against the LIVE list: the render-time gate was
+          // evaluated before the await, and another writer (a second drop, or
+          // the Initial Video placing its anchor) can fill the slots meanwhile.
+          // An over-cap write would survive to normalization, whose overflow
+          // rule then has to delete SOMETHING the user placed.
+          let declined = false;
+
+          onChange((current) => {
+            if (current.filter((entry) => entry.kind === 'image').length >= maxImages) {
+              declined = true;
+
+              return current;
+            }
+
+            return [
+              ...current,
+              {
+                detail: 'max',
+                image: { height: resolved.height, image_name: resolved.imageName, width: resolved.width },
+                kind: 'image',
+              },
+            ];
+          });
+          if (declined) {
+            setErrorMessage(t('widgets.video.referenceImageCapRace', { max: maxImages }));
+          }
         }
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -301,7 +336,7 @@ export const VideoReferenceListField = memo(function VideoReferenceListField({
         setIsLoading(false);
       }
     },
-    [onChange, references, reportError]
+    [maxImages, onChange, reportError, t]
   );
 
   const addVideoReference = useCallback(
@@ -321,16 +356,31 @@ export const VideoReferenceListField = memo(function VideoReferenceListField({
             width: item.width,
           });
 
-          onChange([
-            ...references,
-            {
-              // References are truncated to the generated duration, not joined: default to
-              // the whole clip rather than the extend-mode 2-frame-tail trim.
-              clip: { ...clip, endFrame: Math.max(0, clip.numFrames - 1), startFrame: 0 },
-              conditioning: 'video_audio',
-              kind: 'video',
-            },
-          ]);
+          // Same live cap re-check as the image path -- the Initial Video's
+          // anchor is the writer that most easily fills the slots mid-await.
+          let declined = false;
+
+          onChange((current) => {
+            if (current.filter((entry) => entry.kind === 'video').length >= maxVideos) {
+              declined = true;
+
+              return current;
+            }
+
+            return [
+              ...current,
+              {
+                // References are truncated to the generated duration, not joined: default to
+                // the whole clip rather than the extend-mode 2-frame-tail trim.
+                clip: { ...clip, endFrame: Math.max(0, clip.numFrames - 1), startFrame: 0 },
+                conditioning: 'video_audio',
+                kind: 'video',
+              },
+            ];
+          });
+          if (declined) {
+            setErrorMessage(t('widgets.video.referenceVideoCapRace', { max: maxVideos }));
+          }
         }
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -340,7 +390,7 @@ export const VideoReferenceListField = memo(function VideoReferenceListField({
         setIsLoading(false);
       }
     },
-    [onChange, references, reportError]
+    [maxVideos, onChange, reportError, t]
   );
 
   const handleDragEnd = useCallback(
@@ -420,32 +470,36 @@ export const VideoReferenceListField = memo(function VideoReferenceListField({
 
   const updateReference = useCallback(
     (index: number, reference: VideoReferenceItem) => {
-      onChange(references.map((entry, entryIndex) => (entryIndex === index ? reference : entry)));
+      onChange((current) => current.map((entry, entryIndex) => (entryIndex === index ? reference : entry)));
     },
-    [onChange, references]
+    [onChange]
   );
   const removeReference = useCallback(
     (index: number) => {
-      onChange(references.filter((_, entryIndex) => entryIndex !== index));
+      onChange((current) => current.filter((_, entryIndex) => entryIndex !== index));
     },
-    [onChange, references]
+    [onChange]
   );
   const moveReference = useCallback(
     (index: number, direction: -1 | 1) => {
-      const target = index + direction;
+      onChange((current) => {
+        const target = index + direction;
 
-      if (target < 0 || target >= references.length) {
-        return;
-      }
-      const next = [...references];
-      const [entry] = next.splice(index, 1);
+        if (target < 0 || target >= current.length) {
+          return current;
+        }
+        const next = [...current];
+        const [entry] = next.splice(index, 1);
 
-      if (entry) {
+        if (!entry) {
+          return current;
+        }
         next.splice(target, 0, entry);
-        onChange(next);
-      }
+
+        return next;
+      });
     },
-    [onChange, references]
+    [onChange]
   );
 
   return (
@@ -456,8 +510,8 @@ export const VideoReferenceListField = memo(function VideoReferenceListField({
           collections={collections}
           disabled={isInert}
           index={index}
-          isFirst={index === 0}
-          isLast={index === references.length - 1}
+          canMoveDown={index < references.length - 1 && index + 1 !== anchorIndex}
+          canMoveUp={index > 0 && index !== anchorIndex}
           reference={reference}
           onMove={moveReference}
           onRemove={removeReference}
diff --git a/invokeai/frontend/webv2/src/features/video/ui/VideoSourceClipField.tsx b/invokeai/frontend/webv2/src/features/video/ui/VideoSourceClipField.tsx
index 3fa82942610..7c58f9c915a 100644
--- a/invokeai/frontend/webv2/src/features/video/ui/VideoSourceClipField.tsx
+++ b/invokeai/frontend/webv2/src/features/video/ui/VideoSourceClipField.tsx
@@ -377,6 +377,13 @@ export const VideoSourceClipField = memo(
         ) : null}
         {sourceVideo ? (
           <Stack gap="2">
+            {/* The empty-state slot shows the reason when no clip is set; with
+                one set, the frozen trim sliders were the only symptom. */}
+            {disabled && disabledReason ? (
+              <Text color="fg.muted" fontSize="2xs" textWrap="pretty">
+                {disabledReason}
+              </Text>
+            ) : null}
             <Field helpText={t('widgets.video.trimHelp')} label={t('widgets.video.trimStart')}>
               <SliderNumberField
                 ariaLabel={t('widgets.video.trimStart')}
diff --git a/invokeai/frontend/webv2/src/features/video/ui/VideoWidgetView.tsx b/invokeai/frontend/webv2/src/features/video/ui/VideoWidgetView.tsx
index d69ac8faffb..ffa06b4db55 100644
--- a/invokeai/frontend/webv2/src/features/video/ui/VideoWidgetView.tsx
+++ b/invokeai/frontend/webv2/src/features/video/ui/VideoWidgetView.tsx
@@ -8,7 +8,15 @@ import { isMainModelConfig, sanitizeBatchCount, SEED_MAX } from '@features/gener
 import { ensureModelsLoaded, useModelsSelector } from '@features/models';
 import { ModelSelect } from '@features/models/react';
 import { getVideoDurationSeconds, invertVideoAspectRatioId } from '@features/video/core/dimensions';
-import { normalizeVideoWidgetValues, resolveVideoMode, VIDEO_ASPECT_RATIO_IDS } from '@features/video/core/settings';
+import {
+  applyReferenceExtendSourceVideo,
+  applyReferenceExtendNumFrames,
+  canPlaceReferenceExtendAnchor,
+  pinReferenceExtendAnchor,
+  normalizeVideoWidgetValues,
+  resolveVideoMode,
+  VIDEO_ASPECT_RATIO_IDS,
+} from '@features/video/core/settings';
 import {
   getAcceleratorLoraChangeResult,
   getAcceleratorToggleResult,
@@ -24,7 +32,7 @@ import { Button } from '@platform/ui/Button';
 import { SliderNumberField } from '@platform/ui/SliderNumberField';
 import { toaster } from '@platform/ui/toaster';
 import { ArrowLeftRightIcon, DicesIcon } from 'lucide-react';
-import { useCallback, useMemo } from 'react';
+import { useCallback, useEffect, useId, useMemo, useRef } from 'react';
 import { useTranslation } from 'react-i18next';
 
 import { areVideoValuesEqual } from './videoComparators';
@@ -144,6 +152,49 @@ export const VideoWidgetView = () => {
 
   const patch = useCallback((next: Partial<VideoWidgetValues>) => patchValues(next), [patchValues]);
 
+  // Always the newest normalized list. The reference field's add handlers
+  // `await` a gallery resolve before writing, and the Initial Video field and
+  // the Frames slider write references too — so an updater that resolved
+  // against a captured array would clobber whichever of those landed during
+  // the await, silently deleting the anchor or restoring a window the frame
+  // count had already re-derived.
+  // Synced in an effect rather than during render: this file's react-compiler
+  // rule forbids touching a ref while rendering, and a gallery resolve lands
+  // whole frames later, long after the commit.
+  // Keyed by PROJECT, and carrying a LIVENESS bit. The widget is reconciled,
+  // never remounted, across a project switch (the <Activity> key is the panel
+  // instance), while `patch` stays bound to the project its render belonged
+  // to — so a bare latest-list ref tracks whichever project is ACTIVE, and a
+  // gallery resolve landing after a switch would write the new project's
+  // reference list into the old project, wholesale. And a hidden <Activity>
+  // destroys effects while promise continuations keep running: the ref then
+  // freezes with the projectId still matching, so a same-project guard would
+  // happily replay a list the store has since rewritten (a gallery deletion
+  // sweep, say) — resurrecting swept references. `live` is true exactly while
+  // the sync effect is mounted, which is the only time the ref's contents can
+  // be trusted; a write finding it false or mismatched is dropped.
+  //
+  // "Fresh" here means effect-fresh, not instantaneous: two resolves landing
+  // in the same microtask drain still read the same pre-commit list. That
+  // window is inherent to reading through React state at all.
+  const referencesRef = useRef({ live: true, projectId, references: values.references });
+
+  useEffect(() => {
+    referencesRef.current = { live: true, projectId, references: values.references };
+
+    return () => {
+      referencesRef.current = { ...referencesRef.current, live: false };
+    };
+  }, [projectId, values.references]);
+
+  // Chakra's `Field.Root` hands its single `ids.control` to EVERY control
+  // inside it, and this Field holds three. Without an id of its own the
+  // switch's hidden input collides with the seed NumberInput, so the
+  // `<label>` Switch.Root renders points at the seed field: clicking the
+  // toggle focused the seed input and never toggled anything.
+  const seedSwitchId = useId();
+  const seedSwitchIds = useMemo(() => ({ hiddenInput: `${seedSwitchId}-randomize-seed` }), [seedSwitchId]);
+
   useMountEffect(() => {
     void ensureModelsLoaded();
   });
@@ -209,7 +260,6 @@ export const VideoWidgetView = () => {
       cfgScale: (cfgScale: number) => patch({ cfgScale }),
       cfgScaleLowNoise: (cfgScaleLowNoise: number) => patch({ cfgScaleLowNoise }),
       fps: (fps: number) => patch({ fps }),
-      numFrames: (numFrames: number) => patch({ numFrames }),
       randomizeSeed: (details: { checked: boolean }) => patch({ shouldRandomizeSeed: details.checked }),
       seed: ({ valueAsNumber }: NumberInput.ValueChangeDetails) =>
         Number.isFinite(valueAsNumber) && patch({ seed: valueAsNumber }),
@@ -235,24 +285,110 @@ export const VideoWidgetView = () => {
   // video are different ways to claim the same conditioning slot, so setting
   // one clears the other. A last frame combines with either — with a first
   // frame it interpolates (FLF2V); with a source video it is the destination
-  // the extension should land on.
+  // the extension should land on. On a reference-extend panel the initial
+  // video and the references coexist — the setter keeps the linked tail
+  // reference in step with the clip and its cutpoints.
+  const referenceExtend = Boolean(policy.references?.extend);
+  const maxVideoReferences = policy.references?.maxVideos ?? 3;
   const setFirstFrame = useCallback(
     (firstFrameImage: ImageWithDims | null) =>
       patch({ firstFrameImage, ...(firstFrameImage ? { sourceVideo: null } : {}) }),
     [patch]
   );
   const setLastFrame = useCallback((lastFrameImage: ImageWithDims | null) => patch({ lastFrameImage }), [patch]);
+  // Not part of `set`: that object is memoized on `patch` alone so the field
+  // setters keep the children's `memo` intact, and this one has to track the
+  // reference list. The linked tail reference's window is budgeted against the
+  // generated frame count — the backend discards an ill-fitting window at its
+  // SEAM end — so the count and the window move together. The re-derive is
+  // idempotent: this fires once per keystroke of the Frames input, unclamped,
+  // so typing "345" arrives as 3, then 34, then 345.
+  const setNumFrames = useCallback(
+    (numFrames: number) =>
+      patch(
+        referenceExtend && referencesRef.current.live && referencesRef.current.projectId === projectId
+          ? { numFrames, references: applyReferenceExtendNumFrames(referencesRef.current.references, numFrames) }
+          : { numFrames }
+      ),
+    // Reads the list through the ref so the Frames control keeps a stable
+    // prop identity: depending on `values.references` re-created this on every
+    // panel patch, re-rendering the slider against the file's stable-identity
+    // contract. Safe because the re-derive is idempotent in `numFrames`. The
+    // project guard is unreachable for this synchronous caller; it keeps the
+    // ref's contract uniform.
+    [patch, projectId, referenceExtend]
+  );
   const setSourceVideo = useCallback(
-    (sourceVideo: VideoSourceClip | null) => patch({ sourceVideo, ...(sourceVideo ? { firstFrameImage: null } : {}) }),
-    [patch]
+    (sourceVideo: VideoSourceClip | null) => {
+      if (referenceExtend) {
+        // Same guard as `setReferences`: the clip field's adopt and upload
+        // paths call this after an await, and a captured list would clobber a
+        // reference added meanwhile. Dropped when the project moved on or the
+        // sync effect is unmounted — the ref is effect-fresh, not live, and
+        // only vouches for its contents while mounted.
+        if (!referencesRef.current.live || referencesRef.current.projectId !== projectId) {
+          return;
+        }
+        const current = referencesRef.current.references;
+        const references = applyReferenceExtendSourceVideo(current, sourceVideo, maxVideoReferences, values.numFrames);
+
+        // Unchanged identity with a clip set means the video cap is full and
+        // no same-clip entry could be adopted. REFUSE the whole drop: patching
+        // the clip anyway produced an extension with no continuity anchor at
+        // all, behind nothing but a toast -- and the cap gate then froze the
+        // clip's trim sliders. (The gate cannot pre-empt this case: it can
+        // only ask about the clip currently set, and this drop is a different
+        // one.) Clearing is never refused -- removing the linked entry cannot
+        // overflow anything.
+        if (sourceVideo && references === current) {
+          toaster.create({
+            description: t('widgets.video.referenceExtendCapFullDescription'),
+            title: t('widgets.video.referenceExtendCapFull'),
+            type: 'warning',
+          });
+
+          return;
+        }
+        patch({ references, sourceVideo, ...(sourceVideo ? { firstFrameImage: null } : {}) });
+        return;
+      }
+      patch({ sourceVideo, ...(sourceVideo ? { firstFrameImage: null } : {}) });
+    },
+    [maxVideoReferences, patch, projectId, referenceExtend, t, values.numFrames]
   );
+  // The single choke point for every list edit the reference field makes — add,
+  // remove, retrim, reorder — so pinning the continuity anchor here covers all
+  // of them. Request order is rotary order and the generation continues from
+  // the LAST reference, so the anchor's position is derived, not user-set.
   const setReferences = useCallback(
-    (references: VideoReferenceItem[]) =>
+    (update: (current: VideoReferenceItem[]) => VideoReferenceItem[]) => {
+      // A pending edit is DROPPED when the ref cannot vouch for the list:
+      // the project moved on (this callback's `patch` still targets the one
+      // it rendered for), or the sync effect is unmounted (a hidden panel's
+      // continuations would replay a frozen list over whatever the store has
+      // done since). Losing one add beats overwriting a list the user can see.
+      if (!referencesRef.current.live || referencesRef.current.projectId !== projectId) {
+        return;
+      }
+      const updated = update(referencesRef.current.references);
+
+      // Identity return means the updater declined (an apply-time cap check)
+      // or had nothing to do: patching anyway would still fire this spread's
+      // firstFrameImage/lastFrameImage clearing — a refused add erasing frame
+      // slots it never touched — and dirty the project with a no-op write.
+      if (updated === referencesRef.current.references) {
+        return;
+      }
+      const next = referenceExtend ? pinReferenceExtendAnchor(updated) : updated;
+
       patch({
-        references,
-        ...(references.length > 0 ? { firstFrameImage: null, lastFrameImage: null, sourceVideo: null } : {}),
-      }),
-    [patch]
+        references: next,
+        ...(next.length > 0
+          ? { firstFrameImage: null, lastFrameImage: null, ...(referenceExtend ? {} : { sourceVideo: null }) }
+          : {}),
+      });
+    },
+    [patch, projectId, referenceExtend]
   );
   const clearReferences = useCallback(() => patch({ references: [] }), [patch]);
   const setLoras = useCallback(
@@ -321,6 +457,17 @@ export const VideoWidgetView = () => {
   const supportsLastFrame = policy.modes.includes('first-last') || policy.modes.includes('last-frame');
   const supportsExtend = policy.modes.includes('extend');
   const supportsReferences = policy.modes.includes('reference');
+  const supportsInitialVideo = supportsExtend || referenceExtend;
+  // Setting an Initial Video on a reference-extend panel has to place a linked
+  // tail reference, which needs a free video slot -- unless an existing entry
+  // can be adopted, which consumes none. Deferring to the same predicate the
+  // setter's refusal uses keeps the two from drifting: gating on the flag alone
+  // disabled the field after a recall, which restores references UNFLAGGED
+  // beside the source video, and `disabled` reaches the clip's trim sliders too
+  // -- so the cutpoint could not be moved on a clip that was legitimately set.
+  const initialVideoCapBlocked =
+    referenceExtend &&
+    !canPlaceReferenceExtendAnchor(values.references, values.sourceVideo?.video_name, maxVideoReferences);
   const hasConditioningMedia = Boolean(values.firstFrameImage || values.lastFrameImage || values.sourceVideo);
   const derivedSourceText = dimensions ? t(`widgets.video.dimensionSource.${dimensions.source}`) : undefined;
   const derivedSizeText = dimensions
@@ -424,7 +571,7 @@ export const VideoWidgetView = () => {
       {!supportsLastFrame && values.lastFrameImage ? (
         <StaleMediaStub label={t('widgets.video.staleLastFrame')} onClear={clearLastFrame} />
       ) : null}
-      {!supportsExtend && values.sourceVideo ? (
+      {!supportsInitialVideo && values.sourceVideo ? (
         <StaleMediaStub label={t('widgets.video.staleSourceVideo')} onClear={clearSourceVideo} />
       ) : null}
       {!supportsReferences && values.references.length > 0 ? (
@@ -444,12 +591,23 @@ export const VideoWidgetView = () => {
         </GenerationSettingsSection>
       ) : null}
 
-      {supportsExtend ? (
+      {supportsInitialVideo ? (
         <GenerationSettingsSection label={t('widgets.video.initialVideo')} sectionId="video-source" defaultOpen>
           <Stack gap="3" p="2">
+            {referenceExtend ? (
+              <Text color="fg.muted" fontSize="2xs" textWrap="pretty">
+                {t('widgets.video.referenceExtendHelp')}
+              </Text>
+            ) : null}
             <VideoSourceClipField
-              disabled={Boolean(values.firstFrameImage)}
-              disabledReason={values.firstFrameImage ? t('widgets.video.initialVideoBlocked') : undefined}
+              disabled={Boolean(values.firstFrameImage) || initialVideoCapBlocked}
+              disabledReason={
+                values.firstFrameImage
+                  ? t('widgets.video.initialVideoBlocked')
+                  : initialVideoCapBlocked
+                    ? t('widgets.video.initialVideoCapBlocked')
+                    : undefined
+              }
               sourceVideo={values.sourceVideo}
               onChange={setSourceVideo}
             />
@@ -495,7 +653,7 @@ export const VideoWidgetView = () => {
               min={framesSlider.min}
               step={framesSlider.step}
               value={values.numFrames}
-              onChange={set.numFrames}
+              onChange={setNumFrames}
             />
           </Field>
           {policy.ui.fpsVisible ? (
@@ -602,15 +760,22 @@ export const VideoWidgetView = () => {
                 <DicesIcon />
               </IconButton>
               <HStack gap="1">
-                <Switch.Root checked={values.shouldRandomizeSeed} size="sm" onCheckedChange={set.randomizeSeed}>
+                <Switch.Root
+                  checked={values.shouldRandomizeSeed}
+                  ids={seedSwitchIds}
+                  size="sm"
+                  onCheckedChange={set.randomizeSeed}
+                >
                   <Switch.HiddenInput />
                   <Switch.Control _checked={SWITCH_CHECKED_PROPS}>
                     <Switch.Thumb />
                   </Switch.Control>
+                  {/* Inside Switch.Root, so the words are part of the control
+                      (they were an inert sibling <Text> before). */}
+                  <Switch.Label color="fg.muted" fontSize="2xs">
+                    {t('widgets.video.randomizeSeed')}
+                  </Switch.Label>
                 </Switch.Root>
-                <Text color="fg.muted" fontSize="2xs">
-                  {t('widgets.video.randomizeSeed')}
-                </Text>
               </HStack>
             </HStack>
           </Field>
diff --git a/invokeai/frontend/webv2/src/features/video/ui/seedToggle.browser.test.tsx b/invokeai/frontend/webv2/src/features/video/ui/seedToggle.browser.test.tsx
new file mode 100644
index 00000000000..3858afcb66b
--- /dev/null
+++ b/invokeai/frontend/webv2/src/features/video/ui/seedToggle.browser.test.tsx
@@ -0,0 +1,100 @@
+import { ChakraProvider, NumberInput, Switch } from '@chakra-ui/react';
+import { Field } from '@platform/ui/Field';
+import { system } from '@theme/system';
+import { act, useId, useMemo } from 'react';
+import { createRoot, type Root } from 'react-dom/client';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { userEvent } from 'vitest/browser';
+
+/**
+ * The seed row of the Video and Upscale panels puts three controls -- a seed
+ * NumberInput, a shuffle button and a randomize Switch -- inside ONE `Field`.
+ * Chakra's `Field.Root` hands its single `ids.control` to every control it
+ * contains, so without an id of its own the switch's hidden input collides
+ * with the seed input and the `<label>` that `Switch.Root` renders resolves to
+ * the seed field instead. Clicking the toggle then just moved focus.
+ */
+let container: HTMLDivElement;
+let root: Root;
+
+(globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+
+beforeEach(() => {
+  container = document.createElement('div');
+  document.body.append(container);
+  root = createRoot(container);
+});
+
+afterEach(() => {
+  act(() => root.unmount());
+  container.remove();
+});
+
+const SeedRow = ({ onCheckedChange }: { onCheckedChange: (details: { checked: boolean }) => void }) => {
+  const seedSwitchId = useId();
+  const seedSwitchIds = useMemo(() => ({ hiddenInput: `${seedSwitchId}-randomize-seed` }), [seedSwitchId]);
+
+  return (
+    <Field hint="seed" label="Seed">
+      <NumberInput.Root size="xs" value="42">
+        <NumberInput.Input aria-label="Seed" />
+      </NumberInput.Root>
+      <Switch.Root checked={false} ids={seedSwitchIds} size="sm" onCheckedChange={onCheckedChange}>
+        <Switch.HiddenInput data-testid="switch-input" />
+        <Switch.Control data-testid="switch-control">
+          <Switch.Thumb />
+        </Switch.Control>
+        <Switch.Label>Randomize seed</Switch.Label>
+      </Switch.Root>
+    </Field>
+  );
+};
+
+const render = (onCheckedChange: (details: { checked: boolean }) => void) =>
+  act(() => {
+    root.render(
+      <ChakraProvider value={system}>
+        <SeedRow onCheckedChange={onCheckedChange} />
+      </ChakraProvider>
+    );
+  });
+
+describe('seed row randomize switch', () => {
+  it('does not share the Field control id with the seed input', async () => {
+    await render(vi.fn());
+
+    const seed = container.querySelector<HTMLInputElement>('input[aria-label="Seed"]')!;
+    const toggle = container.querySelector<HTMLInputElement>('[data-testid="switch-input"]')!;
+
+    expect(toggle.id).not.toBe('');
+    expect(toggle.id).not.toBe(seed.id);
+    // The label Switch.Root renders must point at the switch, not the seed field.
+    expect(toggle.closest('label')?.getAttribute('for')).toBe(toggle.id);
+  });
+
+  it('toggles when the control is clicked, leaving the seed input unfocused', async () => {
+    const onCheckedChange = vi.fn();
+
+    await render(onCheckedChange);
+    const seed = container.querySelector<HTMLInputElement>('input[aria-label="Seed"]')!;
+
+    await userEvent.click(container.querySelector('[data-testid="switch-control"]')!);
+
+    expect(onCheckedChange).toHaveBeenCalledWith(expect.objectContaining({ checked: true }));
+    expect(document.activeElement).not.toBe(seed);
+  });
+
+  it('toggles when the label text is clicked', async () => {
+    const onCheckedChange = vi.fn();
+
+    await render(onCheckedChange);
+
+    const label = [...container.querySelectorAll('*')].find(
+      (node) => node.textContent === 'Randomize seed' && node.children.length === 0
+    )!;
+
+    await userEvent.click(label);
+
+    expect(onCheckedChange).toHaveBeenCalledWith(expect.objectContaining({ checked: true }));
+  });
+});
diff --git a/invokeai/frontend/webv2/src/workbench/image-actions/executeVideoRecall.ts b/invokeai/frontend/webv2/src/workbench/image-actions/executeVideoRecall.ts
index a38ca9de502..0f968a01f70 100644
--- a/invokeai/frontend/webv2/src/workbench/image-actions/executeVideoRecall.ts
+++ b/invokeai/frontend/webv2/src/workbench/image-actions/executeVideoRecall.ts
@@ -248,7 +248,9 @@ export const executeVideoRecall = async ({
             firstFrameImage: null,
             lastFrameImage: null,
             references,
-            sourceVideo: null,
+            // A source video recorded alongside references is reference-extend
+            // state (hydrated above) — keep it; clear only a leftover.
+            sourceVideo: result.mediaNames.sourceVideoName ? result.values.sourceVideo : null,
           };
           recalledMedia = true;
         }
@@ -267,7 +269,9 @@ export const executeVideoRecall = async ({
       const effectiveModel = result.values.model;
 
       if (effectiveModel) {
-        const modes = getVideoModelPolicy(effectiveModel, result.values).modes;
+        const policy = getVideoModelPolicy(effectiveModel, result.values);
+        const modes = policy.modes;
+        const referenceExtend = Boolean(policy.references?.extend);
         let { firstFrameImage, lastFrameImage, sourceVideo } = result.values;
         let references = result.values.references;
 
@@ -276,13 +280,16 @@ export const executeVideoRecall = async ({
           references = [];
         }
         if (references.length > 0) {
-          // References replace the frame/source slots entirely.
+          // References replace the frame slots; the source video survives only
+          // on a reference-extend panel (the new clip is appended to it).
           firstFrameImage = null;
           lastFrameImage = null;
-          sourceVideo = null;
+          if (!referenceExtend) {
+            sourceVideo = null;
+          }
         }
 
-        if (sourceVideo && !modes.includes('extend')) {
+        if (sourceVideo && !modes.includes('extend') && !(references.length > 0 && referenceExtend)) {
           sourceVideo = null;
         }
         if (firstFrameImage && !modes.includes('first-frame') && !modes.includes('first-last')) {
diff --git a/invokeai/frontend/webv2/src/workbench/image-actions/galleryOptimisticRollback.test.ts b/invokeai/frontend/webv2/src/workbench/image-actions/galleryOptimisticRollback.test.ts
index a9142bc4596..71b746de6c3 100644
--- a/invokeai/frontend/webv2/src/workbench/image-actions/galleryOptimisticRollback.test.ts
+++ b/invokeai/frontend/webv2/src/workbench/image-actions/galleryOptimisticRollback.test.ts
@@ -217,6 +217,43 @@ describe('gallery optimistic rollback against the real reducer', () => {
     expect(getProjectWidgetValues(getProject(restored, projectId), 'gallery').selectedImage).toEqual(galleryItem);
   });
 
+  it('restores swept references even when an initial video occupies the panel (reference-extend pair)', () => {
+    // sourceVideo <-> references is a LEGAL pair on a Ref2VA reference-extend
+    // panel; treating them as rivals made a failed deletion permanently drop
+    // the reference the sweep removed.
+    const seeded = seedProjectWithItem();
+    const projectId = seeded.projectId;
+    const sourceClip = {
+      endFrame: 79,
+      fps: 16,
+      height: 480,
+      numFrames: 81,
+      startFrame: 0,
+      video_name: 'clip.mp4',
+      width: 832,
+    };
+    const imageReference = { detail: 'max', image: { height: 480, image_name: 'a.png', width: 832 }, kind: 'image' };
+    const state = workbenchReducer(seeded.state, {
+      projectId,
+      type: 'patchWidgetValues',
+      values: { references: [imageReference], sourceVideo: sourceClip },
+      widgetId: 'video',
+    });
+
+    const before = captureGalleryWidgetKeyValues(state.projects);
+    const afterRemoval = workbenchReducer(state, { itemKeys: ['image:a.png'], type: 'removeGalleryItems' });
+
+    expect(getProjectWidgetValues(getProject(afterRemoval, projectId), 'video').references).toEqual([]);
+
+    const entries = diffGalleryWidgetKeyValues(before, afterRemoval.projects);
+    const patches = selectRestorableGalleryWidgetPatches(entries, afterRemoval.projects);
+    const restored = applyRestorePatches(afterRemoval, patches);
+    const videoValues = getProjectWidgetValues(getProject(restored, projectId), 'video');
+
+    expect(videoValues.references).toEqual([imageReference]);
+    expect(videoValues.sourceVideo).toEqual(sourceClip);
+  });
+
   it('still restores a cleared video slot when its rival stayed empty', () => {
     const seeded = seedProjectWithItem();
     const projectId = seeded.projectId;
diff --git a/invokeai/frontend/webv2/src/workbench/image-actions/galleryOptimisticRollback.ts b/invokeai/frontend/webv2/src/workbench/image-actions/galleryOptimisticRollback.ts
index e3790d83092..c80abc882cd 100644
--- a/invokeai/frontend/webv2/src/workbench/image-actions/galleryOptimisticRollback.ts
+++ b/invokeai/frontend/webv2/src/workbench/image-actions/galleryOptimisticRollback.ts
@@ -51,10 +51,12 @@ const EXCLUSIVE_RIVAL_FIELDS: ReadonlyArray<{ key: string; rivalKey: string; wid
   { key: 'firstFrameImage', rivalKey: 'references', widgetId: 'video' },
   { key: 'lastFrameImage', rivalKey: 'references', widgetId: 'video' },
   { key: 'sourceVideo', rivalKey: 'firstFrameImage', widgetId: 'video' },
-  { key: 'sourceVideo', rivalKey: 'references', widgetId: 'video' },
   { key: 'references', rivalKey: 'firstFrameImage', widgetId: 'video' },
   { key: 'references', rivalKey: 'lastFrameImage', widgetId: 'video' },
-  { key: 'references', rivalKey: 'sourceVideo', widgetId: 'video' },
+  // sourceVideo <-> references is deliberately NOT a rival pair: the two
+  // coexist on a Ref2VA reference-extend panel, and normalization keeps both
+  // (validation owns rejecting the pair per model). Treating them as rivals
+  // made a FAILED gallery deletion permanently drop the other slot's value.
 ];
 
 const trackedFieldKey = (projectId: string, widgetId: WidgetTypeId, key: string): string =>
diff --git a/invokeai/frontend/webv2/src/workbench/image-actions/videoRecall.test.ts b/invokeai/frontend/webv2/src/workbench/image-actions/videoRecall.test.ts
index 0a2d9eed76b..f70e8b2d6c7 100644
--- a/invokeai/frontend/webv2/src/workbench/image-actions/videoRecall.test.ts
+++ b/invokeai/frontend/webv2/src/workbench/image-actions/videoRecall.test.ts
@@ -575,4 +575,29 @@ describe('model-position recall shapes', () => {
     expect(result?.values.model?.key).toBe(install.key);
     expect(result?.values.h3TransformerModel).toBeNull();
   });
+
+  it('reports the source video alongside the references for a reference-extend recording', () => {
+    const result = buildVideoRecallSettings({
+      currentValues,
+      kind: 'all',
+      metadata: {
+        generation_mode: 'minimax_h3_ref2v',
+        minimax_h3_component_source: { key: install.key },
+        minimax_h3_references: [
+          { conditioning: 'video_audio', end_frame: 400, kind: 'video', start_frame: 260, video_name: 'long.mp4' },
+        ],
+        model: { key: checkpoint.key },
+        num_frames: 124,
+        source_video: { video_name: 'long.mp4' },
+        source_video_end_frame: 400,
+        source_video_start_frame: 10,
+      },
+      models: catalog,
+    });
+
+    expect(result?.fields).toContain('media');
+    expect(result?.mediaNames.references).toHaveLength(1);
+    expect(result?.mediaNames.sourceVideoName).toBe('long.mp4');
+    expect(result?.mediaNames.sourceVideoTrim).toEqual({ endFrame: 400, startFrame: 10 });
+  });
 });
diff --git a/invokeai/frontend/webv2/src/workbench/image-actions/videoRecall.ts b/invokeai/frontend/webv2/src/workbench/image-actions/videoRecall.ts
index a619a7ae083..b4925b468d2 100644
--- a/invokeai/frontend/webv2/src/workbench/image-actions/videoRecall.ts
+++ b/invokeai/frontend/webv2/src/workbench/image-actions/videoRecall.ts
@@ -626,8 +626,16 @@ export const buildVideoRecallSettings = ({
   }
 
   if (references.length > 0) {
-    // References replace every frame/source slot — the modes are mutually exclusive.
+    // References replace the frame slots, but a recorded source video rides
+    // ALONGSIDE them: Ref2VA reference-extend appends the new clip to it.
     mediaNames.references = references;
+    if (media.sourceVideoName) {
+      const startFrame = getInteger(metadata, 'source_video_start_frame');
+      const endFrame = getInteger(metadata, 'source_video_end_frame');
+
+      mediaNames.sourceVideoName = media.sourceVideoName;
+      mediaNames.sourceVideoTrim = startFrame !== null && endFrame !== null ? { endFrame, startFrame } : null;
+    }
     fields.push('media');
   } else if (media.firstFrameName || media.lastFrameName || media.sourceVideoName) {
     mediaNames.firstFrameName = media.firstFrameName;