@@ -4542,6 +4542,9 @@ export default function ChatView(props: ChatViewProps) {
     (surfaces: readonly RightPanelSurface[]) => {
       if (!activeThreadRef) return;
       for (const surface of surfaces) {
+        // Without preview access only the local surface goes away. The
+        // server record is in-memory bookkeeping, not a live view, and stays
+        // listed until a client with the scope closes it or the server restarts.
         if (canOperatePreview && surface.kind === "preview" && surface.resourceId) {
           void closePreviewSession({
             closePreview,
 
@@ -580,12 +580,11 @@ describe("PreviewView navigation", () => {
       createdAt: "2026-09-05T00:00:00.000Z",
     };
     const onSendAnnotation = vi.fn();
-    mocks.pickElement.mockResolvedValue({ annotation, submission: "send" });
-    let finishCapture: (() => void) | undefined;
-    mocks.capturePreviewAnnotationScreenshot.mockImplementationOnce(
+    let submitPick: (() => void) | undefined;
+    mocks.pickElement.mockImplementationOnce(
       () =>
         new Promise((resolve) => {
-          finishCapture = () => resolve({ status: "none" });
+          submitPick = () => resolve({ annotation, submission: "send" });
         }),
     );
     const document = installTestDom();
@@ -602,19 +601,20 @@ describe("PreviewView navigation", () => {
     try {
       await act(async () => root.render(view()));
       await act(async () => mocks.toggleAnnotation?.());
-      expect(finishCapture).toBeDefined();
+      expect(submitPick).toBeDefined();
       expect(mocks.setAnnotationSendEnabled).toHaveBeenLastCalledWith(TEST_RUNTIME_TAB_ID, true);
 
       mocks.readEnvironmentScope.mockImplementation(
         (environmentId?: unknown) => environmentId !== TEST_THREAD_REF.environmentId,
       );
       await act(async () => root.render(view()));
       expect(mocks.setAnnotationSendEnabled).toHaveBeenLastCalledWith(TEST_RUNTIME_TAB_ID, false);
-      await act(async () => finishCapture!());
+      await act(async () => submitPick!());
       expect(mocks.addPreviewAnnotation).toHaveBeenCalledWith(TEST_THREAD_REF, annotation);
       expect(onSendAnnotation).not.toHaveBeenCalled();
 
       mocks.readEnvironmentScope.mockReturnValue(true);
+      mocks.pickElement.mockResolvedValue({ annotation, submission: "send" });
       await act(async () => root.render(view()));
       await act(async () => mocks.toggleAnnotation?.());
       expect(mocks.setAnnotationSendEnabled).toHaveBeenLastCalledWith(TEST_RUNTIME_TAB_ID, true);
@@ -625,6 +625,48 @@ describe("PreviewView navigation", () => {
     }
   });
 
+  it("keeps a submitted annotation when the picker is toggled during capture", async () => {
+    const annotation = {
+      id: "annotation-submitted",
+      pageUrl: "https://example.com/dashboard",
+      pageTitle: "Dashboard",
+      comment: "Tighten this spacing",
+      elements: [],
+      regions: [],
+      strokes: [],
+      styleChanges: [],
+      screenshot: null,
+      createdAt: "2026-09-05T00:00:00.000Z",
+    };
+    mocks.pickElement.mockResolvedValue({ annotation, submission: "attach" });
+    let finishCapture: (() => void) | undefined;
+    mocks.capturePreviewAnnotationScreenshot.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          finishCapture = () => resolve({ status: "none" });
+        }),
+    );
+    const document = installTestDom();
+    const { createRoot } = await import("react-dom/client");
+    const root = createRoot(document.createElement("div") as unknown as Element);
+    try {
+      await act(async () =>
+        root.render(<PreviewView threadRef={TEST_THREAD_REF} tabId="tab-1" visible />),
+      );
+      await act(async () => mocks.toggleAnnotation?.());
+      expect(finishCapture).toBeDefined();
+      // The pick is no longer active once the guest has submitted, so this
+      // starts a new pick instead of cancelling the submitted one.
+      await act(async () => mocks.toggleAnnotation?.());
+      expect(mocks.cancelPickElement).not.toHaveBeenCalled();
+      await act(async () => finishCapture!());
+      expect(mocks.addPreviewAnnotation).toHaveBeenCalledWith(TEST_THREAD_REF, annotation);
+    } finally {
+      await act(async () => root.unmount());
+      vi.unstubAllGlobals();
+    }
+  });
+
   it("does not reopen a cancelled picker after the permission update finishes", async () => {
     let finishUpdate: (() => void) | undefined;
     mocks.setAnnotationSendEnabled.mockImplementationOnce(
 
@@ -594,6 +594,7 @@ export function PreviewView({
     const previouslyFocused =
       typeof document !== "undefined" ? (document.activeElement as HTMLElement | null) : null;
     const pickRequest = { cancelled: false };
+    let submitted = false;
     pickActiveRef.current = pickRequest;
     setPickActive(true);
     void (async () => {
@@ -606,14 +607,21 @@ export function PreviewView({
         if (pickRequest.cancelled) return;
         const result = await previewBridge.pickElement(runtimeTabId);
         if (!result || pickRequest.cancelled) return;
+        // The user has submitted. Nothing that happens after this point (a
+        // second picker click, a tab change, unmount) may discard it, so the
+        // pick stops being cancellable here rather than in `finally`.
+        if (pickActiveRef.current === pickRequest) {
+          pickActiveRef.current = null;
+          if (isMountedRef.current) setPickActive(false);
+          submitted = true;
+        }
         const { annotation: picked, submission, screenshotFailed = false } = result;
         // The structured annotation is still sendable when its optional crop
         // stalls or fails, so tell the user what they lost and keep going
         // instead of holding the composer for an attachment that never lands.
         // The stored copy drops the screenshot on failure, otherwise the prompt
         // would tell the agent a crop is attached when none was sent.
         const capture = await capturePreviewAnnotationScreenshot(picked);
-        if (pickRequest.cancelled) return;
         // Main reports a crop that failed or timed out on its side; the local
         // conversion can fail too. Either way the user should hear about it.
         const cropDropped = screenshotFailed || capture.status === "failed";
@@ -655,9 +663,10 @@ export function PreviewView({
       } catch {
         // Picker failed (e.g. webview navigated). Treat as silent cancel.
       } finally {
+        // A submitted pick already released itself above; a cancelled or
+        // failed one releases here. Avoid `setState on unmounted component`
+        // if the panel/thread closed while the pick was in flight.
         const isCurrentPick = pickActiveRef.current === pickRequest;
-        // Avoid `setState on unmounted component` if the panel/thread closed
-        // while the pick was in flight.
         if (isCurrentPick) {
           pickActiveRef.current = null;
           if (isMountedRef.current) setPickActive(false);
@@ -666,7 +675,7 @@ export function PreviewView({
         // pick stole it into the guest webContents. Skip if the previously-
         // focused element was unmounted or is no longer focusable.
         if (
-          isCurrentPick &&
+          (isCurrentPick || submitted) &&
           previouslyFocused &&
           previouslyFocused.isConnected &&
           typeof previouslyFocused.focus === "function"