@@ -722,7 +722,7 @@ describe("PreviewManager", () => {
   );
 
   effectIt.effect(
-    "hosts an agent tab in a never-shown window that paints and closes with the tab",
+    "hosts an agent tab in a never-shown window until a panel webview takes it over",
     () =>
       withManager((manager) =>
         Effect.gen(function* () {
@@ -767,6 +767,15 @@ describe("PreviewManager", () => {
           });
           expect(state.webContentsId).toBe(55);
           expect(loadURL).toHaveBeenCalledWith("https://example.com/agent");
+          // Back on screen, the renderer moves the tab into a panel webview.
+          fromId.mockReturnValue(
+            makeTestPreviewWebContents(async () => ({
+              toJPEG: () => Buffer.from(""),
+              getSize: () => ({ width: 1, height: 1 }),
+            })),
+          );
+          yield* manager.registerWebview("tab_agent", 42);
+          expect(window.destroy).toHaveBeenCalledOnce();
           yield* manager.closeTab("tab_agent");
           expect(window.destroy).toHaveBeenCalledOnce();
         }),
 
@@ -2084,7 +2084,10 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function
     const expectedGeneration = tabLifecycleGenerations.get(tabId);
     return yield* withTabLifecycleLock(
       tabId,
-      registerWebviewUnlocked(tabId, webContentsId, expectedGeneration),
+      registerWebviewUnlocked(tabId, webContentsId, expectedGeneration).pipe(
+        // The renderer moved a background tab into the panel once T3 was on screen again.
+        Effect.tap(() => Effect.sync(() => closeBackgroundWindow(tabId))),
+      ),
     );
   });
 
 
@@ -218,6 +218,9 @@ describe("ElectronBrowserHost", () => {
           url: `https://example.com/${tabId}`,
         });
         expect(screen.container.querySelectorAll("webview")).toHaveLength(0);
+        // Back on screen, the tab moves into the panel, where every desktop tool works.
+        await act(() => window.dispatchEvent(new Event("focus")));
+        expect(screen.container.querySelectorAll("webview")).toHaveLength(1);
       }
     },
   );
 
@@ -31,13 +31,20 @@ import { useBrowserPointerStore } from "./browserPointerStore";
 import { HostedBrowserWebview } from "./HostedBrowserWebview";
 import { openUrlInPreview } from "./openFileInPreview";
 import { acquireDesktopTab } from "./desktopTabLifetime";
-import { hostsServerTabInBackground, rendersServerTabNatively } from "./previewRuntime";
+import {
+  type BackgroundHosting,
+  hostsServerTabInBackground,
+  readBackgroundHosting,
+  rendersServerTabNatively,
+  useBackgroundHosting,
+} from "./previewRuntime";
 import { previewRuntimeTabId } from "./previewRuntimeTabId";
 
 /** Every session this window renders as a hosted webview, in a fixed (non-display) order. */
 function hostedBrowserSessions(
   previewByThreadKey: Record<string, ThreadPreviewState>,
   primaryEnvironmentId: EnvironmentId | null,
+  hosting: BackgroundHosting,
 ) {
   const activeSessions = Object.entries(previewByThreadKey).flatMap(([threadKey, previewState]) => {
     const threadRef = parseScopedThreadKey(threadKey);
@@ -46,8 +53,18 @@ function hostedBrowserSessions(
           .filter(
             (snapshot) =>
               snapshot.runtime !== "server" ||
-              rendersServerTabNatively(threadRef.environmentId, primaryEnvironmentId, snapshot) ||
-              hostsServerTabInBackground(threadRef.environmentId, primaryEnvironmentId, snapshot),
+              rendersServerTabNatively(
+                threadRef.environmentId,
+                primaryEnvironmentId,
+                snapshot,
+                hosting,
+              ) ||
+              hostsServerTabInBackground(
+                threadRef.environmentId,
+                primaryEnvironmentId,
+                snapshot,
+                hosting,
+              ),
           )
           .map((snapshot) => ({
             threadRef,
@@ -56,6 +73,7 @@ function hostedBrowserSessions(
               threadRef.environmentId,
               primaryEnvironmentId,
               snapshot,
+              hosting,
             ),
             runtimeTabId: previewRuntimeTabId(threadRef, previewState.serverEpoch, snapshot.tabId),
             pictureInPicture:
@@ -106,6 +124,7 @@ function openLinkInPreview({ tabId, url, background }: DesktopPreviewOpenLinkEve
   const source = hostedBrowserSessions(
     readActivePreviewSessions(),
     appAtomRegistry.get(primaryEnvironmentIdAtom),
+    readBackgroundHosting(),
   ).find((session) => session.runtimeTabId === tabId);
   if (!source) return;
   void openUrlInPreview({
@@ -137,7 +156,11 @@ export function ElectronBrowserHost() {
   const previewByThreadKey = useActivePreviewSessions();
   const primaryEnvironmentId = useAtomValue(primaryEnvironmentIdAtom);
   useDesktopHostedPreviewSessions(primaryEnvironmentId);
-  const sessions = hostedBrowserSessions(previewByThreadKey, primaryEnvironmentId);
+  const sessions = hostedBrowserSessions(
+    previewByThreadKey,
+    primaryEnvironmentId,
+    useBackgroundHosting(),
+  );
 
   if (!isElectron) return null;
   return (
 
@@ -1,4 +1,5 @@
 import { useAtomValue } from "@effect/atom-react";
+import { useSyncExternalStore } from "react";
 import type { EnvironmentId, PreviewRuntime, PreviewSessionSnapshot } from "@t3tools/contracts";
 
 import { isElectron } from "~/env";
@@ -61,17 +62,47 @@ function desktopHostsServerTab(
   );
 }
 
-// Fixed when a tab first appears: moving a page between hosts would replace it.
-const backgroundHostedTabs = new Map<string, boolean>();
+// Fixed when a tab first appears, until T3 is on screen again: moving a page between hosts replaces it.
+let backgroundHostedTabs = new Map<string, boolean>();
+const hostingListeners = new Set<() => void>();
+
+// Its window takes focus when T3 is shown again. Background tabs then move to panel webviews, where
+// every desktop tool works, and a new map makes memoized callers look again.
+const returnBackgroundTabsToPanel = () => {
+  if (![...backgroundHostedTabs.values()].some(Boolean)) return;
+  backgroundHostedTabs = new Map([...backgroundHostedTabs.keys()].map((key) => [key, false]));
+  for (const listener of hostingListeners) listener();
+};
+
+const subscribeBackgroundHosting = (listener: () => void) => {
+  hostingListeners.add(listener);
+  if (hostingListeners.size === 1) window.addEventListener("focus", returnBackgroundTabsToPanel);
+  return () => {
+    hostingListeners.delete(listener);
+    if (hostingListeners.size === 0) {
+      window.removeEventListener("focus", returnBackgroundTabsToPanel);
+    }
+  };
+};
+
+export type BackgroundHosting = ReadonlyMap<string, boolean>;
+
+export const readBackgroundHosting = (): BackgroundHosting => backgroundHostedTabs;
+
+export function useBackgroundHosting(): BackgroundHosting {
+  return useSyncExternalStore(subscribeBackgroundHosting, readBackgroundHosting);
+}
 
 /**
  * A panel `<webview>` created while the app window is hidden or minimized never paints, so an
  * agent tab that appears then runs in a never-shown desktop window and the panel streams it.
+ * `hosting` is the map from `useBackgroundHosting`, passed so memoized callers recompute.
  */
 export function hostsServerTabInBackground(
   environmentId: EnvironmentId,
   primaryEnvironmentId: EnvironmentId | null,
   snapshot: RuntimeSnapshot | null | undefined,
+  hosting: BackgroundHosting,
 ): boolean {
   if (
     !snapshot ||
@@ -81,28 +112,33 @@ export function hostsServerTabInBackground(
     return false;
   }
   const key = `${environmentId}\u0000${snapshot.threadId}\u0000${snapshot.tabId}`;
-  let background = backgroundHostedTabs.get(key);
-  if (background === undefined) {
-    background = window.desktopBridge?.getWindowShown?.() === false;
-    backgroundHostedTabs.set(key, background);
-  }
+  const decided = backgroundHostedTabs.get(key) ?? hosting.get(key);
+  if (decided !== undefined) return decided;
+  const background = window.desktopBridge?.getWindowShown?.() === false;
+  backgroundHostedTabs.set(key, background);
   return background;
 }
 
 export function rendersServerTabNatively(
   environmentId: EnvironmentId,
   primaryEnvironmentId: EnvironmentId | null,
   snapshot: RuntimeSnapshot | null | undefined,
+  hosting: BackgroundHosting,
 ): boolean {
   return (
     desktopHostsServerTab(environmentId, primaryEnvironmentId, snapshot) &&
-    !hostsServerTabInBackground(environmentId, primaryEnvironmentId, snapshot)
+    !hostsServerTabInBackground(environmentId, primaryEnvironmentId, snapshot, hosting)
   );
 }
 
 export function useRendersServerTabNatively(
   environmentId: EnvironmentId,
   snapshot: RuntimeSnapshot | null | undefined,
 ): boolean {
-  return rendersServerTabNatively(environmentId, useAtomValue(primaryEnvironmentIdAtom), snapshot);
+  return rendersServerTabNatively(
+    environmentId,
+    useAtomValue(primaryEnvironmentIdAtom),
+    snapshot,
+    useBackgroundHosting(),
+  );
 }
@@ -24,7 +24,7 @@ import {
 import { useBrowserSurfaceStore } from "~/browser/browserSurfaceStore";
 import type { BrowserViewportResizeDirection } from "~/browser/browserViewportLayout";
 import { previewRuntimeTabId } from "~/browser/previewRuntimeTabId";
-import { rendersServerTabNatively } from "~/browser/previewRuntime";
+import { rendersServerTabNatively, useBackgroundHosting } from "~/browser/previewRuntime";
 import { primaryEnvironmentIdAtom } from "~/state/primaryEnvironment";
 import { type ServerBrowserHandle, ServerBrowserSurface } from "~/browser/ServerBrowserSurface";
 import {
@@ -138,10 +138,16 @@ function useBrowserMiniPlayerSource(threadRef: ScopedThreadRef | null, tabId: st
     runtimeTabId === null ? null : (state.byTabId[runtimeTabId]?.fittedSourceContent ?? null),
   );
   const primaryEnvironmentId = useAtomValue(primaryEnvironmentIdAtom);
+  const backgroundHosting = useBackgroundHosting();
   const serverTab =
     threadRef !== null &&
     snapshot?.runtime === "server" &&
-    !rendersServerTabNatively(threadRef.environmentId, primaryEnvironmentId, snapshot);
+    !rendersServerTabNatively(
+      threadRef.environmentId,
+      primaryEnvironmentId,
+      snapshot,
+      backgroundHosting,
+    );
   const streamViewport = useStreamedSourceSize((state) =>
     threadRef &&
     tabId !== null &&