diff --git a/invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/autoSwitchedSelection.test.ts b/invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/autoSwitchedSelection.test.ts
new file mode 100644
index 00000000000..54c1ff2bde2
--- /dev/null
+++ b/invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/autoSwitchedSelection.test.ts
@@ -0,0 +1,73 @@
+import { configureStore, createListenerMiddleware } from '@reduxjs/toolkit';
+import type { AppStartListening } from 'app/store/store';
+import { autoSwitchedImages } from 'features/gallery/store/autoSwitchedImages';
+import {
+  boardIdSelected,
+  gallerySliceConfig,
+  imageSelected,
+  selectionChanged,
+} from 'features/gallery/store/gallerySlice';
+import { beforeEach, describe, expect, it } from 'vitest';
+
+import { addAutoSwitchedSelectionListener } from './autoSwitchedSelection';
+
+// A store with the real gallery reducer and the real listener, so the predicate is exercised
+// against actual selection-writing actions rather than a hand-built state pair.
+const buildStore = () => {
+  const listenerMiddleware = createListenerMiddleware();
+  addAutoSwitchedSelectionListener(listenerMiddleware.startListening as unknown as AppStartListening);
+  return configureStore({
+    reducer: { gallery: gallerySliceConfig.slice.reducer },
+    middleware: (getDefaultMiddleware) => getDefaultMiddleware().prepend(listenerMiddleware.middleware),
+  });
+};
+
+describe('addAutoSwitchedSelectionListener', () => {
+  beforeEach(() => {
+    // The marker is a module singleton; drop anything a previous test left on it.
+    autoSwitchedImages.settle(null);
+  });
+
+  it('keeps the marker when the auto-switch selection lands', () => {
+    const store = buildStore();
+    autoSwitchedImages.record('a.png');
+    store.dispatch(imageSelected('a.png'));
+    expect(autoSwitchedImages.consume('a.png')).toBe(true);
+  });
+
+  it('drops the marker once the user selects something else', () => {
+    // The dead click this exists to prevent: the auto-switch to A never rendered because the user
+    // clicked B first, so their later click on A must still get its reveal.
+    const store = buildStore();
+    autoSwitchedImages.record('a.png');
+    store.dispatch(imageSelected('a.png'));
+    store.dispatch(imageSelected('b.png'));
+    store.dispatch(imageSelected('a.png'));
+    expect(autoSwitchedImages.consume('a.png')).toBe(false);
+  });
+
+  it('settles on every action that writes the selection, not just imageSelected', () => {
+    const store = buildStore();
+
+    autoSwitchedImages.record('a.png');
+    store.dispatch(imageSelected('a.png'));
+    store.dispatch(selectionChanged(['b.png']));
+    expect(autoSwitchedImages.consume('a.png')).toBe(false);
+
+    autoSwitchedImages.record('c.png');
+    store.dispatch(imageSelected('c.png'));
+    store.dispatch(boardIdSelected({ boardId: 'other', select: { selection: ['d.png'], galleryView: 'images' } }));
+    expect(autoSwitchedImages.consume('c.png')).toBe(false);
+  });
+
+  it('leaves the marker alone when an action does not move the selection', () => {
+    const store = buildStore();
+    autoSwitchedImages.record('a.png');
+    store.dispatch(imageSelected('a.png'));
+    // Selecting the same item again, and a board switch that carries no selection, must not
+    // discard a marker whose image has not rendered yet.
+    store.dispatch(imageSelected('a.png'));
+    store.dispatch(boardIdSelected({ boardId: 'other' }));
+    expect(autoSwitchedImages.consume('a.png')).toBe(true);
+  });
+});
diff --git a/invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/autoSwitchedSelection.ts b/invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/autoSwitchedSelection.ts
new file mode 100644
index 00000000000..0b14616f0b3
--- /dev/null
+++ b/invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/autoSwitchedSelection.ts
@@ -0,0 +1,27 @@
+import type { AppStartListening } from 'app/store/store';
+import { autoSwitchedImages } from 'features/gallery/store/autoSwitchedImages';
+import { selectLastSelectedItem } from 'features/gallery/store/gallerySelectors';
+
+/**
+ * Keeps the auto-switch marker scoped to the selection it was recorded for.
+ *
+ * onInvocationComplete records the item it is about to auto-switch to, so the viewer's reveal
+ * effect can tell that handoff apart from a user's gallery click. The marker is only meaningful
+ * while that selection stands: once the selection moves on, the recorded auto-switch will never
+ * render, and leaving the marker behind would make the user's next click on that item read as an
+ * auto-switch and get no reveal.
+ *
+ * Matched by state rather than by action type on purpose — the selection is written by several
+ * reducers (imageSelected, selectionChanged, boardIdSelected, comparedImagesSwapped,
+ * showVirtualBoardsChanged, logout), and a new one added later would silently escape an
+ * action-type list, leaving exactly the stale marker this exists to prevent.
+ */
+export const addAutoSwitchedSelectionListener = (startAppListening: AppStartListening) => {
+  startAppListening({
+    predicate: (_action, currentState, previousState) =>
+      selectLastSelectedItem(currentState) !== selectLastSelectedItem(previousState),
+    effect: (_action, { getState }) => {
+      autoSwitchedImages.settle(selectLastSelectedItem(getState()) ?? null);
+    },
+  });
+};
diff --git a/invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/boardIdSelected.test.ts b/invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/boardIdSelected.test.ts
new file mode 100644
index 00000000000..f457fac2280
--- /dev/null
+++ b/invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/boardIdSelected.test.ts
@@ -0,0 +1,60 @@
+import { configureStore, createListenerMiddleware } from '@reduxjs/toolkit';
+import type { AppStartListening } from 'app/store/store';
+import { gallerySliceConfig, galleryViewChanged, imageSelected } from 'features/gallery/store/gallerySlice';
+import { api } from 'services/api';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { addBoardIdSelectedListener } from './boardIdSelected';
+
+// The listener waits for the board's item list before auto-selecting, so the store needs the API
+// slice present (the query is never fulfilled here — the point is what happens meanwhile).
+const buildStore = () => {
+  const listenerMiddleware = createListenerMiddleware();
+  addBoardIdSelectedListener(listenerMiddleware.startListening as unknown as AppStartListening);
+  return configureStore({
+    reducer: {
+      gallery: gallerySliceConfig.slice.reducer,
+      [api.reducerPath]: api.reducer,
+    },
+    middleware: (getDefaultMiddleware) =>
+      getDefaultMiddleware({ serializableCheck: false }).prepend(listenerMiddleware.middleware),
+  });
+};
+
+describe('addBoardIdSelectedListener', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('does not overwrite a selection made while it was waiting for the board list', async () => {
+    // The gallery's auto-switch dispatches galleryViewChanged immediately before imageSelected.
+    // Without the cancel, the probe this starts wakes up on that very selection and re-selects
+    // from a stale (or empty) list, undoing the auto-switch — and the viewer then reveals the
+    // wrong item over the live preview, the flash the auto-switch marker exists to prevent.
+    const store = buildStore();
+
+    store.dispatch(galleryViewChanged('images'));
+    store.dispatch(imageSelected('new.png'));
+
+    // Past the probe's 5s give-up, which would otherwise clear the selection outright.
+    await vi.advanceTimersByTimeAsync(6000);
+
+    expect(store.getState().gallery.selection).toEqual(['new.png']);
+  });
+
+  it('still clears the selection when a board switch finds nothing to show', async () => {
+    // The auto-select probe itself must keep working: a board change with no items selects
+    // nothing rather than leaving the previous board's item highlighted.
+    const store = buildStore();
+    store.dispatch(imageSelected('from-previous-board.png'));
+
+    store.dispatch(galleryViewChanged('assets'));
+    await vi.advanceTimersByTimeAsync(6000);
+
+    expect(store.getState().gallery.selection).toEqual([]);
+  });
+});
diff --git a/invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/boardIdSelected.ts b/invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/boardIdSelected.ts
index 05dd8e9f208..588b39881a8 100644
--- a/invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/boardIdSelected.ts
+++ b/invokeai/frontend/web/src/app/store/middleware/listenerMiddleware/listeners/boardIdSelected.ts
@@ -6,11 +6,22 @@ import { galleryApi } from 'services/api/endpoints/gallery';
 
 export const addBoardIdSelectedListener = (startAppListening: AppStartListening) => {
   startAppListening({
-    matcher: isAnyOf(boardIdSelected, galleryViewChanged),
+    matcher: isAnyOf(boardIdSelected, galleryViewChanged, imageSelected),
     effect: async (action, { getState, dispatch, condition, cancelActiveListeners }) => {
       // Cancel any in-progress instances of this listener, we don't want to select an item from a previous board
       cancelActiveListeners();
 
+      if (imageSelected.match(action)) {
+        // An explicit selection settles what should be displayed, so a probe still waiting on a
+        // board's items must not overwrite it when it resolves. The gallery's auto-switch dispatches
+        // galleryViewChanged immediately before imageSelected: without this the probe that view
+        // change starts wakes on the selection that follows it, re-selects the first name in a
+        // possibly stale cached list, and undoes the switch — and the viewer then reveals that
+        // wrong image over the live preview, which is the flash the auto-switch marker exists to
+        // prevent. Cancelling above is the whole effect; there is nothing to auto-select here.
+        return;
+      }
+
       if (boardIdSelected.match(action) && action.payload.select) {
         // This action already has a resource selection - skip the below auto-selection logic
         return;
diff --git a/invokeai/frontend/web/src/app/store/store.ts b/invokeai/frontend/web/src/app/store/store.ts
index 59551225314..7ea4ffbf45c 100644
--- a/invokeai/frontend/web/src/app/store/store.ts
+++ b/invokeai/frontend/web/src/app/store/store.ts
@@ -12,6 +12,7 @@ import { errorHandler } from 'app/store/enhancers/reduxRemember/errors';
 import { addAdHocPostProcessingRequestedListener } from 'app/store/middleware/listenerMiddleware/listeners/addAdHocPostProcessingRequestedListener';
 import { addAnyEnqueuedListener } from 'app/store/middleware/listenerMiddleware/listeners/anyEnqueued';
 import { addAppStartedListener } from 'app/store/middleware/listenerMiddleware/listeners/appStarted';
+import { addAutoSwitchedSelectionListener } from 'app/store/middleware/listenerMiddleware/listeners/autoSwitchedSelection';
 import { addBatchEnqueuedListener } from 'app/store/middleware/listenerMiddleware/listeners/batchEnqueued';
 import { addDeleteBoardAndImagesFulfilledListener } from 'app/store/middleware/listenerMiddleware/listeners/boardAndImagesDeleted';
 import { addBoardIdSelectedListener } from 'app/store/middleware/listenerMiddleware/listeners/boardIdSelected';
@@ -326,6 +327,7 @@ addImageAddedToBoardFulfilledListener(startAppListening);
 addImageRemovedFromBoardFulfilledListener(startAppListening);
 addBoardIdSelectedListener(startAppListening);
 addArchivedOrDeletedBoardListener(startAppListening);
+addAutoSwitchedSelectionListener(startAppListening);
 
 // Node schemas
 addGetOpenAPISchemaListener(startAppListening);
diff --git a/invokeai/frontend/web/src/features/gallery/components/ImageViewer/CurrentImagePreview.tsx b/invokeai/frontend/web/src/features/gallery/components/ImageViewer/CurrentImagePreview.tsx
index ba76ca299bb..dc8331ba74e 100644
--- a/invokeai/frontend/web/src/features/gallery/components/ImageViewer/CurrentImagePreview.tsx
+++ b/invokeai/frontend/web/src/features/gallery/components/ImageViewer/CurrentImagePreview.tsx
@@ -6,6 +6,7 @@ import { DndImage } from 'features/dnd/DndImage';
 import ImageMetadataViewer from 'features/gallery/components/ImageMetadataViewer/ImageMetadataViewer';
 import NextPrevItemButtons from 'features/gallery/components/NextPrevItemButtons';
 import { useNextPrevItemNavigation } from 'features/gallery/components/useNextPrevItemNavigation';
+import { autoSwitchedImages } from 'features/gallery/store/autoSwitchedImages';
 import { selectLastSelectedItem } from 'features/gallery/store/gallerySelectors';
 import { useRegisteredHotkeys } from 'features/system/components/HotkeysModal/useHotkeyData';
 import { navigationApi } from 'features/ui/layouts/navigation-api';
@@ -19,11 +20,12 @@ import { AnimatePresence, motion } from 'framer-motion';
 import { memo, useCallback, useEffect, useRef, useState } from 'react';
 import type { ImageDTO } from 'services/api/types';
 
-import { useImageViewerContext } from './context';
+import { SELECTED_ITEM_REVEAL_DURATION_MS, useImageViewerContext } from './context';
 import { NoContentForViewer } from './NoContentForViewer';
 import { ProgressImage } from './ProgressImage2';
 import { ProgressImageTiles } from './ProgressImageTiles';
 import { ProgressIndicator } from './ProgressIndicator2';
+import { createSelectedItemRevealController } from './selectedItemReveal';
 
 export const CurrentImagePreview = memo(({ imageDTO }: { imageDTO: ImageDTO | null }) => {
   const activeTab = useAppSelector(selectActiveTab);
@@ -38,6 +40,7 @@ export const CurrentImagePreview = memo(({ imageDTO }: { imageDTO: ImageDTO | nu
     $activeProgressData,
     $isProgressImageResolving,
     $isTemporarilyShowingSelectedImage,
+    lastRenderedItemNameRef,
   } = useImageViewerContext();
   const progressEvent = useStore($progressEvent);
   const progressImage = useStore($progressImage);
@@ -45,8 +48,16 @@ export const CurrentImagePreview = memo(({ imageDTO }: { imageDTO: ImageDTO | nu
   const isProgressImageResolving = useStore($isProgressImageResolving);
   const isTemporarilyShowingSelectedImage = useStore($isTemporarilyShowingSelectedImage);
   const [imageToRender, setImageToRender] = useState<ImageDTO | null>(null);
-  const previousRenderedImageNameRef = useRef<string | null>(null);
-  const selectedImageRevealTimeoutId = useRef(0);
+  // One controller per mounted preview component; the previous-item ref inside it is the shared
+  // one from the viewer context, so image <-> video clicks read as selection changes on both ends.
+  const [revealController] = useState(() =>
+    createSelectedItemRevealController({
+      lastRenderedItemNameRef,
+      marker: autoSwitchedImages,
+      setRevealed: (revealed) => $isTemporarilyShowingSelectedImage.set(revealed),
+      durationMs: SELECTED_ITEM_REVEAL_DURATION_MS,
+    })
+  );
 
   useEffect(() => {
     if (!selectedImageName) {
@@ -91,41 +102,24 @@ export const CurrentImagePreview = memo(({ imageDTO }: { imageDTO: ImageDTO | nu
 
   const hasProgressImage = progressImage !== null;
 
+  // The reveal sequencing (previous-item tracking, auto-switch suppression, resolve-window
+  // deferral, StrictMode re-arm) lives in the controller — see selectedItemReveal.ts.
   useEffect(() => {
-    const renderedImageName = imageToRender?.image_name ?? null;
-    const previousRenderedImageName = previousRenderedImageNameRef.current;
-    previousRenderedImageNameRef.current = renderedImageName;
-
-    window.clearTimeout(selectedImageRevealTimeoutId.current);
-
-    if (
-      !shouldShowProgressInViewer ||
-      !hasProgressImage ||
-      isProgressImageResolving ||
-      !renderedImageName ||
-      renderedImageName !== selectedImageName
-    ) {
-      $isTemporarilyShowingSelectedImage.set(false);
-      return;
-    }
-
-    if (previousRenderedImageName === null || previousRenderedImageName === renderedImageName) {
-      return;
-    }
-
-    $isTemporarilyShowingSelectedImage.set(true);
-    selectedImageRevealTimeoutId.current = window.setTimeout(() => {
-      $isTemporarilyShowingSelectedImage.set(false);
-    }, SELECTED_IMAGE_REVEAL_DURATION_MS);
-
+    revealController.run({
+      shouldShowProgressInViewer,
+      hasProgressImage,
+      isProgressImageResolving,
+      renderedItemName: imageToRender?.image_name ?? null,
+      selectedItemName: selectedImageName ?? null,
+    });
     return () => {
-      window.clearTimeout(selectedImageRevealTimeoutId.current);
+      revealController.clearTimer();
     };
   }, [
-    $isTemporarilyShowingSelectedImage,
     hasProgressImage,
     imageToRender?.image_name,
     isProgressImageResolving,
+    revealController,
     selectedImageName,
     shouldShowProgressInViewer,
   ]);
@@ -237,7 +231,11 @@ export const CurrentImagePreview = memo(({ imageDTO }: { imageDTO: ImageDTO | nu
       <Flex flexDir="column" gap={2} position="absolute" top={0} insetInlineStart={0} alignItems="flex-start">
         <CanvasAlertsInvocationProgress />
       </Flex>
-      {shouldShowItemDetails && imageToRender && !withProgress && (
+      {/* Gated on the reveal state itself, not only on !withProgress (which the reveal turns
+          off): the reveal exists to make a mid-render click visibly land, and the full-screen
+          metadata panel would drop exactly on top of the just-revealed image for the whole
+          window. Mirrors CurrentVideoPreview's gate. */}
+      {shouldShowItemDetails && imageToRender && !isTemporarilyShowingSelectedImage && !withProgress && (
         <Box position="absolute" opacity={0.8} top={0} width="full" height="full" borderRadius="base">
           <ImageMetadataViewer image={imageToRender} />
         </Box>
@@ -277,5 +275,3 @@ const exit: AnimationProps['exit'] = {
   opacity: 0,
   transition: { duration: 0.07 },
 };
-
-const SELECTED_IMAGE_REVEAL_DURATION_MS = 2000;
diff --git a/invokeai/frontend/web/src/features/gallery/components/ImageViewer/CurrentVideoPreview.test.ts b/invokeai/frontend/web/src/features/gallery/components/ImageViewer/CurrentVideoPreview.test.ts
index 9a22e8cc321..86380c42c96 100644
--- a/invokeai/frontend/web/src/features/gallery/components/ImageViewer/CurrentVideoPreview.test.ts
+++ b/invokeai/frontend/web/src/features/gallery/components/ImageViewer/CurrentVideoPreview.test.ts
@@ -11,3 +11,72 @@ describe('CurrentVideoPreview playback errors', () => {
     expect(source).toContain('onError={handleVideoError}');
   });
 });
+
+describe('CurrentVideoPreview progress overlay', () => {
+  const source = readFileSync(fileURLToPath(new URL('./CurrentVideoPreview.tsx', import.meta.url)), 'utf8');
+
+  it('lifts the overlay during the temporary reveal so mid-render thumbnail clicks visibly land', () => {
+    // The overlay must consult the shared reveal atom (and never re-cover an actively-playing
+    // video) — an unconditional overlay swallows every gallery click for the whole render.
+    expect(source).toMatch(
+      /withProgress =\s+shouldShowProgressInViewer && hasProgressImage && !isTemporarilyShowingSelectedImage && !isPlaying/
+    );
+    expect(source).toContain('SELECTED_ITEM_REVEAL_DURATION_MS');
+    // The previous-item ref handed to the reveal controller must be the shared one from the
+    // viewer context, so image -> video clicks still read as a selection change after the
+    // preview component swaps.
+    expect(source).toMatch(/createSelectedItemRevealController\(\{\s+lastRenderedItemNameRef,/);
+  });
+
+  it('tiles concurrent sessions instead of letting them overwrite each other (multi-GPU)', () => {
+    // CurrentImagePreview tiles per-session previews when several renders run at once; the video
+    // overlay must do the same or the sessions fight over the single full-size preview slot.
+    expect(source).toMatch(/withTiledProgress = withProgress && activeProgressData\.length > 1/);
+    expect(source).toContain('<ProgressImageTiles data={activeProgressData} />');
+  });
+
+  it('routes the reveal decision through the shared controller with the auto-switch marker', () => {
+    // The auto-switch selection lands after onInvocationComplete's DTO fetch, so a quickly-started
+    // next render's first progress event can reset $isProgressImageResolving ahead of it. Timing
+    // cannot tell that handoff from a gallery click; the marker can, and the controller owns the
+    // full sequencing (marker consumption, resolve-window deferral, StrictMode re-arm — see
+    // selectedItemReveal.test.ts for the behavior).
+    expect(source).toMatch(/marker: autoSwitchedImages,/);
+    expect(source).toMatch(/revealController\.run\(\{/);
+    expect(source).toMatch(/isProgressImageResolving,\s+renderedItemName: videoName,/);
+    // The effect cleanup must only cancel the timer — the next run (or the unmount handler below)
+    // owns the revealed flag.
+    expect(source).toMatch(/return \(\) => \{\s+revealController\.clearTimer\(\);\s+\};/);
+  });
+
+  it('does not cover playback or a temporary reveal with the metadata panel', () => {
+    // Playing and revealing both turn withProgress off, so gating the full-screen metadata panel
+    // on !withProgress alone drops it exactly on top of the native controls / the just-revealed
+    // video whenever item details are enabled.
+    expect(source).toMatch(
+      /shouldShowItemDetails && !isPlaying && !isTemporarilyShowingSelectedImage && !withProgress &&/
+    );
+  });
+
+  it('restores the overlay when playback ends on its own, not only when the player is closed', () => {
+    // isPlaying suppresses the overlay; without onEnded it never falls back, so the live preview
+    // stays hidden for the rest of the generation after a short video plays out.
+    expect(source).toContain('onEnded={handleClose}');
+  });
+
+  it('does not end a pending resolve when play() is rejected', () => {
+    // A rejected play() is not a load failure — the element is intact and its metadata has usually
+    // already loaded — so it must not clear an overlay belonging to some other session's render.
+    const playHandler = source.slice(source.indexOf('const handlePlay'), source.indexOf('const handleClose'));
+    expect(playHandler).toContain('reportPlaybackFailure()');
+    expect(playHandler).not.toContain('onLoadImage');
+  });
+
+  it('ends a pending post-render resolve when the video element errors', () => {
+    // onLoadedMetadata normally ends the resolve illusion; an errored element never fires it. The
+    // call must carry this video's session id so the lifecycle can tell it apart from a late load
+    // belonging to another concurrently-completed session.
+    const errorHandler = source.slice(source.indexOf('const handleVideoError'), source.indexOf('const handlePlay'));
+    expect(errorHandler).toContain('onLoadImage(videoDTO?.session_id ?? null)');
+  });
+});
diff --git a/invokeai/frontend/web/src/features/gallery/components/ImageViewer/CurrentVideoPreview.tsx b/invokeai/frontend/web/src/features/gallery/components/ImageViewer/CurrentVideoPreview.tsx
index 19aacb1944b..59983190089 100644
--- a/invokeai/frontend/web/src/features/gallery/components/ImageViewer/CurrentVideoPreview.tsx
+++ b/invokeai/frontend/web/src/features/gallery/components/ImageViewer/CurrentVideoPreview.tsx
@@ -13,7 +13,12 @@ import { dndInputFix } from 'features/dnd/util';
 import VideoMetadataViewer from 'features/gallery/components/ImageMetadataViewer/VideoMetadataViewer';
 import NextPrevItemButtons from 'features/gallery/components/NextPrevItemButtons';
 import { useNextPrevItemNavigation } from 'features/gallery/components/useNextPrevItemNavigation';
-import { selectSelectedBoardId, selectSelection } from 'features/gallery/store/gallerySelectors';
+import { autoSwitchedImages } from 'features/gallery/store/autoSwitchedImages';
+import {
+  selectLastSelectedItem,
+  selectSelectedBoardId,
+  selectSelection,
+} from 'features/gallery/store/gallerySelectors';
 import { isVideoName } from 'features/gallery/store/types';
 import { useRegisteredHotkeys } from 'features/system/components/HotkeysModal/useHotkeyData';
 import { toast } from 'features/toast/toast';
@@ -30,10 +35,12 @@ import { useTranslation } from 'react-i18next';
 import { PiArrowSquareOutBold, PiCopyBold, PiDownloadSimpleBold, PiTrashSimpleBold, PiXBold } from 'react-icons/pi';
 import type { VideoDTO } from 'services/api/types';
 
-import { useImageViewerContext } from './context';
+import { SELECTED_ITEM_REVEAL_DURATION_MS, useImageViewerContext } from './context';
 import { NoContentForViewer } from './NoContentForViewer';
 import { ProgressImage } from './ProgressImage2';
+import { ProgressImageTiles } from './ProgressImageTiles';
 import { ProgressIndicator } from './ProgressIndicator2';
+import { createSelectedItemRevealController } from './selectedItemReveal';
 import { VideoPlayButtonOverlay } from './VideoPlayButtonOverlay';
 
 type Props = {
@@ -57,6 +64,8 @@ type Props = {
  * appear on top of the previously-loaded video. Without this, a freshly generated render's
  * progress images had nowhere to display whenever a video was the last-selected gallery
  * item (and the user only saw the static first-frame still until the new video finished).
+ * Also mirrors its temporary reveal: clicking a gallery thumbnail mid-render lifts the
+ * overlay briefly so the click visibly lands, then the live preview returns.
  */
 export const CurrentVideoPreview = memo(({ videoDTO }: Props) => {
   const videoUrl = useMediaUrl(videoDTO?.video_url);
@@ -71,17 +80,81 @@ export const CurrentVideoPreview = memo(({ videoDTO }: Props) => {
   const deleteVideoModal = useDeleteVideoModalApi();
   const { downloadItem } = useDownloadItem();
   const clipboard = useClipboard();
-  const { $progressEvent, $progressImage, onLoadImage } = useImageViewerContext();
+  const {
+    $progressEvent,
+    $progressImage,
+    $activeProgressData,
+    $isProgressImageResolving,
+    $isTemporarilyShowingSelectedImage,
+    lastRenderedItemNameRef,
+    onLoadImage,
+  } = useImageViewerContext();
   const progressEvent = useStore($progressEvent);
   const progressImage = useStore($progressImage);
-  const withProgress = shouldShowProgressInViewer && progressImage !== null;
+  const activeProgressData = useStore($activeProgressData);
+  const isProgressImageResolving = useStore($isProgressImageResolving);
+  const isTemporarilyShowingSelectedImage = useStore($isTemporarilyShowingSelectedImage);
+  const hasProgressImage = progressImage !== null;
+  // `!isPlaying`: a reveal exposes the play button, and an explicit play is a stronger signal than
+  // the click that triggered the reveal — never re-cover an actively-playing video with the opaque
+  // overlay (its audio would keep running underneath, with the controls unreachable). The overlay
+  // returns when playback ends — whether the user closes the player or the video runs out.
+  const withProgress =
+    shouldShowProgressInViewer && hasProgressImage && !isTemporarilyShowingSelectedImage && !isPlaying;
+  // When more than one session is generating concurrently (multi-GPU), tile their previews instead
+  // of letting the sessions overwrite each other's full-size preview. Mirrors CurrentImagePreview.
+  const withTiledProgress = withProgress && activeProgressData.length > 1;
   const { goToPreviousImage, goToNextImage, isFetching } = useNextPrevItemNavigation();
+  const selectedItemName = useAppSelector(selectLastSelectedItem);
+  // One controller per mounted preview component; the previous-item ref inside it is the shared
+  // one from the viewer context, so image <-> video clicks read as selection changes on both ends.
+  const [revealController] = useState(() =>
+    createSelectedItemRevealController({
+      lastRenderedItemNameRef,
+      marker: autoSwitchedImages,
+      setRevealed: (revealed) => $isTemporarilyShowingSelectedImage.set(revealed),
+      durationMs: SELECTED_ITEM_REVEAL_DURATION_MS,
+    })
+  );
 
   // Whenever the selected video changes, drop back to the idle still + play overlay.
   useEffect(() => {
     setIsPlaying(false);
   }, [videoName]);
 
+  // Mid-generation gallery clicks: mirror CurrentImagePreview's temporary reveal. Without this,
+  // the opaque progress overlay swallows every video-thumbnail click for the whole render — the
+  // selection changes underneath, but nothing visibly happens. Unlike the image path there is no
+  // preload step: the <video> renders immediately (first frame paints when metadata arrives), so
+  // the reveal is keyed directly off the rendered video name. The sequencing (previous-item
+  // tracking, auto-switch suppression, resolve-window deferral, StrictMode re-arm) lives in the
+  // controller — see selectedItemReveal.ts.
+  useEffect(() => {
+    revealController.run({
+      shouldShowProgressInViewer,
+      hasProgressImage,
+      isProgressImageResolving,
+      renderedItemName: videoName,
+      selectedItemName: selectedItemName ?? null,
+    });
+    return () => {
+      revealController.clearTimer();
+    };
+  }, [
+    hasProgressImage,
+    isProgressImageResolving,
+    revealController,
+    selectedItemName,
+    shouldShowProgressInViewer,
+    videoName,
+  ]);
+
+  useEffect(() => {
+    return () => {
+      $isTemporarilyShowingSelectedImage.set(false);
+    };
+  }, [$isTemporarilyShowingSelectedImage]);
+
   // Register the viewer's <video> as a drag source so users can drag the currently-displayed
   // video onto node fields (e.g. a Video Primitive's "Starting Video" input) directly from
   // the viewer, just like they can from the gallery thumbnail. Mirrors GalleryVideoItem's
@@ -117,13 +190,15 @@ export const CurrentVideoPreview = memo(({ videoDTO }: Props) => {
     );
   }, [videoDTO, store]);
 
-  const handleVideoError = useCallback(() => {
+  // Drop back to the idle still and tell the user, without touching the progress overlay. Used on
+  // its own for a rejected play(), where the media itself is fine.
+  const reportPlaybackFailure = useCallback(() => {
     setIsPlaying(false);
     // A restored session's <video> request can 401 before the media-cookie self-heal
     // completes; the URL version bumps and the element reloads once the cookie lands.
     // Surfacing an error toast for that transient window would be a false alarm.
     if (isMediaCookieSelfHealPending()) {
-      return;
+      return false;
     }
     toast({
       id: 'VIDEO_PLAYBACK_FAILED',
@@ -131,8 +206,23 @@ export const CurrentVideoPreview = memo(({ videoDTO }: Props) => {
       title: t('toast.videoPlaybackFailed'),
       description: t('toast.videoPlaybackFailedDesc'),
     });
+    return true;
   }, [t]);
 
+  const handleVideoError = useCallback(() => {
+    // The self-heal case reloads the element, which then fires onLoadedMetadata and ends any
+    // pending resolve on its own — so only a real element error takes the shortcut below.
+    if (!reportPlaybackFailure()) {
+      return;
+    }
+    // A genuinely errored element will never fire onLoadedMetadata, which is what normally ends
+    // this session's post-render "resolve" illusion — end it here instead of letting the overlay
+    // sit over the viewer for the whole resolve timeout. Attributed to this video's session, so
+    // the lifecycle ignores it if some other session's illusion is the one pending, and it is a
+    // no-op when none is.
+    onLoadImage(videoDTO?.session_id ?? null);
+  }, [onLoadImage, reportPlaybackFailure, videoDTO?.session_id]);
+
   const handlePlay = useCallback(() => {
     setIsPlaying(true);
     // The ref points at the same element we'll re-render with controls/audio; calling
@@ -146,9 +236,12 @@ export const CurrentVideoPreview = memo(({ videoDTO }: Props) => {
         setIsPlaying(false);
         return;
       }
-      handleVideoError();
+      // Not a load failure: onLoadedMetadata has usually already fired, and the element is intact.
+      // Routing this through the error path would end whichever session's resolve illusion happens
+      // to be pending, for a user gesture unrelated to any render.
+      reportPlaybackFailure();
     });
-  }, [handleVideoError]);
+  }, [reportPlaybackFailure]);
 
   // Close: stop playback and drop back to the first-frame preview + play overlay. We
   // explicitly pause() because toggling React's `controls` prop hides the chrome but does
@@ -338,6 +431,7 @@ export const CurrentVideoPreview = memo(({ videoDTO }: Props) => {
         playsInline
         controls={isPlaying}
         onLoadedMetadata={handleLoadedMetadata}
+        onEnded={handleClose}
         onError={handleVideoError}
         style={{
           maxWidth: '100%',
@@ -348,16 +442,25 @@ export const CurrentVideoPreview = memo(({ videoDTO }: Props) => {
         }}
       />
       {!isPlaying && !withProgress && <VideoPlayButtonOverlay onClick={handlePlay} />}
-      {shouldShowItemDetails && !withProgress && (
+      {/* Gated on the states themselves, not on !withProgress: playing and revealing both turn
+          withProgress off, and the full-screen metadata panel would land exactly on top of the
+          playback controls / the just-revealed video, swallowing the interaction they exist for. */}
+      {shouldShowItemDetails && !isPlaying && !isTemporarilyShowingSelectedImage && !withProgress && (
         <Box position="absolute" opacity={0.8} top={0} width="full" height="full" borderRadius="base">
           <VideoMetadataViewer video={videoDTO} />
         </Box>
       )}
       {withProgress && (
         <Flex w="full" h="full" position="absolute" alignItems="center" justifyContent="center" bg="base.900">
-          <ProgressImage progressImage={progressImage} />
-          {progressEvent && (
-            <ProgressIndicator progressEvent={progressEvent} position="absolute" top={6} right={6} size={8} />
+          {withTiledProgress ? (
+            <ProgressImageTiles data={activeProgressData} />
+          ) : (
+            <>
+              <ProgressImage progressImage={progressImage} />
+              {progressEvent && (
+                <ProgressIndicator progressEvent={progressEvent} position="absolute" top={6} right={6} size={8} />
+              )}
+            </>
           )}
         </Flex>
       )}
diff --git a/invokeai/frontend/web/src/features/gallery/components/ImageViewer/context.tsx b/invokeai/frontend/web/src/features/gallery/components/ImageViewer/context.tsx
index 19530ffebb9..1cbd6baaf33 100644
--- a/invokeai/frontend/web/src/features/gallery/components/ImageViewer/context.tsx
+++ b/invokeai/frontend/web/src/features/gallery/components/ImageViewer/context.tsx
@@ -11,8 +11,8 @@ import { selectAutoSwitch } from 'features/gallery/store/gallerySelectors';
 import type { ProgressImage as ProgressImageType } from 'features/nodes/types/common';
 import { LRUCache } from 'lru-cache';
 import { type Atom, atom, computed, map, type MapStore, type WritableAtom } from 'nanostores';
-import type { PropsWithChildren } from 'react';
-import { createContext, memo, useCallback, useContext, useEffect, useMemo, useState } from 'react';
+import type { MutableRefObject, PropsWithChildren } from 'react';
+import { createContext, memo, useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react';
 import type { S } from 'services/api/types';
 import { getEventScope } from 'services/events/eventScope';
 import { $socket } from 'services/events/stores';
@@ -31,6 +31,11 @@ type ImageViewerContextValue = {
   $activeProgressData: Atom<ViewerProgressDatum[]>;
   $isProgressImageResolving: Atom<boolean>;
   $isTemporarilyShowingSelectedImage: WritableAtom<boolean>;
+  /** Name of the item most recently rendered by either preview component (image or video). Shared
+   * across the two components so a click that switches media type (image -> video or back) still
+   * reads as a selection change to the temporary-reveal logic — a per-component ref resets on the
+   * swap and would silently swallow the first reveal after every type switch. */
+  lastRenderedItemNameRef: MutableRefObject<string | null>;
   /**
    * The viewer finished loading the final image/video for the given session (its DTO's
    * `session_id`, or null when it has none). Ends the completed session's "resolve" illusion.
@@ -38,6 +43,9 @@ type ImageViewerContextValue = {
   onLoadImage: (sessionId: string | null) => void;
 };
 
+/** How long a mid-generation gallery click shows the clicked item before the live preview returns. */
+export const SELECTED_ITEM_REVEAL_DURATION_MS = 2000;
+
 const ImageViewerContext = createContext<ImageViewerContextValue | null>(null);
 
 const log = logger('events');
@@ -60,6 +68,7 @@ export const ImageViewerContextProvider = memo((props: PropsWithChildren) => {
   )[0];
   const $isProgressImageResolving = useState(() => atom(false))[0];
   const $isTemporarilyShowingSelectedImage = useState(() => atom(false))[0];
+  const lastRenderedItemNameRef = useRef<string | null>(null);
   // We can have race conditions where we receive a progress event for a queue item that has already finished. Easiest
   // way to handle this is to keep track of finished queue items in a cache and ignore progress events for those.
   const [finishedQueueItemIds] = useState(() => new LRUCache<number, boolean>({ max: 200 }));
@@ -202,6 +211,7 @@ export const ImageViewerContextProvider = memo((props: PropsWithChildren) => {
       $activeProgressData,
       $isProgressImageResolving,
       $isTemporarilyShowingSelectedImage,
+      lastRenderedItemNameRef,
       onLoadImage,
     }),
     [
diff --git a/invokeai/frontend/web/src/features/gallery/components/ImageViewer/selectedItemReveal.test.ts b/invokeai/frontend/web/src/features/gallery/components/ImageViewer/selectedItemReveal.test.ts
new file mode 100644
index 00000000000..a18244ec4ac
--- /dev/null
+++ b/invokeai/frontend/web/src/features/gallery/components/ImageViewer/selectedItemReveal.test.ts
@@ -0,0 +1,248 @@
+import { createAutoSwitchedSelectionMarker } from 'features/gallery/store/autoSwitchedImages';
+import { describe, expect, it } from 'vitest';
+
+import { createSelectedItemRevealController } from './selectedItemReveal';
+
+/**
+ * Drives the controller through the same call sequences the preview components' effects produce,
+ * with a hand-cranked timer so reveal expiry is explicit. The marker is the real implementation —
+ * the reveal/auto-switch interplay is exactly what these tests exist to pin.
+ */
+const createHarness = () => {
+  let revealed = false;
+  const lastRenderedItemNameRef = { current: null as string | null };
+  const marker = createAutoSwitchedSelectionMarker();
+  const timers = new Map<number, () => void>();
+  let nextTimerId = 1;
+
+  const controller = createSelectedItemRevealController({
+    lastRenderedItemNameRef,
+    marker,
+    setRevealed: (value) => {
+      revealed = value;
+    },
+    durationMs: 2000,
+    schedule: (fn) => {
+      const id = nextTimerId++;
+      timers.set(id, fn);
+      return id;
+    },
+    cancel: (id) => {
+      timers.delete(id);
+    },
+  });
+
+  return {
+    controller,
+    marker,
+    lastRenderedItemNameRef,
+    isRevealed: () => revealed,
+    // The components' unmount handler lowers the shared flag directly, without going through the
+    // controller — StrictMode runs it between the doubled mount effects.
+    lowerExternally: () => {
+      revealed = false;
+    },
+    fireTimers: () => {
+      for (const [id, fn] of [...timers]) {
+        timers.delete(id);
+        fn();
+      }
+    },
+    pendingTimerCount: () => timers.size,
+  };
+};
+
+// An auto-switch as onInvocationComplete + the selection listener produce it: record, then the
+// dispatched selection lands and settles the marker.
+const autoSwitchTo = (marker: ReturnType<typeof createAutoSwitchedSelectionMarker>, itemName: string) => {
+  marker.record(itemName);
+  marker.settle(itemName);
+};
+
+const inputs = (overrides: Partial<Parameters<ReturnType<typeof createHarness>['controller']['run']>[0]> = {}) => ({
+  shouldShowProgressInViewer: true,
+  hasProgressImage: true,
+  isProgressImageResolving: false,
+  renderedItemName: null as string | null,
+  selectedItemName: null as string | null,
+  ...overrides,
+});
+
+const rendering = (itemName: string) => inputs({ renderedItemName: itemName, selectedItemName: itemName });
+
+describe('createSelectedItemRevealController', () => {
+  it('reveals a mid-render selection change, then lowers when the timer fires', () => {
+    const h = createHarness();
+    h.controller.run(rendering('a.png'));
+    h.controller.run(rendering('b.png'));
+    expect(h.isRevealed()).toBe(true);
+    h.fireTimers();
+    expect(h.isRevealed()).toBe(false);
+  });
+
+  it('does not reveal the first render after the viewer opens', () => {
+    const h = createHarness();
+    h.controller.run(rendering('a.png'));
+    expect(h.isRevealed()).toBe(false);
+  });
+
+  it('does not re-reveal when a later run finds the same item and no reveal in flight', () => {
+    const h = createHarness();
+    h.controller.run(rendering('a.png'));
+    h.controller.run(rendering('b.png'));
+    h.fireTimers();
+    // e.g. the resolving flag flapping, or any other dependency change with the item unchanged.
+    h.controller.run(rendering('b.png'));
+    expect(h.isRevealed()).toBe(false);
+  });
+
+  it('does not reveal an auto-switched item', () => {
+    const h = createHarness();
+    h.controller.run(rendering('a.png'));
+    autoSwitchTo(h.marker, 'b.png');
+    h.controller.run(rendering('b.png'));
+    expect(h.isRevealed()).toBe(false);
+  });
+
+  it('consumes the marker even when no progress is showing, so a later click on that item reveals', () => {
+    const h = createHarness();
+    h.controller.run(rendering('a.png'));
+    autoSwitchTo(h.marker, 'b.png');
+    // The auto-switched item renders with the overlay down — the common case.
+    h.controller.run(inputs({ renderedItemName: 'b.png', selectedItemName: 'b.png', hasProgressImage: false }));
+    expect(h.isRevealed()).toBe(false);
+    // A new render starts; the user clicks away and back to the once-auto-switched item.
+    h.controller.run(rendering('a.png'));
+    h.controller.run(rendering('b.png'));
+    expect(h.isRevealed()).toBe(true);
+  });
+
+  it('keeps the reveal through a StrictMode double-invoked mount effect', () => {
+    // React StrictMode mounts run effect -> cleanup -> effect. The cleanup cancels the reveal
+    // timer and the unmount handler lowers the shared flag; the second run then finds the shared
+    // ref already holding the new name. Without the re-arm, every cross-media first reveal dies
+    // in development.
+    const h = createHarness();
+    h.controller.run(rendering('previous-image.png'));
+    h.controller.run(rendering('clicked-video.mp4'));
+    expect(h.isRevealed()).toBe(true);
+    h.controller.clearTimer();
+    h.lowerExternally();
+    h.controller.run(rendering('clicked-video.mp4'));
+    expect(h.isRevealed()).toBe(true);
+    expect(h.pendingTimerCount()).toBe(1);
+    h.fireTimers();
+    expect(h.isRevealed()).toBe(false);
+  });
+
+  it('reveals a click that landed inside a resolve window once the window ends', () => {
+    const h = createHarness();
+    h.controller.run(rendering('a.png'));
+    // The user clicks a video while a finished render's preview is resolving; the next render's
+    // progress then resumes before the resolve ends.
+    h.controller.run(inputs({ isProgressImageResolving: true, renderedItemName: 'b.mp4', selectedItemName: 'b.mp4' }));
+    expect(h.isRevealed()).toBe(false);
+    // The ref must not have advanced past the click — that is what kept this click dead before.
+    expect(h.lastRenderedItemNameRef.current).toBe('a.png');
+    h.controller.run(rendering('b.mp4'));
+    expect(h.isRevealed()).toBe(true);
+  });
+
+  it('still suppresses an auto-switch whose render landed inside a resolve window', () => {
+    // The marker must not be consumed by a run that cannot reveal, or the post-resolve run would
+    // read the auto-switch as a user click.
+    const h = createHarness();
+    h.controller.run(rendering('a.png'));
+    autoSwitchTo(h.marker, 'b.mp4');
+    h.controller.run(inputs({ isProgressImageResolving: true, renderedItemName: 'b.mp4', selectedItemName: 'b.mp4' }));
+    expect(h.isRevealed()).toBe(false);
+    h.controller.run(rendering('b.mp4'));
+    expect(h.isRevealed()).toBe(false);
+  });
+
+  it('reveals the selection made after the selection was cleared — including the same item', () => {
+    const h = createHarness();
+    h.controller.run(rendering('a.png'));
+    // Clearing the selection empties the viewer; the ref must not fall back to the "nothing has
+    // rendered yet" state or the next click is treated as the viewer's first render and stays
+    // hidden under the progress overlay.
+    h.controller.run(inputs({ renderedItemName: null, selectedItemName: null }));
+    h.controller.run(rendering('b.mp4'));
+    expect(h.isRevealed()).toBe(true);
+
+    const h2 = createHarness();
+    h2.controller.run(rendering('a.png'));
+    h2.controller.run(inputs({ renderedItemName: null, selectedItemName: null }));
+    h2.controller.run(rendering('a.png'));
+    expect(h2.isRevealed()).toBe(true);
+  });
+
+  it('keeps the previous item while a selection exists but its render has not landed', () => {
+    // Image preloads and DTO fetches make the rendered item lag the selection; the in-between run
+    // must neither reveal nor erase the fact of what was on screen before.
+    const h = createHarness();
+    h.controller.run(rendering('a.png'));
+    h.controller.run(inputs({ renderedItemName: null, selectedItemName: 'b.png' }));
+    expect(h.isRevealed()).toBe(false);
+    expect(h.lastRenderedItemNameRef.current).toBe('a.png');
+    h.controller.run(rendering('b.png'));
+    expect(h.isRevealed()).toBe(true);
+  });
+
+  it('does not reveal while the rendered item lags the selection', () => {
+    const h = createHarness();
+    h.controller.run(rendering('a.png'));
+    h.controller.run(inputs({ renderedItemName: 'a.png', selectedItemName: 'b.png' }));
+    expect(h.isRevealed()).toBe(false);
+  });
+
+  it('lowers the reveal when the overlay is not showing at all', () => {
+    const h = createHarness();
+    h.controller.run(rendering('a.png'));
+    h.controller.run(inputs({ renderedItemName: 'b.png', selectedItemName: 'b.png', hasProgressImage: false }));
+    expect(h.isRevealed()).toBe(false);
+    const h2 = createHarness();
+    h2.controller.run(rendering('a.png'));
+    h2.controller.run(
+      inputs({ renderedItemName: 'b.png', selectedItemName: 'b.png', shouldShowProgressInViewer: false })
+    );
+    expect(h2.isRevealed()).toBe(false);
+  });
+
+  it('keeps a reveal the user already earned when a generation elsewhere starts resolving', () => {
+    // The clicked item is on screen with its two seconds running. Another session finishing is no
+    // reason to slam the opaque overlay back over it.
+    const h = createHarness();
+    h.controller.run(rendering('a.png'));
+    h.controller.run(rendering('b.png'));
+    expect(h.isRevealed()).toBe(true);
+
+    h.controller.run({ ...rendering('b.png'), isProgressImageResolving: true });
+    expect(h.isRevealed(), 'the granted reveal survives the resolve window').toBe(true);
+
+    // ...and it still ends on its own rather than sticking there.
+    h.fireTimers();
+    expect(h.isRevealed()).toBe(false);
+  });
+
+  it('lowers during a resolve window when the in-flight reveal is for a different item', () => {
+    const h = createHarness();
+    h.controller.run(rendering('a.png'));
+    h.controller.run(rendering('b.png'));
+    expect(h.isRevealed()).toBe(true);
+    h.controller.run({ ...rendering('c.png'), isProgressImageResolving: true });
+    expect(h.isRevealed()).toBe(false);
+  });
+
+  it('leaves no stale timer behind when a run supersedes a reveal', () => {
+    // Two timers alive at once means the older one lowers the newer one's reveal early.
+    const h = createHarness();
+    h.controller.run(rendering('a.png'));
+    h.controller.run(rendering('b.png'));
+    h.controller.run(rendering('c.png'));
+    expect(h.pendingTimerCount()).toBe(1);
+
+    h.controller.run({ ...rendering('c.png'), isProgressImageResolving: true });
+    expect(h.pendingTimerCount(), 'the resolve-window re-arm replaces the timer, not adds one').toBe(1);
+  });
+});
diff --git a/invokeai/frontend/web/src/features/gallery/components/ImageViewer/selectedItemReveal.ts b/invokeai/frontend/web/src/features/gallery/components/ImageViewer/selectedItemReveal.ts
new file mode 100644
index 00000000000..aea5addd516
--- /dev/null
+++ b/invokeai/frontend/web/src/features/gallery/components/ImageViewer/selectedItemReveal.ts
@@ -0,0 +1,174 @@
+/**
+ * The viewer's "reveal selected item" mechanism, extracted from the preview components so its
+ * sequencing is testable without rendering.
+ *
+ * A generation covers the viewer with an opaque progress overlay, which would otherwise swallow
+ * every gallery click for the whole render: the selection changes underneath, but nothing visibly
+ * happens. The reveal lifts the overlay for `durationMs` when the rendered item changes because
+ * the *user* picked a new one, then drops back to the live preview.
+ *
+ * CurrentImagePreview and CurrentVideoPreview each own one controller and call `run` from the
+ * effect that reacts to their rendered item; `lastRenderedItemNameRef` is shared between them via
+ * the viewer context so a click that switches media type still reads as a selection change.
+ *
+ * Sequencing rules the controller encodes (each one has a failure mode without it):
+ *
+ * - The previous-item ref is NOT advanced, and the auto-switch marker NOT consumed, while a
+ *   finished render's preview is resolving into its final frame. A click landing inside that
+ *   window keeps its identity until the window ends, so the next run can still classify it —
+ *   revealing a user click that resumes progress would otherwise be impossible, and an
+ *   auto-switch would consume its marker on a run that can never reveal, then read as a user
+ *   click afterwards.
+ * - The marker IS consumed on every other change of the rendered item, even when no progress is
+ *   showing: it must not outlive the render it was recorded for.
+ * - Clearing the selection moves the ref to a sentinel rather than null: null means "nothing has
+ *   rendered since the viewer opened" and suppresses the reveal (that first render is not a
+ *   click), but the selection made after a clear IS a click and must reveal — including a
+ *   re-selection of the very item that was cleared.
+ * - A run that finds the rendered item unchanged while this controller's own reveal is the one
+ *   in flight re-arms it instead of killing it. React StrictMode double-invokes a mount's
+ *   effects (run → cleanup → run), so without this every cross-media first reveal dies in
+ *   development: the second run sees the name the first run wrote into the shared ref.
+ * - Every other path lowers the reveal. `run` cancels the running reveal's timer before
+ *   deciding, so an outcome that left the flag raised would have nothing left to lower it.
+ */
+
+type SelectedItemRevealInputs = {
+  /** The user's "show progress in viewer" setting. */
+  shouldShowProgressInViewer: boolean;
+  /** Whether a live progress preview exists to be covering the viewer at all. */
+  hasProgressImage: boolean;
+  /** Whether a finished generation's preview is mid-handoff to its final frame. */
+  isProgressImageResolving: boolean;
+  /** The item the component is rendering right now, or null when it has nothing to show. */
+  renderedItemName: string | null;
+  /** The item the gallery selection points at, or null when the selection is empty. */
+  selectedItemName: string | null;
+};
+
+type SelectedItemRevealController = {
+  /** Decide and apply the reveal state for the current render. Call from the effect body. */
+  run: (inputs: SelectedItemRevealInputs) => void;
+  /** Cancel the running reveal's timer without changing the revealed state. Call from the
+   * effect's cleanup — the next `run` (or the component's unmount handler) owns the state. */
+  clearTimer: () => void;
+};
+
+// Written into the shared ref when the selection is cleared after something had rendered. Never
+// equals a real item name (names are filenames), never equals null (the nothing-rendered-yet
+// state), so the next rendered item compares as a change and gets its reveal.
+const SELECTION_CLEARED = '';
+
+export const createSelectedItemRevealController = (deps: {
+  /** Shared with the other preview component via the viewer context. */
+  lastRenderedItemNameRef: { current: string | null };
+  /** The auto-switch marker (see features/gallery/store/autoSwitchedImages). */
+  marker: { consume: (itemName: string) => boolean };
+  /** Writes the shared "temporarily showing selected item" flag. */
+  setRevealed: (revealed: boolean) => void;
+  durationMs: number;
+  schedule?: (fn: () => void, ms: number) => number;
+  cancel?: (id: number) => void;
+}): SelectedItemRevealController => {
+  const {
+    lastRenderedItemNameRef,
+    marker,
+    setRevealed,
+    durationMs,
+    schedule = (fn, ms) => window.setTimeout(fn, ms),
+    cancel = (id) => window.clearTimeout(id),
+  } = deps;
+
+  // The item this controller's currently-armed reveal is showing, null when none is in flight.
+  // This is what lets a StrictMode re-run tell "my own reveal, restarted" from "nothing changed".
+  let activeRevealItemName: string | null = null;
+  let timerId = 0;
+
+  const lower = () => {
+    activeRevealItemName = null;
+    setRevealed(false);
+  };
+
+  const run: SelectedItemRevealController['run'] = ({
+    shouldShowProgressInViewer,
+    hasProgressImage,
+    isProgressImageResolving,
+    renderedItemName,
+    selectedItemName,
+  }) => {
+    cancel(timerId);
+
+    // Resolve window: leave the ref and the marker exactly as they are (see the module docblock)
+    // so whatever lands during it can still be classified — and revealed — when it ends.
+    if (isProgressImageResolving) {
+      if (activeRevealItemName !== null && activeRevealItemName === renderedItemName) {
+        // A reveal the user already earned is in flight over this very item. A generation
+        // finishing elsewhere is no reason to slam the overlay back over their click, so re-arm
+        // (the timer was cancelled above) instead of lowering.
+        timerId = schedule(lower, durationMs);
+        return;
+      }
+      lower();
+      return;
+    }
+
+    const previousRenderedItemName = lastRenderedItemNameRef.current;
+    if (renderedItemName !== null) {
+      lastRenderedItemNameRef.current = renderedItemName;
+    } else if (selectedItemName === null && previousRenderedItemName !== null) {
+      // Selection cleared. While a selection exists but its render hasn't landed yet (preload or
+      // DTO fetch pending), the ref must keep the previous item — nulling it would erase the
+      // "previous item" fact and swallow the reveal the successor run would fire.
+      lastRenderedItemNameRef.current = SELECTION_CLEARED;
+    }
+
+    // Consumed before the visibility guards below: in the common case the auto-switched item
+    // renders with no progress showing, and the marker must not outlive the render it was
+    // recorded for.
+    const wasAutoSwitchedTo =
+      renderedItemName !== null && renderedItemName !== previousRenderedItemName && marker.consume(renderedItemName);
+
+    if (
+      !shouldShowProgressInViewer ||
+      !hasProgressImage ||
+      renderedItemName === null ||
+      // Render lagging the selection: whatever is on screen is not what the user picked, so
+      // showing it would not make their click land.
+      renderedItemName !== selectedItemName
+    ) {
+      lower();
+      return;
+    }
+
+    if (previousRenderedItemName === null || previousRenderedItemName === renderedItemName) {
+      if (activeRevealItemName !== renderedItemName) {
+        // Not a change of displayed item — nothing happened that needs to be made visible. The
+        // first render after the viewer opens is not a click either.
+        lower();
+        return;
+      }
+      // This controller's own reveal of this exact item is in flight: a StrictMode re-run of the
+      // mount effect (its cleanup already cancelled the timer, and the unmount handler lowered
+      // the flag). Fall through and re-arm rather than killing the reveal the user just earned.
+    } else if (wasAutoSwitchedTo) {
+      // The reveal exists for *user* selections. The auto-switch selection lands after an async
+      // DTO fetch, so the next render's first progress event can slot in ahead of it and reset
+      // the resolving flag — by the time it reaches this effect, timing cannot tell it from a
+      // click, but the marker can. Revealing it would flash the finished item over the new
+      // render's live preview.
+      lower();
+      return;
+    }
+
+    activeRevealItemName = renderedItemName;
+    setRevealed(true);
+    timerId = schedule(lower, durationMs);
+  };
+
+  return {
+    run,
+    clearTimer: () => {
+      cancel(timerId);
+    },
+  };
+};
diff --git a/invokeai/frontend/web/src/features/gallery/components/ImageViewer/viewerProgressLifecycle.test.ts b/invokeai/frontend/web/src/features/gallery/components/ImageViewer/viewerProgressLifecycle.test.ts
index a3181382a7f..3b96c95895b 100644
--- a/invokeai/frontend/web/src/features/gallery/components/ImageViewer/viewerProgressLifecycle.test.ts
+++ b/invokeai/frontend/web/src/features/gallery/components/ImageViewer/viewerProgressLifecycle.test.ts
@@ -114,6 +114,19 @@ describe('viewerProgressLifecycle', () => {
       }
     );
 
+    it('leaves the promoted session up when no further event arrives', () => {
+      // The handoff must not be on borrowed time: after A finishes, B may go a long while before
+      // its next progress event (a video render's steps are seconds apart), and no timer armed by
+      // A's completion may take B's preview down in the meantime.
+      const { eventB } = startTwoSessions();
+      lifecycle.onTerminal(buildTerminalEvent({ item_id: 1, status: 'completed' }), true);
+      lifecycle.onFinalImageLoaded('session-1');
+      vi.advanceTimersByTime(RESOLVE_TIMEOUT_MS * 10);
+      expect(stores.$progressEvent.get()).toBe(eventB);
+      expect(stores.$progressImage.get()).toBe(eventB.image);
+      expect(stores.$progressData.get()[2]?.itemId).toBe(2);
+    });
+
     it('hands the shared preview to the remaining session even when auto-switch is off', () => {
       const { eventB } = startTwoSessions();
       lifecycle.onTerminal(buildTerminalEvent({ item_id: 1, status: 'canceled' }), false);
diff --git a/invokeai/frontend/web/src/features/gallery/store/autoSwitchedImages.test.ts b/invokeai/frontend/web/src/features/gallery/store/autoSwitchedImages.test.ts
new file mode 100644
index 00000000000..899397eeaac
--- /dev/null
+++ b/invokeai/frontend/web/src/features/gallery/store/autoSwitchedImages.test.ts
@@ -0,0 +1,79 @@
+import { describe, expect, it } from 'vitest';
+
+import { createAutoSwitchedSelectionMarker } from './autoSwitchedImages';
+
+describe('createAutoSwitchedSelectionMarker', () => {
+  it('reports the auto-switched item on its first render, once', () => {
+    const marker = createAutoSwitchedSelectionMarker();
+    marker.record('a.png');
+    marker.settle('a.png');
+    expect(marker.consume('a.png')).toBe(true);
+    expect(marker.consume('a.png')).toBe(false);
+  });
+
+  it('reports nothing for an item that was never auto-switched to', () => {
+    const marker = createAutoSwitchedSelectionMarker();
+    expect(marker.consume('a.png')).toBe(false);
+  });
+
+  it('drops a marker whose selection was superseded before it rendered', () => {
+    // The auto-switch to A is dispatched, then the user clicks B before A's preload settles. A can
+    // never render as that auto-switch, and the user's later click on A must reveal it.
+    const marker = createAutoSwitchedSelectionMarker();
+    marker.record('a.png');
+    marker.settle('a.png');
+    marker.settle('b.png');
+    marker.settle('a.png');
+    expect(marker.consume('a.png')).toBe(false);
+  });
+
+  it('keeps only the last of several auto-switches settled in one batch', () => {
+    // Two sessions completing together record two names, but only the last selection stands.
+    const marker = createAutoSwitchedSelectionMarker();
+    marker.record('a.png');
+    marker.settle('a.png');
+    marker.record('b.png');
+    marker.settle('b.png');
+    expect(marker.consume('b.png')).toBe(true);
+    expect(marker.consume('a.png')).toBe(false);
+  });
+
+  it('survives settles that do not move the selection', () => {
+    // Re-selecting the same item (or any other action that leaves the selection alone) must not
+    // discard a marker whose item has not rendered yet.
+    const marker = createAutoSwitchedSelectionMarker();
+    marker.record('a.png');
+    marker.settle('a.png');
+    marker.settle('a.png');
+    expect(marker.consume('a.png')).toBe(true);
+  });
+
+  it('drops the marker when the selection is cleared', () => {
+    const marker = createAutoSwitchedSelectionMarker();
+    marker.record('a.png');
+    marker.settle('a.png');
+    marker.settle(null);
+    expect(marker.consume('a.png')).toBe(false);
+  });
+
+  it('does not report a second render of an item after its marker was consumed', () => {
+    // The user navigates away and back: that second render is a user selection and must reveal.
+    const marker = createAutoSwitchedSelectionMarker();
+    marker.record('a.png');
+    marker.settle('a.png');
+    expect(marker.consume('a.png')).toBe(true);
+    marker.settle('b.png');
+    marker.settle('a.png');
+    expect(marker.consume('a.png')).toBe(false);
+  });
+
+  it('does not clear a pending marker when a different item is consumed', () => {
+    // The rendered item can lag a just-auto-switched selection: the viewer consumes for whatever
+    // is still on screen, and that must not spend the marker the incoming item is owed.
+    const marker = createAutoSwitchedSelectionMarker();
+    marker.record('a.png');
+    marker.settle('a.png');
+    expect(marker.consume('b.png')).toBe(false);
+    expect(marker.consume('a.png'), 'the marker survives an unrelated consume').toBe(true);
+  });
+});
diff --git a/invokeai/frontend/web/src/features/gallery/store/autoSwitchedImages.ts b/invokeai/frontend/web/src/features/gallery/store/autoSwitchedImages.ts
new file mode 100644
index 00000000000..d7ab9003458
--- /dev/null
+++ b/invokeai/frontend/web/src/features/gallery/store/autoSwitchedImages.ts
@@ -0,0 +1,61 @@
+/**
+ * Marks the gallery selection the auto-switch made, until the viewer renders it.
+ *
+ * The viewer briefly reveals a newly selected item over the progress overlay so that a
+ * mid-generation gallery click is not invisible (see the reveal effect in CurrentImagePreview).
+ * Auto-switch selections must not trigger that reveal — but they land asynchronously: the switch is
+ * dispatched only after onInvocationComplete's DTO fetch resolves, and the viewer renders it only
+ * after the thumbnail preload settles. When the next generation is started quickly, its first
+ * invocation_progress event slots into that window and resets $isProgressImageResolving, so by the
+ * time the auto-switch selection reaches the viewer it is indistinguishable from a user click and
+ * the reveal flashes the previous result over the live preview for 2 seconds.
+ *
+ * The marker is scoped to the selection it was recorded for, not to the item name: it survives only
+ * as long as that selection stands. A name-keyed marker cannot tell "this render is the auto-switch
+ * landing" from "the user picked that same item later", so an auto-switch that never rendered —
+ * because the user clicked elsewhere first — would swallow their later click on it, the very dead
+ * click the reveal exists to prevent. Settling on every selection change closes that: once the
+ * selection moves on, the recorded auto-switch can never render, and the marker goes with it.
+ *
+ * That scoping is also why no expiry or bound is needed. At most one marker exists, and only while
+ * its selection is the current one.
+ */
+type AutoSwitchedSelectionMarker = {
+  /** Records that the gallery is auto-switching the selection to this item. Call immediately
+   * before dispatching that selection, so the settle it triggers sees the marker. */
+  record: (itemName: string) => void;
+  /**
+   * Points the marker at the selection that now stands, dropping it unless it is still the one
+   * recorded. Call on every selection change (see addAutoSwitchedSelectionListener).
+   */
+  settle: (selectedItemName: string | null) => void;
+  /**
+   * Returns whether the item now rendering is the one the auto-switch selected, clearing the
+   * marker. Call on every change of the rendered item.
+   */
+  consume: (itemName: string) => boolean;
+};
+
+export const createAutoSwitchedSelectionMarker = (): AutoSwitchedSelectionMarker => {
+  let pendingItemName: string | null = null;
+
+  return {
+    record: (itemName) => {
+      pendingItemName = itemName;
+    },
+    settle: (selectedItemName) => {
+      if (pendingItemName !== selectedItemName) {
+        pendingItemName = null;
+      }
+    },
+    consume: (itemName) => {
+      if (pendingItemName !== itemName) {
+        return false;
+      }
+      pendingItemName = null;
+      return true;
+    },
+  };
+};
+
+export const autoSwitchedImages = createAutoSwitchedSelectionMarker();
diff --git a/invokeai/frontend/web/src/services/api/endpoints/videos.ts b/invokeai/frontend/web/src/services/api/endpoints/videos.ts
index 49043d763a0..3f7327ca49c 100644
--- a/invokeai/frontend/web/src/services/api/endpoints/videos.ts
+++ b/invokeai/frontend/web/src/services/api/endpoints/videos.ts
@@ -352,14 +352,13 @@ export const {
   useDeleteUncategorizedVideosMutation,
 } = videosApi;
 
+export const { useGetVideoMetadataQuery, useGetVideoWorkflowQuery, useLazyGetVideoWorkflowQuery } = videosApi;
+
 /** @knipignore Reserved for follow-up phases (bulk delete / intermediate toggle / video-only views).
  * useDeleteVideoMutation is here because the only call site uses videosApi.endpoints.deleteVideo.initiate
  * via the delete-video modal, but a future bulk/multi-select flow may want the React hook form. */
 export const {
   useListVideosQuery,
-  useGetVideoMetadataQuery,
-  useGetVideoWorkflowQuery,
-  useLazyGetVideoWorkflowQuery,
   useGetVideoNamesQuery,
   useDeleteVideoMutation,
   useDeleteVideosMutation,
diff --git a/invokeai/frontend/web/src/services/events/onInvocationComplete.test.ts b/invokeai/frontend/web/src/services/events/onInvocationComplete.test.ts
index 0a811360ae0..3d3ca34b14d 100644
--- a/invokeai/frontend/web/src/services/events/onInvocationComplete.test.ts
+++ b/invokeai/frontend/web/src/services/events/onInvocationComplete.test.ts
@@ -117,8 +117,12 @@ vi.mock('services/events/stores', () => ({
 
 // Import AFTER the mocks above are declared (vi.mock is hoisted; explicit ordering here
 // is for the human reader).
+import { autoSwitchedImages } from 'features/gallery/store/autoSwitchedImages';
+import { selectAutoSwitch } from 'features/gallery/store/gallerySelectors';
+import { imageSelected } from 'features/gallery/store/gallerySlice';
 import { getImageDTOSafe } from 'services/api/endpoints/images';
 import { getVideoDTOSafe } from 'services/api/endpoints/videos';
+import { $lastProgressEvent } from 'services/events/stores';
 
 import {
   buildOnForeignInvocationComplete,
@@ -157,6 +161,10 @@ const buildImageCompleteEvent = (): S['InvocationCompleteEvent'] =>
 describe('onInvocationComplete polymorphic gallery cache', () => {
   beforeEach(() => {
     vi.clearAllMocks();
+    // clearAllMocks resets calls, not implementations — restore the factory default so a test that
+    // turns auto-switch on cannot leak it into the next one.
+    vi.mocked(selectAutoSwitch).mockReturnValue(false);
+    autoSwitchedImages.settle(null);
   });
 
   it('invalidates GalleryItemNameList + GalleryItemList when an image output completes', async () => {
@@ -288,6 +296,602 @@ describe('onInvocationComplete polymorphic gallery cache', () => {
     expect(galleryInvalidation?.payload).toContainEqual({ type: 'BoardVideosTotal', id: 'board-123' });
     expect(galleryInvalidation?.payload).toContain('VirtualBoards');
   });
+
+  it('processes each completion event exactly once — a duplicate delivery does no gallery work', async () => {
+    // Re-running the gallery handling on a duplicate double-counts the optimistic board totals and
+    // re-records the auto-switch marker after it was consumed, which suppresses a later genuine
+    // gallery click on that image.
+    const dispatch = vi.fn(() => ({ unwrap: () => Promise.resolve(undefined) }));
+    const getState = vi.fn(() => ({}));
+
+    const handler = buildOnInvocationComplete(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getState as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      dispatch as any,
+      new Map()
+    );
+
+    await handler(buildImageCompleteEvent());
+    const dispatchCountAfterFirst = dispatch.mock.calls.length;
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(1);
+
+    await handler(buildImageCompleteEvent());
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(1);
+    expect(dispatch.mock.calls.length).toBe(dispatchCountAfterFirst);
+  });
+
+  it('rejects a duplicate that arrives while the first delivery is still awaiting its DTO fetch', async () => {
+    // The gallery work awaits a DTO fetch, so a duplicate can land mid-flight. The handler must
+    // mark the event as processed before the first await, not after.
+    const dispatch = vi.fn(() => ({ unwrap: () => Promise.resolve(undefined) }));
+    const getState = vi.fn(() => ({}));
+
+    const handler = buildOnInvocationComplete(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getState as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      dispatch as any,
+      new Map()
+    );
+
+    await Promise.all([handler(buildImageCompleteEvent()), handler(buildImageCompleteEvent())]);
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(1);
+  });
+
+  it('records a duplicated video completion once, so a later reselection of that video reveals', async () => {
+    // The duplicate delivery used to re-run addVideosToGallery in full: a second auto-switch
+    // marker record and a second selection dispatch. The dedupe must stop the whole re-run.
+    autoSwitchedImages.settle(null); // the marker is a module singleton; start from empty
+    vi.mocked(selectAutoSwitch).mockReturnValueOnce(true);
+    vi.mocked(getVideoDTOSafe).mockResolvedValueOnce({
+      video_name: 'fresh-video.mp4',
+      video_url: 'mock://fresh-video.mp4',
+      thumbnail_url: 'mock://thumb/fresh-video.mp4',
+      width: 832,
+      height: 480,
+      duration_seconds: 3.4,
+      frame_count: 81,
+      is_intermediate: false,
+      is_starred: false,
+      board_id: null,
+      created_at: '2026-01-01',
+      updated_at: '2026-01-01',
+      session_id: 'test-session',
+      node_id: 'test-node',
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any);
+
+    const dispatch = vi.fn(() => ({ unwrap: () => Promise.resolve(undefined) }));
+    const getState = vi.fn(() => ({}));
+
+    const handler = buildOnInvocationComplete(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getState as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      dispatch as any,
+      new Map()
+    );
+
+    const videoEvent = buildImageCompleteEvent();
+    videoEvent.invocation.type = 'wan_l2v';
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (videoEvent as any).result = { video: { video_name: 'fresh-video.mp4' } };
+
+    await handler(videoEvent);
+    await handler(videoEvent);
+
+    expect(getVideoDTOSafe).toHaveBeenCalledTimes(1);
+    expect(imageSelected).toHaveBeenCalledTimes(1);
+
+    // The rest of JPPhoto's sequence, against the real marker singleton: the auto-switched video
+    // renders (consume), the user selects another item, then re-selects the video — which must
+    // NOT read as an auto-switch, or the click is dead under the progress overlay.
+    autoSwitchedImages.settle('fresh-video.mp4');
+    expect(autoSwitchedImages.consume('fresh-video.mp4')).toBe(true);
+    autoSwitchedImages.settle('some-other-item.png');
+    autoSwitchedImages.settle('fresh-video.mp4');
+    expect(autoSwitchedImages.consume('fresh-video.mp4')).toBe(false);
+  });
+
+  it('lets a re-delivery retry when the first attempt lost its DTO to a transient failure', async () => {
+    // getImageDTOSafe swallows fetch errors and returns null, so a transient failure silently
+    // drops the image from the gallery. Keeping the dedupe key in that case would make the loss
+    // permanent — the redelivery that could fix it is turned away as a duplicate.
+    vi.mocked(getImageDTOSafe).mockResolvedValueOnce(null);
+
+    const dispatched: unknown[] = [];
+    const dispatch = vi.fn((action: unknown) => {
+      dispatched.push(action);
+      return { unwrap: () => Promise.resolve(undefined) };
+    });
+    const getState = vi.fn(() => ({}));
+
+    const handler = buildOnInvocationComplete(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getState as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      dispatch as any,
+      new Map()
+    );
+
+    await handler(buildImageCompleteEvent());
+    expect(
+      dispatched.some((action) => {
+        const payload = (action as { payload?: unknown }).payload;
+        return Array.isArray(payload) && payload.includes('GalleryItemNameList');
+      }),
+      'a failed lookup produces no gallery work'
+    ).toBe(false);
+
+    await handler(buildImageCompleteEvent());
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(2);
+    expect(
+      dispatched.some((action) => {
+        const payload = (action as { payload?: unknown }).payload;
+        return Array.isArray(payload) && payload.includes('GalleryItemNameList');
+      }),
+      'the retry must do the gallery work the first delivery lost'
+    ).toBe(true);
+  });
+
+  it('retries only the output whose lookup failed, leaving the ones that landed alone', async () => {
+    // One of two image lookups fails. The successful one's board totals and optimistic insert have
+    // already gone out, so a re-delivery must not touch it — but the lost one is only recoverable
+    // here, since nothing re-emits the event on its own.
+    vi.mocked(getImageDTOSafe).mockResolvedValueOnce(null);
+
+    const dispatch = vi.fn(() => ({ unwrap: () => Promise.resolve(undefined) }));
+    const getState = vi.fn(() => ({}));
+
+    const handler = buildOnInvocationComplete(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getState as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      dispatch as any,
+      new Map()
+    );
+
+    const twoImages = buildImageCompleteEvent();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (twoImages as any).result = {
+      image_1: { image_name: 'first.png' },
+      image_2: { image_name: 'second.png' },
+    };
+
+    await handler(twoImages);
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(2);
+
+    await handler(twoImages);
+    // Exactly one more lookup, and it is the one that failed.
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(3);
+    expect(vi.mocked(getImageDTOSafe).mock.calls.at(-1)?.[0]).toBe('first.png');
+
+    // Once everything has landed, the event is closed again.
+    await handler(twoImages);
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(3);
+  });
+
+  it('retries a failed lookup inside an image collection', async () => {
+    // Collections are where partial failure is actually plausible: the user sees most of a batch
+    // and silently misses one image, its auto-switch, and its board count.
+    vi.mocked(getImageDTOSafe).mockResolvedValueOnce(null);
+
+    const dispatch = vi.fn(() => ({ unwrap: () => Promise.resolve(undefined) }));
+    const getState = vi.fn(() => ({}));
+
+    const handler = buildOnInvocationComplete(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getState as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      dispatch as any,
+      new Map()
+    );
+
+    const collection = buildImageCompleteEvent();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (collection as any).result = {
+      collection: [{ image_name: 'batch-1.png' }, { image_name: 'batch-2.png' }, { image_name: 'batch-3.png' }],
+    };
+
+    await handler(collection);
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(3);
+
+    await handler(collection);
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(4);
+    expect(vi.mocked(getImageDTOSafe).mock.calls.at(-1)?.[0]).toBe('batch-1.png');
+  });
+
+  it('lets a duplicate that overlapped a lost delivery become the retry', async () => {
+    // The duplicate arrives while the first delivery is still fetching, so it cannot be told yet
+    // that the fetch will fail. Rejecting it outright strands the output: there is no third event.
+    let resolveFirstLookup: (value: null) => void = () => {};
+    vi.mocked(getImageDTOSafe).mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          resolveFirstLookup = resolve;
+        })
+    );
+
+    const dispatch = vi.fn(() => ({ unwrap: () => Promise.resolve(undefined) }));
+    const getState = vi.fn(() => ({}));
+
+    const handler = buildOnInvocationComplete(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getState as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      dispatch as any,
+      new Map()
+    );
+
+    const event = buildImageCompleteEvent();
+    const first = handler(event);
+    const duplicate = handler(event);
+
+    // The first delivery's only lookup fails, losing the image.
+    resolveFirstLookup(null);
+    await Promise.all([first, duplicate]);
+
+    // The duplicate picked the work back up rather than being discarded.
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(2);
+    expect(vi.mocked(getImageDTOSafe).mock.calls.at(-1)?.[0]).toBe('fresh-image.png');
+  });
+
+  it('marks the selection it auto-switches to, so the viewer does not reveal it as a user click', async () => {
+    // Without the marker the finished image flashes over the next generation's live preview for
+    // two seconds — the regression this PR exists to fix. The marker is the only signal that can
+    // tell the handoff from a click, since it lands after the next generation's first progress
+    // event has already reset the timing-based guard.
+    vi.mocked(selectAutoSwitch).mockReturnValue(true);
+    autoSwitchedImages.settle(null);
+
+    const dispatch = vi.fn(() => ({ unwrap: () => Promise.resolve(undefined) }));
+    const getState = vi.fn(() => ({}));
+
+    const handler = buildOnInvocationComplete(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getState as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      dispatch as any,
+      new Map()
+    );
+
+    await handler(buildImageCompleteEvent());
+
+    expect(autoSwitchedImages.consume('fresh-image.png')).toBe(true);
+  });
+
+  it('does not mark anything when auto-switch is off — nothing is selected to be revealed', async () => {
+    vi.mocked(selectAutoSwitch).mockReturnValue(false);
+    autoSwitchedImages.settle(null);
+
+    const dispatch = vi.fn(() => ({ unwrap: () => Promise.resolve(undefined) }));
+    const getState = vi.fn(() => ({}));
+
+    const handler = buildOnInvocationComplete(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getState as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      dispatch as any,
+      new Map()
+    );
+
+    await handler(buildImageCompleteEvent());
+
+    expect(autoSwitchedImages.consume('fresh-image.png')).toBe(false);
+  });
+
+  it('retries only the image half of a mixed result, not the video that landed', async () => {
+    // The video lookup succeeded, so its board invalidation and auto-switch already went out; a
+    // re-delivery re-running them would invalidate twice and move the selection a second time.
+    vi.mocked(selectAutoSwitch).mockReturnValue(true);
+    vi.mocked(getImageDTOSafe).mockResolvedValueOnce(null);
+    vi.mocked(getVideoDTOSafe).mockResolvedValueOnce({
+      video_name: 'fresh-video.mp4',
+      video_url: 'mock://fresh-video.mp4',
+      thumbnail_url: 'mock://thumb/fresh-video.mp4',
+      is_intermediate: false,
+      is_starred: false,
+      board_id: 'board-123',
+      created_at: '2026-01-01',
+      updated_at: '2026-01-01',
+      session_id: 'test-session',
+      node_id: 'test-node',
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any);
+
+    const dispatch = vi.fn(() => ({ unwrap: () => Promise.resolve(undefined) }));
+    const getState = vi.fn(() => ({}));
+
+    const handler = buildOnInvocationComplete(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getState as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      dispatch as any,
+      new Map()
+    );
+
+    const mixed = buildImageCompleteEvent();
+    mixed.invocation.type = 'wan_l2v';
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (mixed as any).result = {
+      image: { image_name: 'lost-image.png' },
+      video: { video_name: 'fresh-video.mp4' },
+    };
+
+    await handler(mixed);
+    expect(getVideoDTOSafe).toHaveBeenCalledTimes(1);
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(1);
+
+    // The re-delivery refetches the lost image and leaves the video alone.
+    await handler(mixed);
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(2);
+    expect(getVideoDTOSafe).toHaveBeenCalledTimes(1);
+  });
+
+  it('redoes only the gallery work on a retry, not the global side effects', async () => {
+    // The canvas processing flag and $lastProgressEvent are global: by the time a re-delivery
+    // arrives the user may have started another run, and clearing them again would stop that run's
+    // spinner and blank its progress.
+    vi.mocked(getImageDTOSafe).mockResolvedValueOnce(null);
+
+    const dispatched: unknown[] = [];
+    const dispatch = vi.fn((action: unknown) => {
+      dispatched.push(action);
+      return { unwrap: () => Promise.resolve(undefined) };
+    });
+    const getState = vi.fn(() => ({}));
+
+    const handler = buildOnInvocationComplete(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getState as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      dispatch as any,
+      new Map()
+    );
+
+    const canvasEvent = buildImageCompleteEvent();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (canvasEvent as any).origin = 'canvas_workflow_integration';
+
+    await handler(canvasEvent);
+    const canvasClears = () => dispatched.filter((a) => (a as { type?: string }).type === 'mock/canvasComplete').length;
+    expect(canvasClears()).toBe(1);
+    expect($lastProgressEvent.set).toHaveBeenCalledTimes(1);
+
+    // The retry must redo the lost gallery fetch...
+    await handler(canvasEvent);
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(2);
+    // ...and nothing else.
+    expect(canvasClears()).toBe(1);
+    expect($lastProgressEvent.set).toHaveBeenCalledTimes(1);
+  });
+
+  it('retries the lost output alongside an intermediate one, without redoing the intermediate', async () => {
+    // An intermediate image never reaches the gallery, so there is nothing to redo for it — but the
+    // lookup that failed beside it must still be recoverable.
+    vi.mocked(getImageDTOSafe)
+      .mockResolvedValueOnce(null)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .mockResolvedValueOnce({ image_name: 'intermediate.png', is_intermediate: true, board_id: null } as any);
+
+    const dispatch = vi.fn(() => ({ unwrap: () => Promise.resolve(undefined) }));
+    const getState = vi.fn(() => ({}));
+
+    const handler = buildOnInvocationComplete(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getState as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      dispatch as any,
+      new Map()
+    );
+
+    const twoImages = buildImageCompleteEvent();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (twoImages as any).result = {
+      image_1: { image_name: 'lost.png' },
+      image_2: { image_name: 'intermediate.png' },
+    };
+
+    await handler(twoImages);
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(2);
+
+    // Only the lost output is refetched — the intermediate one never had gallery work to redo.
+    await handler(twoImages);
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(3);
+    expect(vi.mocked(getImageDTOSafe).mock.calls.at(-1)?.[0]).toBe('lost.png');
+  });
+
+  it('serializes several duplicates waiting on one lost delivery into a single retry', async () => {
+    // All three duplicates are parked on the same in-flight delivery. When it fails they all wake
+    // up; only one may pick the work back up, or the retried output lands two or three times over.
+    let resolveFirstLookup: (value: null) => void = () => {};
+    vi.mocked(getImageDTOSafe).mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          resolveFirstLookup = resolve;
+        })
+    );
+
+    const dispatch = vi.fn(() => ({ unwrap: () => Promise.resolve(undefined) }));
+    const getState = vi.fn(() => ({}));
+
+    const handler = buildOnInvocationComplete(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getState as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      dispatch as any,
+      new Map()
+    );
+
+    const event = buildImageCompleteEvent();
+    const deliveries = [handler(event), handler(event), handler(event), handler(event)];
+
+    resolveFirstLookup(null);
+    await Promise.all(deliveries);
+
+    // One failed lookup plus exactly one retry.
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(2);
+  });
+
+  it('counts an image named twice in one result once, and once again on retry', async () => {
+    // An image collection concatenates its inputs without deduping, so the same name can appear
+    // twice. It is one image: counting it twice inflates the board total, and on a retry a
+    // name-keyed missing set would re-admit the occurrence that already landed.
+    vi.mocked(selectAutoSwitch).mockReturnValue(true);
+    vi.mocked(getImageDTOSafe).mockResolvedValueOnce(null);
+
+    const dispatched: unknown[] = [];
+    const dispatch = vi.fn((action: unknown) => {
+      dispatched.push(action);
+      return { unwrap: () => Promise.resolve(undefined) };
+    });
+    const getState = vi.fn(() => ({}));
+
+    const handler = buildOnInvocationComplete(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getState as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      dispatch as any,
+      new Map()
+    );
+
+    const duplicated = buildImageCompleteEvent();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (duplicated as any).result = {
+      collection: [{ image_name: 'dup.png' }, { image_name: 'dup.png' }],
+    };
+
+    // Pass 1: one lookup for the repeated name, and it fails, so nothing lands.
+    await handler(duplicated);
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(1);
+
+    // Pass 2: still one lookup, and the image is counted exactly once.
+    await handler(duplicated);
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(2);
+
+    const boardTotalUpdates = dispatched.filter(
+      (action) => (action as { type?: string }).type === 'mock/boardsApi/upsertQueryEntries'
+    );
+    expect(boardTotalUpdates).toHaveLength(1);
+  });
+
+  it('keeps a non-intermediate sibling of an intermediate output', async () => {
+    // This used to bail out of the whole pass on the first intermediate, abandoning siblings that
+    // belong in the gallery — and with per-output retry such a sibling is in nobody's missing set,
+    // so no re-delivery could recover it.
+    // mockResolvedValueOnce, not mockImplementation: clearAllMocks resets calls but not
+    // implementations, so a persistent one would leak into every test after this.
+    const dto = (imageName: string, isIntermediate: boolean) =>
+      ({
+        image_name: imageName,
+        image_url: `mock://${imageName}`,
+        thumbnail_url: `mock://thumb/${imageName}`,
+        is_intermediate: isIntermediate,
+        is_starred: false,
+        image_category: 'general',
+        board_id: null,
+        created_at: '2026-01-01',
+        updated_at: '2026-01-01',
+        session_id: 'test-session',
+        node_id: 'test-node',
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      }) as any;
+    vi.mocked(getImageDTOSafe)
+      .mockResolvedValueOnce(dto('intermediate.png', true))
+      .mockResolvedValueOnce(dto('keeper.png', false));
+
+    const dispatched: unknown[] = [];
+    const dispatch = vi.fn((action: unknown) => {
+      dispatched.push(action);
+      return { unwrap: () => Promise.resolve(undefined) };
+    });
+    const getState = vi.fn(() => ({}));
+
+    const handler = buildOnInvocationComplete(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getState as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      dispatch as any,
+      new Map()
+    );
+
+    const mixed = buildImageCompleteEvent();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (mixed as any).result = {
+      collection: [{ image_name: 'intermediate.png' }, { image_name: 'keeper.png' }],
+    };
+
+    await handler(mixed);
+
+    const galleryInvalidation = dispatched.find((action) => {
+      const payload = (action as { payload?: unknown }).payload;
+      return Array.isArray(payload) && payload.includes('GalleryItemNameList');
+    });
+    expect(galleryInvalidation, 'the non-intermediate sibling must reach the gallery').toBeDefined();
+  });
+
+  it('does not move the selection again when a retry lands the lost output', async () => {
+    // The re-delivery can arrive long after the user has selected something else.
+    vi.mocked(selectAutoSwitch).mockReturnValue(true);
+    vi.mocked(getImageDTOSafe).mockResolvedValueOnce(null);
+
+    const dispatch = vi.fn(() => ({ unwrap: () => Promise.resolve(undefined) }));
+    const getState = vi.fn(() => ({}));
+
+    const handler = buildOnInvocationComplete(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getState as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      dispatch as any,
+      new Map()
+    );
+
+    await handler(buildImageCompleteEvent());
+    expect(imageSelected).not.toHaveBeenCalled();
+
+    await handler(buildImageCompleteEvent());
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(2);
+    expect(imageSelected, 'a retry lands the image without re-running the handoff').not.toHaveBeenCalled();
+  });
+
+  it('logs rather than rejecting when the gallery work throws', async () => {
+    // Both call sites discard this handler's promise, so a rejection would surface only as an
+    // unhandled rejection.
+    const dispatch = vi.fn(() => {
+      throw new Error('dispatch exploded');
+    });
+    const getState = vi.fn(() => ({}));
+
+    const handler = buildOnInvocationComplete(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getState as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      dispatch as any,
+      new Map()
+    );
+
+    await expect(handler(buildImageCompleteEvent())).resolves.toBeUndefined();
+  });
+
+  it('still processes distinct invocations of the same queue item', async () => {
+    const dispatch = vi.fn(() => ({ unwrap: () => Promise.resolve(undefined) }));
+    const getState = vi.fn(() => ({}));
+
+    const handler = buildOnInvocationComplete(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getState as any,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      dispatch as any,
+      new Map()
+    );
+
+    await handler(buildImageCompleteEvent());
+    const secondNode = buildImageCompleteEvent();
+    secondNode.invocation.id = 'prepared-node-2';
+    await handler(secondNode);
+    expect(getImageDTOSafe).toHaveBeenCalledTimes(2);
+  });
 });
 
 describe('buildOnForeignInvocationComplete', () => {
diff --git a/invokeai/frontend/web/src/services/events/onInvocationComplete.tsx b/invokeai/frontend/web/src/services/events/onInvocationComplete.tsx
index 5318043749d..8491e08e16a 100644
--- a/invokeai/frontend/web/src/services/events/onInvocationComplete.tsx
+++ b/invokeai/frontend/web/src/services/events/onInvocationComplete.tsx
@@ -1,6 +1,7 @@
 import { logger } from 'app/logging/logger';
 import type { AppDispatch, AppGetState } from 'app/store/store';
 import { canvasWorkflowIntegrationProcessingCompleted } from 'features/controlLayers/store/canvasWorkflowIntegrationSlice';
+import { autoSwitchedImages } from 'features/gallery/store/autoSwitchedImages';
 import {
   selectAutoSwitch,
   selectGalleryView,
@@ -11,6 +12,7 @@ import {
 import { boardIdSelected, galleryViewChanged, imageSelected } from 'features/gallery/store/gallerySlice';
 import { $nodeExecutionStates, upsertExecutionState } from 'features/nodes/hooks/useNodeExecutionState';
 import { isImageField, isImageFieldCollection, isVideoField } from 'features/nodes/types/common';
+import { LRUCache } from 'lru-cache';
 import type { ApiTagDescription } from 'services/api';
 import { api, LIST_ALL_TAG, LIST_TAG } from 'services/api';
 import { boardsApi } from 'services/api/endpoints/boards';
@@ -31,6 +33,17 @@ import type { JsonObject } from 'type-fest';
 
 const log = logger('events');
 
+/**
+ * What a completion event still has outstanding.
+ *
+ * `done` rejects any re-delivery. `retryable` names the outputs whose DTO lookup failed — the ones
+ * that never reached the gallery — so a re-delivery can fetch exactly those again. Tracking the
+ * missing outputs rather than the event as a whole is what makes a partial failure recoverable: an
+ * event-wide flag would either re-run the outputs that did land (double-counting their board totals
+ * and optimistic inserts) or abandon the one that did not.
+ */
+type ProcessedInvocationState = { status: 'done' } | { status: 'retryable'; missingNames: ReadonlySet<string> };
+
 // These nodes are passthrough nodes. They do not add images/videos to the gallery — their
 // outputs reference an existing asset — so we must skip the gallery handling for them.
 // Without 'video' here, a Video Primitive completing mid-run would invalidate the gallery
@@ -53,13 +66,40 @@ export const buildOnInvocationComplete = (
   dispatch: AppDispatch,
   completedInvocationKeysByItemId: Map<number, Set<string>>
 ) => {
-  const addImagesToGallery = async (data: S['InvocationCompleteEvent']) => {
+  // A duplicate delivery of a completion event must not repeat the work below: re-running the
+  // gallery handling double-counts the optimistic board totals and re-dispatches the auto-switch
+  // selection. The shared completedInvocationKeysByItemId map cannot detect this — the
+  // workflow coordinator pre-marks first-delivery events for non-active workflow items before this
+  // handler runs — so the handler tracks what it has processed itself. The invocation id half of
+  // the key is the prepared node's per-execution UUID, so keys cannot collide across distinct
+  // executions even where item ids restart (in-memory DB); the LRU bounds memory.
+  const processedInvocations = new LRUCache<string, ProcessedInvocationState>({ max: 1000 });
+  // Deliveries currently fetching, so a duplicate can wait for one instead of being discarded.
+  // Entries live only for the duration of a pass; the LRU above is what bounds long-term memory.
+  const inFlightDeliveries = new Map<string, Promise<void>>();
+
+  // `retryNames`, when set, restricts this pass to the outputs a previous delivery lost to a failed
+  // lookup — everything else already landed and must not be dispatched twice.
+  const addImagesToGallery = async (
+    data: S['InvocationCompleteEvent'],
+    onLookupFailure: (imageName: string) => void,
+    retryNames: ReadonlySet<string> | null
+  ) => {
+    // A retry exists to land an output the gallery lost, not to re-run the handoff around it. By
+    // the time a re-delivery arrives the user has had time to select something else, and pulling
+    // the selection back would be a worse failure than the one being repaired.
+    const isRetry = retryNames !== null;
     if (nodeTypeDenylist.includes(data.invocation.type)) {
       log.trace(`Skipping denylisted node type (${data.invocation.type})`);
       return;
     }
 
-    const imageDTOs = await getResultImageDTOs(data);
+    const fetchedImageDTOs = await getResultImageDTOs(data, onLookupFailure, retryNames);
+    // Intermediates never reach the gallery. Dropping them here rather than bailing out of the
+    // whole pass on the first one (which is what this used to do) matters now that a delivery's
+    // outputs are tracked individually: a sibling abandoned that way is in nobody's missing set,
+    // so no re-delivery could ever recover it. Mirrors addVideosToGallery.
+    const imageDTOs = fetchedImageDTOs.filter((imageDTO) => !imageDTO.is_intermediate);
     if (imageDTOs.length === 0) {
       return;
     }
@@ -70,10 +110,6 @@ export const buildOnInvocationComplete = (
     const getImageNamesArg = selectGetImageNamesQueryArgs(getState());
 
     for (const imageDTO of imageDTOs) {
-      if (imageDTO.is_intermediate) {
-        return;
-      }
-
       const board_id = imageDTO.board_id ?? 'none';
       // update the total images for the board
       boardTotalAdditions[board_id] = (boardTotalAdditions[board_id] || 0) + 1;
@@ -182,7 +218,7 @@ export const buildOnInvocationComplete = (
 
     const autoSwitch = selectAutoSwitch(getState());
 
-    if (!autoSwitch) {
+    if (!autoSwitch || isRetry) {
       return;
     }
 
@@ -196,6 +232,12 @@ export const buildOnInvocationComplete = (
     const { image_name } = lastImageDTO;
     const board_id = lastImageDTO.board_id ?? 'none';
 
+    // Both branches below auto-switch the selection to this image. Record that so the viewer's
+    // reveal effect can tell the handoff apart from a user's gallery click — this dispatch happens
+    // after an async DTO fetch, so it can land after the next generation's first progress event has
+    // already reset $isProgressImageResolving, and timing alone cannot distinguish the two.
+    autoSwitchedImages.record(image_name);
+
     // With optimistic updates, we can immediately switch to the new image
     const selectedBoardId = selectSelectedBoardId(getState());
 
@@ -222,35 +264,70 @@ export const buildOnInvocationComplete = (
     }
   };
 
-  const getResultImageDTOs = async (data: S['InvocationCompleteEvent']): Promise<ImageDTO[]> => {
+  // getImageDTOSafe swallows fetch errors and returns null, which downstream is indistinguishable
+  // from "this node produced no image". onLookupFailure separates the two, naming the output that
+  // was lost so a re-delivery can fetch just that one again.
+  const getResultImageDTOs = async (
+    data: S['InvocationCompleteEvent'],
+    onLookupFailure: (imageName: string) => void,
+    retryNames: ReadonlySet<string> | null
+  ): Promise<ImageDTO[]> => {
     const { result } = data;
     const imageDTOs: ImageDTO[] = [];
+    const fetched = new Set<string>();
+    const fetch = async (imageName: string) => {
+      if (retryNames !== null && !retryNames.has(imageName)) {
+        return;
+      }
+      // A result can name the same image twice (an image collection concatenates its inputs
+      // without deduping). It is still one image: fetching it once keeps its board total counted
+      // once, and keeps the retry set — which is keyed by name — from re-admitting an occurrence
+      // that already landed.
+      if (fetched.has(imageName)) {
+        return;
+      }
+      fetched.add(imageName);
+      const imageDTO = await getImageDTOSafe(imageName);
+      if (imageDTO) {
+        imageDTOs.push(imageDTO);
+      } else {
+        onLookupFailure(imageName);
+      }
+    };
     for (const [_name, value] of objectEntries(result)) {
       if (isImageField(value)) {
-        const imageDTO = await getImageDTOSafe(value.image_name);
-        if (imageDTO) {
-          imageDTOs.push(imageDTO);
-        }
+        await fetch(value.image_name);
       } else if (isImageFieldCollection(value)) {
         for (const imageField of value) {
-          const imageDTO = await getImageDTOSafe(imageField.image_name);
-          if (imageDTO) {
-            imageDTOs.push(imageDTO);
-          }
+          await fetch(imageField.image_name);
         }
       }
     }
     return imageDTOs;
   };
 
-  const getResultVideoDTOs = async (data: S['InvocationCompleteEvent']): Promise<VideoDTO[]> => {
+  const getResultVideoDTOs = async (
+    data: S['InvocationCompleteEvent'],
+    onLookupFailure: (videoName: string) => void,
+    retryNames: ReadonlySet<string> | null
+  ): Promise<VideoDTO[]> => {
     const { result } = data;
     const videoDTOs: VideoDTO[] = [];
+    const fetched = new Set<string>();
     for (const [_name, value] of objectEntries(result)) {
       if (isVideoField(value)) {
+        if (retryNames !== null && !retryNames.has(value.video_name)) {
+          continue;
+        }
+        if (fetched.has(value.video_name)) {
+          continue;
+        }
+        fetched.add(value.video_name);
         const videoDTO = await getVideoDTOSafe(value.video_name);
         if (videoDTO) {
           videoDTOs.push(videoDTO);
+        } else {
+          onLookupFailure(value.video_name);
         }
       }
     }
@@ -266,12 +343,18 @@ export const buildOnInvocationComplete = (
   //      (DndImage onLoad) to clear them. When auto-switching to a video, the viewer swaps
   //      CurrentImagePreview for CurrentVideoPreview, which unmounts the stale progress overlay
   //      so the stuck "Saving video" spinner goes away on its own.
-  const addVideosToGallery = async (data: S['InvocationCompleteEvent']) => {
+  const addVideosToGallery = async (
+    data: S['InvocationCompleteEvent'],
+    onLookupFailure: (videoName: string) => void,
+    retryNames: ReadonlySet<string> | null
+  ) => {
+    // See addImagesToGallery: a retry does not redo the auto-switch.
+    const isRetry = retryNames !== null;
     if (nodeTypeDenylist.includes(data.invocation.type)) {
       return;
     }
 
-    const videoDTOs = await getResultVideoDTOs(data);
+    const videoDTOs = await getResultVideoDTOs(data, onLookupFailure, retryNames);
     if (videoDTOs.length === 0) {
       return;
     }
@@ -296,7 +379,7 @@ export const buildOnInvocationComplete = (
     dispatch(galleryApi.util.invalidateTags(getTagsToInvalidateForBoardAffectingMutation(affectedBoards)));
 
     const autoSwitch = selectAutoSwitch(getState());
-    if (!autoSwitch) {
+    if (!autoSwitch || isRetry) {
       return;
     }
 
@@ -308,6 +391,13 @@ export const buildOnInvocationComplete = (
     const { video_name } = lastVideoDTO;
     const board_id = lastVideoDTO.board_id ?? 'none';
 
+    // Both branches below auto-switch the selection to this video. Record that so the viewer's
+    // reveal effect can tell the handoff apart from a user's gallery click — this dispatch happens
+    // after an async DTO fetch, so it can land after the next render's first progress event has
+    // already reset $isProgressImageResolving, and timing alone cannot distinguish the two. The
+    // marker is keyed by gallery item name, which is polymorphic across images and videos.
+    autoSwitchedImages.record(video_name);
+
     // Selection is a polymorphic string[]; useGalleryItemDTO discriminates by filename extension.
     const selectedBoardId = selectSelectedBoardId(getState());
     if (board_id !== selectedBoardId) {
@@ -350,35 +440,122 @@ export const buildOnInvocationComplete = (
     }
   };
 
+  /**
+   * One pass over a completion event. `retryNames` is null for a first delivery and otherwise names
+   * the outputs an earlier delivery lost, restricting this pass to those.
+   *
+   * Returns the outputs whose lookup failed this time. Bookkeeping is done here, before the
+   * returned promise settles, so a duplicate waiting on it always observes the final state.
+   */
+  const deliver = async (
+    data: S['InvocationCompleteEvent'],
+    invocationKey: string,
+    retryNames: ReadonlySet<string> | null
+  ): Promise<void> => {
+    const isRetry = retryNames !== null;
+    const missingNames = new Set<string>();
+    const onLookupFailure = (itemName: string) => {
+      missingNames.add(itemName);
+    };
+
+    // A retry redoes the lost gallery work and nothing else: the rest of this handler is not
+    // idempotent against a *later* generation, because the canvas processing flag and
+    // $lastProgressEvent are global. Re-running them would end the spinner and blank the progress
+    // of whatever is running by then.
+    if (!isRetry) {
+      const nodeExecutionState = $nodeExecutionStates.get()[data.invocation_source_id];
+      const updatedNodeExecutionState = getUpdatedNodeExecutionStateOnInvocationComplete(
+        nodeExecutionState,
+        data,
+        completedInvocationKeysByItemId
+      );
+
+      if (nodeExecutionState && !updatedNodeExecutionState) {
+        log.trace(
+          { data } as JsonObject,
+          `Ignoring duplicate invocation complete (${data.invocation.type}, ${data.invocation_source_id})`
+        );
+      }
+
+      if (updatedNodeExecutionState) {
+        upsertExecutionState(updatedNodeExecutionState.nodeId, updatedNodeExecutionState);
+      }
+
+      // Clear canvas workflow integration processing state if needed
+      clearCanvasWorkflowIntegrationProcessing(data);
+    }
+
+    try {
+      // Add images to gallery (canvas workflow integration results go to staging area automatically)
+      await addImagesToGallery(data, onLookupFailure, retryNames);
+      await addVideosToGallery(data, onLookupFailure, retryNames);
+
+      if (!isRetry) {
+        $lastProgressEvent.set(null);
+      }
+    } catch (error) {
+      // Both call sites discard this handler's promise, so a throw here would surface as an
+      // unhandled rejection and nothing else. Log it and let the bookkeeping below run: the
+      // outputs whose lookups failed are still worth recording as retryable.
+      log.error({ data, error } as JsonObject, `Error handling invocation complete: ${String(error)}`);
+    } finally {
+      if (missingNames.size > 0) {
+        processedInvocations.set(invocationKey, { status: 'retryable', missingNames });
+      }
+    }
+  };
+
   return async (data: S['InvocationCompleteEvent']) => {
     log.debug({ data } as JsonObject, `Invocation complete (${data.invocation.type}, ${data.invocation_source_id})`);
 
-    const nodeExecutionState = $nodeExecutionStates.get()[data.invocation_source_id];
-    const updatedNodeExecutionState = getUpdatedNodeExecutionStateOnInvocationComplete(
-      nodeExecutionState,
-      data,
-      completedInvocationKeysByItemId
-    );
-
-    if (nodeExecutionState && !updatedNodeExecutionState) {
+    const invocationKey = `${data.item_id}:${data.invocation.id}`;
+    const logDuplicate = () => {
       log.trace(
         { data } as JsonObject,
         `Ignoring duplicate invocation complete (${data.invocation.type}, ${data.invocation_source_id})`
       );
-    }
+    };
 
-    if (updatedNodeExecutionState) {
-      upsertExecutionState(updatedNodeExecutionState.nodeId, updatedNodeExecutionState);
+    // A duplicate that lands while the first delivery is still fetching waits for it rather than
+    // being discarded: if that delivery lost outputs to failed lookups, this duplicate is the only
+    // thing that can recover them — nothing re-emits the event on its own. This check must come
+    // before the 'done' one, which the in-flight delivery has already written by now.
+    //
+    // Several duplicates can be waiting here at once. They resume one at a time, and the first to
+    // find work marks the event 'done' again before it suspends, so the rest fall through to the
+    // duplicate branch rather than starting parallel retries.
+    const inFlight = inFlightDeliveries.get(invocationKey);
+    if (inFlight) {
+      await inFlight;
+      if (processedInvocations.get(invocationKey)?.status !== 'retryable') {
+        logDuplicate();
+        return;
+      }
+    } else if (processedInvocations.get(invocationKey)?.status === 'done') {
+      logDuplicate();
+      return;
     }
 
-    // Clear canvas workflow integration processing state if needed
-    clearCanvasWorkflowIntegrationProcessing(data);
-
-    // Add images to gallery (canvas workflow integration results go to staging area automatically)
-    await addImagesToGallery(data);
-    await addVideosToGallery(data);
-
-    $lastProgressEvent.set(null);
+    const state = processedInvocations.get(invocationKey);
+    const retryNames = state?.status === 'retryable' ? state.missingNames : null;
+    // Mark before the awaits below so a duplicate cannot start a second pass over the same outputs
+    // while this one is in flight; the handshake above is what lets it retry afterwards instead.
+    processedInvocations.set(invocationKey, { status: 'done' });
+
+    const delivery = deliver(data, invocationKey, retryNames);
+    // Waiters only need to know when the pass finished, not whether it threw.
+    const settled = delivery.then(
+      () => undefined,
+      () => undefined
+    );
+    inFlightDeliveries.set(invocationKey, settled);
+    try {
+      await delivery;
+    } finally {
+      if (inFlightDeliveries.get(invocationKey) === settled) {
+        inFlightDeliveries.delete(invocationKey);
+      }
+    }
   };
 };