@@ -46,6 +46,10 @@ export class PreviewManager extends Context.Service<
     readonly markHeadless: (
       input: PreviewCloseInput & { readonly tabId: string },
     ) => Effect.Effect<void, PreviewError>;
+    /** Publishes the tab's unchanged snapshot again, for clients that dropped the tab. */
+    readonly announce: (
+      input: PreviewCloseInput & { readonly tabId: string },
+    ) => Effect.Effect<void, PreviewError>;
     readonly requestReveal: (
       input: PreviewCloseInput & { readonly tabId: string; readonly force: boolean },
     ) => Effect.Effect<void, PreviewError>;
@@ -298,6 +302,28 @@ export const make = Effect.gen(function* PreviewManagerMake() {
     );
   });
 
+  const announce: PreviewManager["Service"]["announce"] = Effect.fn("PreviewManager.announce")(
+    function* (input) {
+      return yield* mutateExistingSession(
+        input.threadId,
+        input.tabId,
+        Effect.fn("PreviewManager.announceSession")(function* (session) {
+          return {
+            next: session,
+            emit: {
+              type: "resized",
+              threadId: session.threadId,
+              tabId: session.tabId,
+              createdAt: yield* currentIsoTimestamp,
+              snapshot: session.snapshot,
+            },
+            result: undefined,
+          };
+        }),
+      );
+    },
+  );
+
   const resize: PreviewManager["Service"]["resize"] = Effect.fn("PreviewManager.resize")(
     function* (input) {
       return yield* mutateExistingSession(
@@ -452,6 +478,7 @@ export const make = Effect.gen(function* PreviewManagerMake() {
     requestReveal,
     reportStatus,
     markHeadless,
+    announce,
     resize,
     adjust,
     close,
 
@@ -321,6 +321,9 @@ const desktopRenders = (tabId: string) => {
   }
   return desktopTabs.has(tabId);
 };
+/** When set, a desktop that has not attached a tab waits for it the way the real channel does. */
+let desktopAttachesLate = false;
+let desktopAttachWaiting = Promise.withResolvers<void>();
 const shownDesktopTabs = new Set<string>();
 const releasedDesktopTabs: Array<string> = [];
 const desktopTurns = new NodeEvents.EventEmitter();
@@ -355,7 +358,30 @@ const dependencies = Layer.mergeAll(
   }),
   Layer.succeed(DesktopChannel.DesktopBrowserChannel, {
     available: true,
-    awaitAttached: (key) => Effect.sync(() => desktopRenders(key.tabId)),
+    awaitAttached: (key, timeout) =>
+      !desktopAttachesLate || desktopRenders(key.tabId)
+        ? Effect.sync(() => desktopRenders(key.tabId))
+        : Effect.raceFirst(
+            Stream.callback<string>((queue) =>
+              Effect.acquireRelease(
+                Effect.sync(() => {
+                  const onAttach = (attached: { tabId: string }) =>
+                    Queue.offerUnsafe(queue, attached.tabId);
+                  desktopDetaches.on("attach", onAttach);
+                  return onAttach;
+                }),
+                (onAttach) => Effect.sync(() => desktopDetaches.off("attach", onAttach)),
+              ),
+            ).pipe(
+              Stream.filter((tabId) => tabId === key.tabId),
+              Stream.runHead,
+              Effect.as(true),
+            ),
+            Effect.sync(() => desktopAttachWaiting.resolve()).pipe(
+              Effect.andThen(Effect.sleep(timeout)),
+              Effect.as(false),
+            ),
+          ),
     detached: Stream.callback<{ threadId: string; tabId: string }>((queue) =>
       Effect.acquireRelease(
         Effect.sync(() => {
@@ -460,6 +486,8 @@ beforeEach(() => {
   desktopTabs.clear();
   shownDesktopTabs.clear();
   desktopRendersNext = false;
+  desktopAttachesLate = false;
+  desktopAttachWaiting = Promise.withResolvers<void>();
   desktopPageUrl = "about:blank";
   desktopSizeAnswer = null;
   desktopDetachReady = Promise.withResolvers<void>();
@@ -627,6 +655,63 @@ it.effect("a tab the desktop does not draw is marked headless, so the desktop st
   ).pipe(Effect.provide(layer)),
 );
 
+it.effect("an agent's tab the reloaded desktop dropped goes back to the desktop", () =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const { broker } = yield* ready;
+      const manager = yield* Manager.PreviewManager;
+      const threadId = scope.thread.threadId;
+      desktopRendersNext = true;
+      const opened = yield* broker.invoke<PreviewAutomationStatus>({
+        scope,
+        operation: "open",
+        input: { url: "https://example.com/?t=1", reuseExistingTab: false, open: false },
+      });
+      const tabId = PreviewTabId.make(opened.tabId!);
+      // The renderer reloads on another thread: its webview goes, and it only mounts this
+      // thread's tabs again once a preview event for the thread reaches it.
+      yield* Effect.promise(() => desktopDetachReady.promise);
+      desktopAttachesLate = true;
+      desktopTabs.delete(tabId);
+      desktopDetaches.emit("detach", { threadId, tabId });
+      yield* Effect.promise(() => desktopReleased.promise);
+      // It is still reloading when the agent's call arrives, so it misses the first event.
+      yield* Effect.gen(function* () {
+        yield* Effect.promise(() => desktopAttachWaiting.promise);
+        const events = yield* manager.subscribeEvents;
+        const nextForThread = Effect.gen(function* () {
+          let event = yield* PubSub.take(events);
+          while (event.threadId !== threadId) event = yield* PubSub.take(events);
+        });
+        yield* nextForThread;
+        yield* nextForThread;
+        desktopTabs.add(tabId);
+        desktopDetaches.emit("attach", { threadId, tabId });
+      }).pipe(Effect.forkScoped);
+
+      const evaluating = yield* broker
+        .invoke({
+          scope,
+          tabId,
+          operation: "evaluate",
+          input: { expression: "navigator.userAgent" },
+        })
+        .pipe(Effect.forkScoped);
+      yield* Effect.raceFirst(
+        Fiber.join(evaluating),
+        Effect.promise(() => desktopAttachWaiting.promise).pipe(
+          Effect.andThen(TestClock.adjust("10 seconds")),
+          Effect.andThen(Fiber.join(evaluating)),
+        ),
+      );
+      const { sessions } = yield* manager.list({ threadId });
+
+      expect(sessions.find((session) => session.tabId === tabId)?.headless).toBeUndefined();
+      expect(desktopConnections).toHaveLength(2);
+    }),
+  ).pipe(Effect.provide(layer)),
+);
+
 it.effect("a desktop page that loaded before the server attached reports its loaded title", () =>
   Effect.scoped(
     Effect.gen(function* () {
 
@@ -766,10 +766,17 @@ const make = Effect.gen(function* () {
   const desktopRenders = (snapshot: PreviewSessionSnapshot) =>
     desktopChannel.available && !snapshot.headless
       ? runPromise(
-          desktopChannel.awaitAttached(
-            { threadId: snapshot.threadId, tabId: snapshot.tabId },
-            DESKTOP_ATTACH_TIMEOUT,
-          ),
+          Effect.gen(function* () {
+            const key = { threadId: snapshot.threadId, tabId: snapshot.tabId };
+            // A reloaded desktop mounts a thread's tabs again only once an event for it arrives,
+            // and a renderer still reloading misses events, so repeat it until the wait ends.
+            if (!(yield* desktopChannel.isAttached(key))) {
+              yield* manager
+                .announce({ threadId: ThreadId.make(key.threadId), tabId: key.tabId })
+                .pipe(Effect.ignore, Effect.repeat(Schedule.spaced("1 second")), Effect.forkScoped);
+            }
+            return yield* desktopChannel.awaitAttached(key, DESKTOP_ATTACH_TIMEOUT);
+          }).pipe(Effect.scoped),
         )
       : Promise.resolve(false);