@@ -41,4 +41,5 @@ export const REACT_COMPILED_FILES = [
   "apps/web/src/components/pullRequest/usePullRequestFilesViewed.ts",
   "apps/web/src/hooks/useLiveRefresh.ts",
   "apps/web/src/browser/useBrowserViewportResize.ts",
+  "apps/web/src/components/desktop/SnapShotCoordinator.tsx",
 ] as const;
@@ -3,14 +3,15 @@ import {
   PROVIDER_SEND_TURN_MAX_IMAGE_BYTES,
   type ScopedThreadRef,
 } from "@t3tools/contracts";
-import { useCallback, useEffect, useRef } from "react";
+import { useEffect, useRef, useState } from "react";
 
 import {
   type DraftId,
   type PersistedComposerImageAttachment,
   useComposerDraftStore,
 } from "../../composerDraftStore";
 import { useHandleNewThread } from "../../hooks/useHandleNewThread";
+import { useStableCallback } from "../../hooks/useStableCallback";
 import { useClientSettings } from "../../hooks/useSettings";
 import { readThreadShell } from "../../state/entities";
 import { compressImageToByteLimit, dataUrlToFile } from "../../lib/imageCompression";
@@ -36,6 +37,11 @@ import { stackedThreadToast, toastManager } from "../ui/toast";
 
 type CaptureTarget = DraftId | ScopedThreadRef;
 
+function isSameCaptureTarget(a: CaptureTarget, b: CaptureTarget): boolean {
+  if (typeof a === "string" || typeof b === "string") return a === b;
+  return a.environmentId === b.environmentId && a.threadId === b.threadId;
+}
+
 export function resolveExistingSnapShotTarget(
   target: CaptureTarget,
   routeThreadRef: ScopedThreadRef | null,
@@ -207,25 +213,44 @@ export function SnapShotCoordinator() {
   );
   const animateCaptures = useClientSettings((settings) => settings.snapShotAnimations);
   const captureTargetsRef = useRef(new Map<string, Promise<CaptureTarget | null>>());
-  const lastTargetRef = useRef<CaptureTarget | null>(null);
   const targetResolutionRef = useRef<Promise<CaptureTarget | null> | null>(null);
   const drainingRef = useRef<Promise<void> | null>(null);
   const rerunRequestedRef = useRef(false);
   const soundedCaptureIdsRef = useRef(new Set<string>());
   const pendingAnimationStartsRef = useRef(new Set<string>());
 
+  // Captures go to the last thread or draft on screen, even from routes that show neither.
   const currentTarget = routeThreadRef ?? routeDraftId;
-  if (currentTarget) lastTargetRef.current = currentTarget;
+  const [lastRouteTarget, setLastRouteTarget] = useState(currentTarget);
+  if (
+    currentTarget &&
+    (lastRouteTarget === null || !isSameCaptureTarget(currentTarget, lastRouteTarget))
+  ) {
+    setLastRouteTarget(currentTarget);
+  }
+  // What a resolution settled on (a promoted draft, a new draft, or nothing) stands in for the
+  // route's target until the route moves on, so captures in one drain share one new draft.
+  const settledTargetRef = useRef<{
+    readonly routeTarget: CaptureTarget | null;
+    readonly target: CaptureTarget | null;
+  } | null>(null);
+  const readLastTarget = useStableCallback(() => {
+    const settled = settledTargetRef.current;
+    return settled && settled.routeTarget === lastRouteTarget ? settled.target : lastRouteTarget;
+  });
+  const settleLastTarget = useStableCallback((target: CaptureTarget | null) => {
+    settledTargetRef.current = { routeTarget: lastRouteTarget, target };
+  });
 
-  const resolveTarget = useCallback(async (): Promise<CaptureTarget | null> => {
-    const lastTarget = lastTargetRef.current;
+  const resolveTarget = async (): Promise<CaptureTarget | null> => {
+    const lastTarget = readLastTarget();
     if (lastTarget) {
       const existingTarget = resolveExistingSnapShotTarget(lastTarget, routeThreadRef);
       if (existingTarget) {
-        lastTargetRef.current = existingTarget;
+        settleLastTarget(existingTarget);
         return existingTarget;
       }
-      lastTargetRef.current = null;
+      settleLastTarget(null);
     }
     const projectRef = resolveThreadActionProjectRef({
       activeDraftThread,
@@ -236,27 +261,21 @@ export function SnapShotCoordinator() {
     if (!projectRef) return null;
     const created = await handleNewThread(projectRef);
     if (!created) return null;
-    lastTargetRef.current = created.draftId;
+    settleLastTarget(created.draftId);
     return created.draftId;
-  }, [activeDraftThread, activeThread, defaultProjectRef, handleNewThread, routeThreadRef]);
+  };
 
-  const resolveCaptureTarget = useCallback(
-    () => resolveSnapShotTargetOnce(targetResolutionRef, resolveTarget),
-    [resolveTarget],
-  );
+  const resolveCaptureTarget = () => resolveSnapShotTargetOnce(targetResolutionRef, resolveTarget);
 
-  const playCaptureSound = useCallback(
-    (id: string) => {
-      if (!captureSound || soundedCaptureIdsRef.current.has(id)) return;
-      soundedCaptureIdsRef.current.add(id);
-      try {
-        playSnapShotSound(captureSound);
-      } catch {}
-    },
-    [captureSound],
-  );
+  const playCaptureSound = (id: string) => {
+    if (!captureSound || soundedCaptureIdsRef.current.has(id)) return;
+    soundedCaptureIdsRef.current.add(id);
+    try {
+      playSnapShotSound(captureSound);
+    } catch {}
+  };
 
-  const drain = useCallback(async () => {
+  const drain = async () => {
     const bridge = getDesktopSnapShotBridge();
     if (!bridge) return;
     if (drainingRef.current) {
@@ -326,7 +345,7 @@ export function SnapShotCoordinator() {
       });
     drainingRef.current = operation;
     return operation;
-  }, [playCaptureSound, resolveCaptureTarget, routeThreadRef]);
+  };
 
   useEffect(() => {
     const bridge = getDesktopSnapShotBridge();
@@ -335,7 +354,7 @@ export function SnapShotCoordinator() {
     const unsubscribe = bridge.onSnapShotEvent((event) => {
       switch (event.type) {
         case "requested": {
-          const current = lastTargetRef.current;
+          const current = readLastTarget();
           const target = current ? resolveExistingSnapShotTarget(current, routeThreadRef) : null;
           // Creating a new draft would navigate the renderer before a self-capture finishes.
           if (target) {
@@ -386,7 +405,14 @@ export function SnapShotCoordinator() {
       }
     });
     return unsubscribe;
-  }, [animateCaptures, drain, playCaptureSound, resolveCaptureTarget, routeThreadRef]);
+  }, [
+    animateCaptures,
+    drain,
+    playCaptureSound,
+    readLastTarget,
+    resolveCaptureTarget,
+    routeThreadRef,
+  ]);
 
   useEffect(() => {
     const dismissOnBlur = () => {