@@ -15,6 +15,7 @@ import {
   type DesktopBrowserCommand as DesktopBrowserCommandType,
 } from "@t3tools/contracts";
 import * as Context from "effect/Context";
+import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
@@ -46,8 +47,13 @@ export class DesktopBrowserChannel extends Context.Service<
   {
     /** False when this server was not started by a desktop app. */
     readonly available: boolean;
-    /** Desktop tabs as they attach and detach. */
-    readonly changes: Stream.Stream<{ readonly key: DesktopTabKey; readonly attached: boolean }>;
+    /**
+     * Waits for a tab to be attached. Subscribes before it checks, so an
+     * attach landing in between is never missed. False after `timeout`.
+     */
+    readonly awaitAttached: (key: DesktopTabKey, timeout: Duration.Input) => Effect.Effect<boolean>;
+    /** Desktop tabs as they detach. */
+    readonly detached: Stream.Stream<DesktopTabKey>;
     readonly isAttached: (key: DesktopTabKey) => Effect.Effect<boolean>;
     /**
      * A one-connection CDP endpoint for an attached tab. Closing the scope
@@ -70,7 +76,8 @@ export const make = Effect.gen(function* () {
   if (inputFd === undefined || controlFd === undefined) {
     return DesktopBrowserChannel.of({
       available: false,
-      changes: Stream.empty,
+      awaitAttached: () => Effect.succeed(false),
+      detached: Stream.empty,
       isAttached: () => Effect.succeed(false),
       endpoint: () => Effect.die("No desktop app is attached to this server."),
     });
@@ -180,7 +187,24 @@ export const make = Effect.gen(function* () {
 
   return DesktopBrowserChannel.of({
     available: true,
-    changes: Stream.fromPubSub(changes),
+    awaitAttached: (key, timeout) =>
+      Effect.scoped(
+        Effect.gen(function* () {
+          const subscription = yield* PubSub.subscribe(changes);
+          if (attachedTabs.has(keyOf(key))) return true;
+          return yield* Stream.fromSubscription(subscription).pipe(
+            Stream.filter((change) => change.attached && keyOf(change.key) === keyOf(key)),
+            Stream.runHead,
+            Effect.map(Option.isSome),
+            Effect.timeoutOption(timeout),
+            Effect.map((result) => Option.getOrElse(result, () => false)),
+          );
+        }),
+      ),
+    detached: Stream.fromPubSub(changes).pipe(
+      Stream.filter((change) => !change.attached),
+      Stream.map((change) => change.key),
+    ),
     isAttached: (key) => Effect.sync(() => attachedTabs.has(keyOf(key))),
     endpoint,
   });
@@ -193,7 +217,8 @@ export const layerNone = Layer.succeed(
   DesktopBrowserChannel,
   DesktopBrowserChannel.of({
     available: false,
-    changes: Stream.empty,
+    awaitAttached: () => Effect.succeed(false),
+    detached: Stream.empty,
     isAttached: () => Effect.succeed(false),
     endpoint: () => Effect.die("No desktop app is attached to this server."),
   }),
 
@@ -17,12 +17,14 @@ import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Queue from "effect/Queue";
+import * as Stream from "effect/Stream";
 import type { BrowserContext, Page } from "playwright-core";
 import { beforeEach, expect, vi } from "vite-plus/test";
 
 import * as ServerConfig from "../config.ts";
 import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
 import * as Broker from "../mcp/PreviewAutomationBroker.ts";
+import * as DesktopChannel from "./DesktopBrowserChannel.ts";
 import * as Manager from "./Manager.ts";
 import * as ServerBrowser from "./ServerBrowser.ts";
 import * as Toolchain from "./ServerBrowserToolchain.ts";
@@ -41,6 +43,14 @@ vi.mock("./ServerBrowserContexts.ts", () => ({
       contexts.push(context);
       return context as unknown as BrowserContext;
     }
+    async scratchPage() {
+      return makeContext().page as unknown as Page;
+    }
+    async connectDesktopPage(endpoint: string) {
+      const context = makeContext();
+      desktopConnections.push({ endpoint, context });
+      return { browser: { close: async () => {} }, page: context.page as unknown as Page };
+    }
     async close() {
       for (const context of contexts) await context.close();
     }
@@ -140,6 +150,20 @@ let contextGate: PromiseWithResolvers<void> | null = null;
 type ClipboardBinding = (source: { page: unknown }, text: unknown) => void;
 let clipboardBinding: ClipboardBinding | null = null;
 let contextFailure: Error | null = null;
+/** Server tabs the fake desktop renders, and the endpoints the server connected to. */
+let desktopRendersNext = false;
+/** Pages the fake desktop takes back; the channel's detached stream emits them. */
+const desktopDetaches = new NodeEvents.EventEmitter();
+const desktopTabs = new Set<string>();
+const desktopRenders = (tabId: string) => {
+  if (desktopRendersNext) {
+    desktopRendersNext = false;
+    desktopTabs.add(tabId);
+  }
+  return desktopTabs.has(tabId);
+};
+const releasedDesktopTabs: Array<string> = [];
+const desktopConnections: Array<{ endpoint: string; context: ReturnType<typeof makeContext> }> = [];
 const scope = {
   environmentId: EnvironmentId.make("browser-test-environment"),
   threadId: ThreadId.make("browser-test-thread"),
@@ -158,6 +182,27 @@ const dependencies = Layer.mergeAll(
   Layer.succeed(Toolchain.ServerBrowserToolchain, {
     resolve: Effect.die("mock Chromium does not need an executable"),
   }),
+  Layer.succeed(DesktopChannel.DesktopBrowserChannel, {
+    // Only tabs a test marks render on the desktop; the rest stay headless.
+    available: true,
+    awaitAttached: (key) => Effect.sync(() => desktopRenders(key.tabId)),
+    detached: Stream.callback<{ threadId: string; tabId: string }>((queue) =>
+      Effect.acquireRelease(
+        Effect.sync(() => {
+          const onDetach = (key: { threadId: string; tabId: string }) =>
+            Queue.offerUnsafe(queue, key);
+          desktopDetaches.on("detach", onDetach);
+          return onDetach;
+        }),
+        (onDetach) => Effect.sync(() => desktopDetaches.off("detach", onDetach)),
+      ),
+    ),
+    isAttached: (key) => Effect.sync(() => desktopRenders(key.tabId)),
+    endpoint: (key) =>
+      Effect.acquireRelease(Effect.succeed(`ws://desktop/${key.tabId}`), () =>
+        Effect.sync(() => releasedDesktopTabs.push(key.tabId)),
+      ),
+  }),
 ).pipe(
   Layer.provideMerge(ServerConfig.layerTest(process.cwd(), { prefix: "t3-server-browser-" })),
   Layer.provideMerge(NodeServices.layer),
@@ -188,6 +233,10 @@ beforeEach(() => {
   contexts.length = 0;
   contextGate = null;
   contextFailure = null;
+  desktopTabs.clear();
+  desktopRendersNext = false;
+  releasedDesktopTabs.length = 0;
+  desktopConnections.length = 0;
 });
 
 it.live("readiness none responds immediately but takeover input waits for navigation commit", () =>
@@ -865,3 +914,68 @@ it.live("viewers see the agent's pointer move to its target and click there", ()
     }),
   ).pipe(Effect.provide(layer)),
 );
+
+it.live("drives the desktop's own page for a tab the desktop renders", () =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const browser = yield* ServerBrowser.ServerBrowser;
+      const broker = yield* Broker.PreviewAutomationBroker;
+      const manager = yield* Manager.PreviewManager;
+      yield* Effect.yieldNow;
+      desktopRendersNext = true;
+      const opened = yield* manager.open({ threadId: scope.threadId, runtime: "server" });
+      const viewer = yield* browser.attachViewer(viewerInput(opened.tabId, true));
+      expect(desktopConnections.map((connection) => connection.endpoint)).toEqual([
+        `ws://desktop/${opened.tabId}`,
+      ]);
+      // No headless context was launched for it.
+      expect(contexts).toEqual([]);
+      const page = desktopConnections[0]!.context.page;
+      // The desktop panel sizes its page, so a viewer resize leaves it alone.
+      yield* viewer.input({ type: "takeControl" });
+      yield* viewer.input({ type: "resize", width: 390, height: 844 });
+      expect(page.setViewportSize).not.toHaveBeenCalled();
+      yield* viewer.input({ type: "releaseControl" });
+      // Agents reach it through the same engine as a headless tab.
+      const evaluated = yield* broker.invoke({
+        scope: { ...scope, providerSessionId: "agent-desktop" },
+        operation: "status",
+        input: {},
+        tabId: PreviewTabId.make(opened.tabId),
+      });
+      expect(evaluated).toMatchObject({ tabId: opened.tabId });
+      // Closing the session lets go of the desktop's page without closing it.
+      yield* manager.close({ threadId: scope.threadId, tabId: opened.tabId });
+      while (releasedDesktopTabs.length === 0) yield* Effect.yieldNow;
+      expect(releasedDesktopTabs).toEqual([opened.tabId]);
+      expect(page.close).not.toHaveBeenCalled();
+    }),
+  ).pipe(Effect.provide(layer)),
+);
+
+it.live("a desktop page the desktop takes back reconnects instead of closing", () =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const browser = yield* ServerBrowser.ServerBrowser;
+      const manager = yield* Manager.PreviewManager;
+      yield* Effect.yieldNow;
+      desktopRendersNext = true;
+      const opened = yield* manager.open({ threadId: scope.threadId, runtime: "server" });
+      const viewer = yield* browser.attachViewer(viewerInput(opened.tabId, false));
+      // Devtools opened on the desktop, so it withdrew the page's debugger.
+      // The server's listener subscribes in its own fiber; detach once it is there.
+      while (desktopDetaches.listenerCount("detach") === 0) yield* Effect.yieldNow;
+      desktopDetaches.emit("detach", { threadId: scope.threadId, tabId: opened.tabId });
+      let end = yield* Queue.take(viewer.output);
+      while (end._tag !== "reconnect" && end._tag !== "gone")
+        end = yield* Queue.take(viewer.output);
+      expect(end._tag).toBe("reconnect");
+      expect(releasedDesktopTabs).toEqual([opened.tabId]);
+      // The session survives, and the next viewer reaches the page again.
+      const { sessions } = yield* manager.list({ threadId: scope.threadId });
+      expect(sessions.map((session) => session.tabId)).toContain(opened.tabId);
+      yield* browser.attachViewer(viewerInput(opened.tabId, false));
+      expect(desktopConnections).toHaveLength(2);
+    }),
+  ).pipe(Effect.provide(layer)),
+);