diff --git a/apps/studio/src/client/atoms/studio-modal.ts b/apps/studio/src/client/atoms/studio-modal.ts
index e47104620..a15c2b0eb 100644
--- a/apps/studio/src/client/atoms/studio-modal.ts
+++ b/apps/studio/src/client/atoms/studio-modal.ts
@@ -9,6 +9,14 @@ const openModalAtom = atom<null | {
   state: unknown;
 }>(null);
 
+/**
+ * Whether any app-wide studio modal holds the slot. Read by hosts of a
+ * body-mounted browser guest, which is not inside the dialog's subtree and so
+ * would otherwise keep painting straight through its overlay (see
+ * use-guest-covered).
+ */
+export const isStudioModalOpenAtom = atom((get) => get(openModalAtom) !== null);
+
 type StudioModalAtom<T> = WritableAtom<null | T, [null | T], void>;
 
 /**
diff --git a/apps/studio/src/client/components/file-viewer.tsx b/apps/studio/src/client/components/file-viewer.tsx
index be85f29a1..c1d14d6e3 100644
--- a/apps/studio/src/client/components/file-viewer.tsx
+++ b/apps/studio/src/client/components/file-viewer.tsx
@@ -17,7 +17,6 @@ import { type FileType, getFileType } from "@/client/lib/get-file-type";
 import { cn, getRevealInFolderLabel } from "@/client/lib/utils";
 import { rpcClient } from "@/client/rpc/client";
 import {
-  ArrowClockwiseIcon,
   ArrowLineDownIcon,
   ArrowsOutSimpleIcon,
   CheckIcon,
@@ -40,10 +39,10 @@ import { ViewerSurface } from "./document-viewers/viewer-surface";
 import { FileActionsMenuItems } from "./file-actions-menu";
 import { FileLoading } from "./file-loading";
 import { FilePreviewFallback } from "./file-preview-fallback";
+import { HtmlArtifactPreview } from "./html-artifact-preview";
 import { RevealInFolderIcon } from "./icons/reveal-in-folder";
 import { ImageViewer } from "./image-viewer";
 import { OpenTaskFileButton } from "./open-task-file-button";
-import { SandboxedHtmlIframe } from "./sandboxed-html-iframe";
 import { SessionMarkdown } from "./session-markdown";
 import { Alert, AlertDescription, AlertTitle } from "./ui/alert";
 import { Button } from "./ui/button";
@@ -184,7 +183,9 @@ export const fileViewerClassName =
 interface ViewerContext {
   fallback: ReactNode;
   file: TaskFileViewerFile;
-  htmlReloadNonce: number;
+  // Bumped when the user asks to return to the start of the file they are
+  // already looking at; see TaskView.
+  goHomeNonce?: number;
   imageLoadError: boolean;
   onImageError: () => void;
   onMediaError: (fallbackExtension: string) => void;
@@ -273,11 +274,10 @@ const VIEWERS = {
       context.viewMode === "raw" ? (
         renderText(context)
       ) : (
-        <SandboxedHtmlIframe
-          className="absolute inset-0 size-full border-0"
-          key={context.htmlReloadNonce}
-          src={context.file.url}
-          title={context.file.filename}
+        <HtmlArtifactPreview
+          entryUrl={context.file.url}
+          goHomeNonce={context.goHomeNonce}
+          taskId={context.file.taskId}
         />
       ),
     scrolls: "container",
@@ -457,19 +457,18 @@ const fileViewerHeaderOpenWithTriggerClassName = toolbarClassName({
 
 export function FileViewer({
   file,
+  goHomeNonce,
   onClose,
   onExpand,
 }: {
   file: TaskFileViewerFile;
+  // Passed through to a viewer that hosts a browser guest; see ViewerContext.
+  goHomeNonce?: number;
   onClose: () => void;
   onExpand?: () => void;
 }) {
   const { filename, filePath, mimeType, taskId, url } = file;
   const [viewMode, setViewMode] = useState<"preview" | "raw">("preview");
-  // Remounts the sandboxed HTML iframe back to its entry page. The iframe is a
-  // cross-origin, opaque-origin sandbox, so we can't read or drive its history;
-  // reloading `src` is the only way to escape an in-page link navigation.
-  const [htmlReloadNonce, setHtmlReloadNonce] = useState(0);
   const [mediaLoadError, setMediaLoadError] = useState(false);
   const [mediaErrorType, setMediaErrorType] = useState<string | undefined>();
   const [imageErrorUrl, setImageErrorUrl] = useState<null | string>(null);
@@ -496,13 +495,20 @@ export function FileViewer({
   const fileType = getFileType(file);
   const hasPreview = fileType === "markdown" || fileType === "html";
   const fileActions = useFileActionVisibility(file);
+  // An HTML preview is a `<webview>` guest, and there is exactly one per task.
+  // Expanding would mount a second host for it, and two hosts sharing one guest
+  // have to agree on which file is on screen, who owns Cmd+F, and which of them
+  // may paint -- none of which a viewer can answer from its own props. The panel
+  // already gives an artifact the full height of the pane, so the affordance is
+  // withheld rather than arbitrated. Every other file type keeps it.
+  const canExpand = onExpand != null && fileType !== "html";
   const hasHeaderMenuActions =
-    onExpand != null || fileActions.showDownload || fileActions.showReveal;
+    canExpand || fileActions.showDownload || fileActions.showReveal;
   const showOverflowMenu =
     fileActions.showDownload ||
     fileActions.showReveal ||
     hasPreview ||
-    Boolean(onExpand);
+    canExpand;
 
   const handleDownload = async () => {
     await downloadFile(file);
@@ -549,7 +555,7 @@ export function FileViewer({
       />
     ),
     file,
-    htmlReloadNonce,
+    goHomeNonce,
     imageLoadError,
     onImageError: () => {
       setImageErrorUrl(url);
@@ -576,24 +582,6 @@ export function FileViewer({
               size="sm"
               variant="ghost"
             />
-            {fileType === "html" && viewMode === "preview" && (
-              <Tooltip>
-                <TooltipTrigger asChild>
-                  <Button
-                    aria-label="Reload"
-                    className={fileViewerHeaderIconActionClassName}
-                    onClick={() => {
-                      setHtmlReloadNonce((nonce) => nonce + 1);
-                    }}
-                    size="icon-sm"
-                    variant="ghost"
-                  >
-                    <ArrowClockwiseIcon className="size-4" />
-                  </Button>
-                </TooltipTrigger>
-                <TooltipContent>Reload</TooltipContent>
-              </Tooltip>
-            )}
             {fileActions.showCopy && !imageLoadError && (
               <Button
                 className={fileViewerHeaderActionClassName}
@@ -626,7 +614,7 @@ export function FileViewer({
                   </Button>
                 </DropdownMenuTrigger>
                 <DropdownMenuContent align="end">
-                  {onExpand && (
+                  {canExpand && (
                     <DropdownMenuItem onClick={onExpand}>
                       <ArrowsOutSimpleIcon className="size-4" />
                       <span>Expand</span>
diff --git a/apps/studio/src/client/components/html-artifact-preview.tsx b/apps/studio/src/client/components/html-artifact-preview.tsx
new file mode 100644
index 000000000..7422818e4
--- /dev/null
+++ b/apps/studio/src/client/components/html-artifact-preview.tsx
@@ -0,0 +1,313 @@
+import { BrowserFindBar } from "@/client/components/task/browser-find-bar";
+import { GuestLoadErrorNotice } from "@/client/components/task/guest-load-error";
+import { Button } from "@/client/components/ui/button";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuSeparator,
+  DropdownMenuTrigger,
+} from "@/client/components/ui/dropdown-menu";
+import { Spinner } from "@/client/components/ui/spinner";
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipTrigger,
+} from "@/client/components/ui/tooltip";
+import {
+  ZoomLevelMenu,
+  ZoomStepperControl,
+} from "@/client/components/zoom-controls";
+import { useIsActiveTab } from "@/client/hooks/use-active-tab";
+import { useBrowserFind } from "@/client/hooks/use-browser-find";
+import { useBrowserSlot } from "@/client/hooks/use-browser-slot";
+import { useBrowserTargets } from "@/client/hooks/use-browser-targets";
+import { useIsGuestCovered } from "@/client/hooks/use-guest-covered";
+import { useGuestMenuState } from "@/client/hooks/use-guest-menu-state";
+import { useGuestNavigation } from "@/client/hooks/use-guest-navigation";
+import { rpcClient } from "@/client/rpc/client";
+import { BROWSER_ZOOM_MAX, BROWSER_ZOOM_MIN } from "@/shared/browser";
+import {
+  encodeArtifactTargetId,
+  type TaskId,
+} from "@instrument-org/workspace/client";
+import {
+  ArrowClockwiseIcon,
+  ArrowCounterClockwiseIcon,
+  ArrowLeftIcon,
+  ArrowRightIcon,
+  ArrowSquareOutIcon,
+  DotsThreeVerticalIcon,
+  HouseIcon,
+  MagnifyingGlassIcon,
+} from "@phosphor-icons/react";
+import { useMutation } from "@tanstack/react-query";
+import { useEffect } from "react";
+
+/**
+ * An HTML file artifact, rendered in the same `<webview>` guest the agent
+ * browses in rather than a sandboxed `<iframe>`.
+ *
+ * The point is not the back/forward chrome, though that is what shows: the
+ * agent and the user load the identical asset URL, so rendering them on
+ * different primitives meant everything origin-scoped -- `localStorage`,
+ * cookies, same-origin `fetch` of a sibling file -- behaved one way when the
+ * agent screenshotted its own work and another way in front of the user. One
+ * guest kind for both makes the agent's self-check evidence about what the user
+ * will see.
+ *
+ * One guest per task, navigated between files, not one per file: `entryUrl`
+ * changing is a `loadURL`, exactly as a browser tab would do it. Exactly one
+ * preview is ever mounted for a task -- the artifact panel -- which is why
+ * nothing here has to arbitrate between hosts; `FileViewer` withholds Expand
+ * for HTML to keep it that way.
+ *
+ * Deliberately no address bar. Back, forward, reload and a way home are what a
+ * preview needs; a free-form URL box would turn the agent's output into a
+ * general-purpose browser running in a real origin.
+ */
+export function HtmlArtifactPreview({
+  entryUrl,
+  goHomeNonce,
+  taskId,
+}: {
+  // The artifact's own page. Carries the version query string, so a file
+  // rewritten on disk arrives here as a new URL and re-navigates.
+  entryUrl: string;
+  // Bumped when the user re-selects the file already on screen, which asks for
+  // the entry page back; see TaskView.
+  goHomeNonce?: number;
+  taskId: TaskId;
+}) {
+  const targetId = encodeArtifactTargetId(taskId);
+  const isActiveTab = useIsActiveTab();
+  const covered = useIsGuestCovered();
+
+  const attachedTargets = useBrowserTargets();
+  const active = attachedTargets.has(targetId);
+
+  const { isError: openFailed, mutate: openPreview } = useMutation(
+    rpcClient.workspace.artifactPreview.open.mutationOptions(),
+  );
+
+  // Ask the main process for a guest whenever there isn't one: on mount, and
+  // again if this one goes away (a crash in untrusted artifact HTML, the task
+  // being trashed). Deliberately a mutation and not a cached query -- one that
+  // had already resolved would replay its old answer and leave the preview
+  // waiting on a guest nobody asked for a second time.
+  //
+  // It cannot spin: the effect is keyed on `active`, so a create that fails, or
+  // succeeds without the guest attaching, leaves the deps untouched.
+  useEffect(() => {
+    if (!active) {
+      openPreview({ id: taskId });
+    }
+  }, [active, openPreview, taskId]);
+
+  const guest = useGuestNavigation({ active, targetId });
+  const find = useBrowserFind({ active, covered, isActiveTab, targetId });
+  const slotRef = useBrowserSlot({
+    active,
+    covered,
+    hasLoadError: Boolean(guest.loadError),
+    isActiveTab,
+    targetId,
+  });
+
+  const openExternalLink = useMutation(
+    rpcClient.utils.openExternalLink.mutationOptions(),
+  );
+  const [menuOpen, setMenuOpen] = useGuestMenuState();
+
+  // Point the guest at this artifact: on mount, when the selected file changes,
+  // and when the user asks to go home. A fresh guest arrives on `about:blank`,
+  // so `active` becoming true is one of the triggers -- otherwise a preview
+  // whose guest was replaced would sit on a blank page it believed was correct.
+  useEffect(() => {
+    if (active) {
+      guest.navigateTo(entryUrl);
+    }
+    // `guest` is rebuilt every render; navigating is keyed on the file, the
+    // go-home gesture, and the guest becoming available, not on that identity.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [active, entryUrl, goHomeNonce, targetId]);
+
+  const atEntry = guest.currentUrl() === entryUrl;
+
+  return (
+    <div className="absolute inset-0 flex flex-col">
+      <div className="flex items-center gap-1 border-b px-1.5 py-1">
+        <Button
+          aria-label="Back"
+          disabled={!active || !guest.canGoBack}
+          onClick={guest.goBack}
+          size="icon-sm"
+          variant="ghost"
+        >
+          <ArrowLeftIcon className="size-4" />
+        </Button>
+        <Button
+          aria-label="Forward"
+          disabled={!active || !guest.canGoForward}
+          onClick={guest.goForward}
+          size="icon-sm"
+          variant="ghost"
+        >
+          <ArrowRightIcon className="size-4" />
+        </Button>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <Button
+              aria-label="Reload"
+              disabled={!active}
+              onClick={guest.reload}
+              size="icon-sm"
+              variant="ghost"
+            >
+              <ArrowClockwiseIcon className="size-4" />
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent>Reload</TooltipContent>
+        </Tooltip>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <Button
+              aria-label="Back to the start of this file"
+              disabled={!active || atEntry}
+              onClick={() => {
+                guest.navigateTo(entryUrl);
+              }}
+              size="icon-sm"
+              variant="ghost"
+            >
+              <HouseIcon className="size-4" />
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent>Back to the start of this file</TooltipContent>
+        </Tooltip>
+        {/* Read-only: says where a followed link landed, and is not a way to
+            navigate somewhere else. */}
+        <div className="min-w-0 flex-1 truncate px-2 text-xs text-muted-foreground">
+          {guest.url}
+        </div>
+        <DropdownMenu
+          // Non-modal so clicking into the guest `<webview>` (a separate
+          // WebContents) isn't blocked by the modal body `pointer-events: none`;
+          // useGuestMenuState is what then dismisses it, since that click gives
+          // Radix nothing its own outside-dismiss can see.
+          modal={false}
+          onOpenChange={(open) => {
+            if (open) {
+              guest.syncZoomFactor();
+            }
+            setMenuOpen(open);
+          }}
+          open={menuOpen}
+        >
+          <DropdownMenuTrigger asChild>
+            <Button
+              aria-label="Preview options"
+              disabled={!active}
+              size="icon-sm"
+              variant="ghost"
+            >
+              <DotsThreeVerticalIcon className="size-4" />
+            </Button>
+          </DropdownMenuTrigger>
+          <DropdownMenuContent align="end" className="w-56">
+            <div className="flex items-center justify-between px-2 py-1.5">
+              <span className="text-sm">Zoom</span>
+              <ZoomStepperControl
+                canZoomIn={guest.zoomFactor < BROWSER_ZOOM_MAX}
+                canZoomOut={guest.zoomFactor > BROWSER_ZOOM_MIN}
+                onZoomIn={guest.zoomIn}
+                onZoomOut={guest.zoomOut}
+                readout={
+                  <ZoomLevelMenu
+                    max={BROWSER_ZOOM_MAX}
+                    min={BROWSER_ZOOM_MIN}
+                    nested
+                    onSelect={guest.applyZoom}
+                    zoom={guest.zoomFactor}
+                  />
+                }
+              />
+            </div>
+            <DropdownMenuSeparator />
+            <DropdownMenuItem
+              onSelect={() => {
+                find.setFindOpen(true);
+              }}
+            >
+              <MagnifyingGlassIcon className="size-4" />
+              Find in page
+            </DropdownMenuItem>
+            <DropdownMenuItem onSelect={guest.hardReload}>
+              <ArrowCounterClockwiseIcon className="size-4" />
+              Hard reload
+            </DropdownMenuItem>
+            <DropdownMenuSeparator />
+            <DropdownMenuItem
+              onSelect={() => {
+                openExternalLink.mutate({
+                  url: guest.currentUrl() ?? entryUrl,
+                });
+              }}
+            >
+              <ArrowSquareOutIcon className="size-4" />
+              Open in external browser
+            </DropdownMenuItem>
+          </DropdownMenuContent>
+        </DropdownMenu>
+      </div>
+      {active && find.findOpen && (
+        <BrowserFindBar
+          closeFind={find.closeFind}
+          findInputRef={find.findInputRef}
+          findQuery={find.findQuery}
+          findResult={find.findResult}
+          runFind={find.runFind}
+          setFindQuery={find.setFindQuery}
+        />
+      )}
+      {active ? (
+        <div className="relative flex-1" ref={slotRef}>
+          {guest.loadError && (
+            <GuestLoadErrorNotice
+              error={guest.loadError}
+              onRetry={() => {
+                // Retry what failed -- which is the URL the notice names, and
+                // after a followed link is not this artifact's entry page.
+                guest.navigateTo(guest.loadError?.url ?? entryUrl);
+              }}
+            />
+          )}
+        </div>
+      ) : (
+        <div className="flex flex-1 flex-col items-center justify-center gap-3 p-6 text-center text-sm text-muted-foreground">
+          {openFailed ? (
+            <>
+              <span>Couldn’t open the preview.</span>
+              {/* The open effect fires once per state by design, so it will not
+                  retry on its own. This is the way back. */}
+              <Button
+                onClick={() => {
+                  openPreview({ id: taskId });
+                }}
+                size="sm"
+                variant="outline"
+              >
+                Try again
+              </Button>
+            </>
+          ) : (
+            <>
+              <Spinner className="size-5" />
+              <span>Opening preview…</span>
+            </>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/apps/studio/src/client/components/sandboxed-html-iframe.tsx b/apps/studio/src/client/components/sandboxed-html-iframe.tsx
deleted file mode 100644
index dc6eeba44..000000000
--- a/apps/studio/src/client/components/sandboxed-html-iframe.tsx
+++ /dev/null
@@ -1,34 +0,0 @@
-import { cn } from "../lib/utils";
-
-export function SandboxedHtmlIframe({
-  className,
-  restrictInteractive = false,
-  src,
-  style,
-  title,
-}: {
-  className?: string;
-  restrictInteractive?: boolean;
-  src: string;
-  style?: React.CSSProperties;
-  title: string;
-}) {
-  const sandbox = restrictInteractive
-    ? "allow-downloads allow-forms allow-scripts"
-    : "allow-downloads allow-forms allow-modals allow-pointer-lock allow-popups allow-scripts allow-presentation";
-
-  const allow = restrictInteractive
-    ? "accelerometer; autoplay; encrypted-media"
-    : "accelerometer; autoplay; camera; clipboard-read; clipboard-write; display-capture; encrypted-media; fullscreen; geolocation; gyroscope; microphone; midi; payment; usb; xr-spatial-tracking";
-
-  return (
-    <iframe
-      allow={allow}
-      className={cn("bg-white", className)}
-      sandbox={sandbox}
-      src={src}
-      style={style}
-      title={title}
-    />
-  );
-}
diff --git a/apps/studio/src/client/components/task/browser-panel.tsx b/apps/studio/src/client/components/task/browser-panel.tsx
index e168f37dc..75f708dae 100644
--- a/apps/studio/src/client/components/task/browser-panel.tsx
+++ b/apps/studio/src/client/components/task/browser-panel.tsx
@@ -1,4 +1,5 @@
 import { BrowserFindBar } from "@/client/components/task/browser-find-bar";
+import { GuestLoadErrorNotice } from "@/client/components/task/guest-load-error";
 import { Button } from "@/client/components/ui/button";
 import {
   DropdownMenu,
@@ -26,7 +27,9 @@ import {
 import { useIsActiveTab } from "@/client/hooks/use-active-tab";
 import { useBrowserFind } from "@/client/hooks/use-browser-find";
 import { useBrowserSlot } from "@/client/hooks/use-browser-slot";
-import { getWebviewElement } from "@/client/lib/browser-pool";
+import { useIsGuestCovered } from "@/client/hooks/use-guest-covered";
+import { useGuestMenuState } from "@/client/hooks/use-guest-menu-state";
+import { useGuestNavigation } from "@/client/hooks/use-guest-navigation";
 import {
   EMULATED_DEVICES,
   type EmulatedDevice,
@@ -34,7 +37,6 @@ import {
 import { resolveUrlOrSearch } from "@/client/lib/resolve-url-or-search";
 import { rpcClient } from "@/client/rpc/client";
 import { BROWSER_ZOOM_MAX, BROWSER_ZOOM_MIN } from "@/shared/browser";
-import { steppedZoom } from "@/shared/zoom";
 import {
   type BrowserTargetId,
   encodeBrowserTargetId,
@@ -51,21 +53,11 @@ import {
   DeviceMobileIcon,
   DotsThreeVerticalIcon,
   MagnifyingGlassIcon,
-  WarningCircleIcon,
   XIcon,
 } from "@phosphor-icons/react";
 import { useMutation } from "@tanstack/react-query";
 import { useEffect, useRef, useState } from "react";
 
-// Shape of the `<webview>` `did-fail-load` DOM event (Electron adds these
-// fields; the DOM lib types it as a plain Event).
-interface DidFailLoadEvent extends Event {
-  errorCode: number;
-  errorDescription: string;
-  isMainFrame: boolean;
-  validatedURL: string;
-}
-
 /**
  * The task's in-app browser, hosted in the artifact panel. The guest `<webview>`
  * lives in the body-mounted pool; {@link useBrowserSlot} measures a slot and
@@ -91,9 +83,7 @@ export function TaskBrowserPanel({
   const inputRef = useRef<HTMLInputElement>(null);
   const isActiveTab = useIsActiveTab();
   const [draftUrl, setDraftUrl] = useState("");
-  const [nav, setNav] = useState({ back: false, forward: false });
-  const [zoomFactor, setZoomFactor] = useState(1);
-  const [menuOpen, setMenuOpen] = useState(false);
+  const [menuOpen, setMenuOpen] = useGuestMenuState();
   // null = the panel's natural size ("Actual size"). Applied via CDP device
   // emulation with a scale computed from the panel's live bounds (see
   // device-emulation.ts) rather than resizing the webview element, which
@@ -101,27 +91,39 @@ export function TaskBrowserPanel({
   const [emulatedDevice, setEmulatedDevice] = useState<EmulatedDevice | null>(
     null,
   );
-  // Set when a main-frame navigation fails (bad host, no network, ...). The
-  // guest is parked and we show a light error state over the slot instead of its
-  // blank error page. Cleared when a new load starts or succeeds.
-  const [loadError, setLoadError] = useState<null | {
-    message: string;
-    url: string;
-  }>(null);
   // While the user is editing the URL, agent-driven navigations must not
   // overwrite what they're typing.
   const editingUrlRef = useRef(false);
 
-  const find = useBrowserFind({ active, isActiveTab, targetId });
+  const guest = useGuestNavigation({
+    active,
+    isUrlEditing: () => editingUrlRef.current,
+    targetId,
+  });
+  // Read once and give both hooks the same answer: a panel that parks its guest
+  // under an overlay must also stop being the Cmd+F target, or the overlay's
+  // host claims the single find-opener slot, clears it on unmount, and this
+  // panel never re-registers.
+  const covered = useIsGuestCovered();
+  const find = useBrowserFind({ active, covered, isActiveTab, targetId });
   const slotRef = useBrowserSlot({
     active,
+    covered,
     emulatedDeviceHeight: emulatedDevice?.height,
     emulatedDeviceWidth: emulatedDevice?.width,
-    hasLoadError: Boolean(loadError),
+    hasLoadError: Boolean(guest.loadError),
     isActiveTab,
     targetId,
   });
 
+  // Mirror the guest's URL into the address bar. Held in local state (rather
+  // than read straight off the hook) because the user types into the same box.
+  useEffect(() => {
+    if (!editingUrlRef.current) {
+      setDraftUrl(guest.url);
+    }
+  }, [guest.url]);
+
   const openExternalLink = useMutation(
     rpcClient.utils.openExternalLink.mutationOptions(),
   );
@@ -141,73 +143,6 @@ export function TaskBrowserPanel({
     openBrowser({ id: taskId, sessionId });
   }, [active, openBrowser, sessionId, targetId, taskId]);
 
-  // Mirror the guest's URL + nav availability into the controls (it navigates
-  // from agent CDP commands too, not just user input), and track main-frame
-  // load failures so we can show a light error state.
-  useEffect(() => {
-    if (!active) {
-      return;
-    }
-    const webview = getWebviewElement(targetId);
-    if (!webview) {
-      return;
-    }
-    const sync = () => {
-      // getURL/canGoBack throw if the guest hasn't attached its WebContents yet;
-      // the did-navigate events that also drive this only fire once it has.
-      try {
-        if (!editingUrlRef.current) {
-          const url = webview.getURL();
-          setDraftUrl(url === "about:blank" ? "" : url);
-        }
-        setNav({ back: webview.canGoBack(), forward: webview.canGoForward() });
-      } catch {
-        // Not attached yet; a did-navigate will re-run sync once it is.
-      }
-    };
-    const onNavigate = () => {
-      setLoadError(null);
-      sync();
-    };
-    const onStartLoading = () => {
-      setLoadError(null);
-    };
-    const onFailLoad = (event: Event) => {
-      const detail = event as DidFailLoadEvent;
-      // Ignore sub-frame failures and user-aborted navigations (ERR_ABORTED),
-      // which fire routinely when a new navigation supersedes an in-flight one.
-      if (!detail.isMainFrame || detail.errorCode === -3) {
-        return;
-      }
-      setLoadError({
-        message: detail.errorDescription || "This site can’t be reached",
-        url: detail.validatedURL,
-      });
-      if (!editingUrlRef.current && detail.validatedURL) {
-        setDraftUrl(detail.validatedURL);
-      }
-      // A committed error page makes the prior page a back entry, but
-      // did-navigate doesn't reliably fire on error-page commit, so refresh the
-      // nav buttons here instead of leaving them stale (back stuck disabled).
-      try {
-        setNav({ back: webview.canGoBack(), forward: webview.canGoForward() });
-      } catch {
-        // Guest not attached yet; a later did-navigate will sync.
-      }
-    };
-    sync();
-    webview.addEventListener("did-navigate", onNavigate);
-    webview.addEventListener("did-navigate-in-page", onNavigate);
-    webview.addEventListener("did-start-loading", onStartLoading);
-    webview.addEventListener("did-fail-load", onFailLoad);
-    return () => {
-      webview.removeEventListener("did-navigate", onNavigate);
-      webview.removeEventListener("did-navigate-in-page", onNavigate);
-      webview.removeEventListener("did-start-loading", onStartLoading);
-      webview.removeEventListener("did-fail-load", onFailLoad);
-    };
-  }, [active, targetId]);
-
   // Focus the URL bar on a blank page ONLY when this panel opened the browser
   // (autoOpenedRef), i.e. a user-initiated open, so they can type immediately.
   // For an agent-initiated open we must not steal focus: a focused bar reads as
@@ -217,7 +152,7 @@ export function TaskBrowserPanel({
       return;
     }
     try {
-      const url = getWebviewElement(targetId)?.getURL();
+      const url = guest.currentUrl();
       const activeElement = document.activeElement;
       // isContentEditable also covers contenteditable="" / "plaintext-only",
       // which an attribute selector would miss.
@@ -225,83 +160,36 @@ export function TaskBrowserPanel({
         activeElement instanceof HTMLElement &&
         (activeElement.isContentEditable ||
           activeElement.matches("input, textarea, select"));
-      if ((!url || url === "about:blank") && !hostInputFocused) {
+      if (!url && !hostInputFocused) {
         inputRef.current?.focus();
       }
     } catch {
       // Not attached yet; nothing to focus into.
     }
+    // `guest` is rebuilt every render and this is a one-shot read at the moment
+    // the guest becomes available, not something to redo as it navigates.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [active, targetId]);
 
-  // Close the overflow menu when the host window loses focus. Clicking into the
-  // guest `<webview>` (a separate WebContents) blurs the host window but never
-  // dispatches a pointer/focus event Radix can see, so its own outside-dismiss
-  // never fires and the menu would otherwise stay stuck open over the page.
-  useEffect(() => {
-    if (!menuOpen) {
-      return;
-    }
-    const close = () => {
-      setMenuOpen(false);
-    };
-    window.addEventListener("blur", close);
-    return () => {
-      window.removeEventListener("blur", close);
-    };
-  }, [menuOpen]);
-
-  const webviewFor = () => getWebviewElement(targetId);
-
-  // loadURL rejects on a failed navigation (bad host, offline, ...); the
-  // did-fail-load listener already surfaces the error, so swallow the rejection
-  // to avoid an unhandled promise error.
-  const navigateTo = (url: string) => {
-    void webviewFor()
-      ?.loadURL(url)
-      .catch(() => {
-        // Surfaced by the did-fail-load listener; nothing to do here.
-      });
-  };
-
-  const applyZoom = (factor: number) => {
-    const webview = webviewFor();
-    if (!webview) {
-      return;
-    }
-    webview.setZoomFactor(factor);
-    setZoomFactor(factor);
-  };
-
-  const currentUrl = () => {
-    try {
-      // getURL throws until the guest's WebContents is dom-ready; `active` can
-      // lead that (it round-trips through main), so treat a throw as "no page".
-      const url = webviewFor()?.getURL();
-      return url && url !== "about:blank" ? url : undefined;
-    } catch {
-      return;
-    }
-  };
-
   // A real page is loaded (not about:blank). Zoom, copy, and open-external all
   // act on the current page, so they're only meaningful once one exists; zoom in
   // particular is per-page and doesn't carry to the next navigation.
-  const pageUrl = active ? currentUrl() : undefined;
+  const pageUrl = active ? guest.currentUrl() : undefined;
 
   return (
     <div className="flex h-full flex-col overflow-hidden rounded-xl bg-card shadow-sm">
       <div className="flex items-center gap-1 border-b p-1.5">
         <Button
-          disabled={!active || !nav.back}
-          onClick={() => webviewFor()?.goBack()}
+          disabled={!active || !guest.canGoBack}
+          onClick={guest.goBack}
           size="icon-sm"
           variant="ghost"
         >
           <ArrowLeftIcon className="size-4" />
         </Button>
         <Button
-          disabled={!active || !nav.forward}
-          onClick={() => webviewFor()?.goForward()}
+          disabled={!active || !guest.canGoForward}
+          onClick={guest.goForward}
           size="icon-sm"
           variant="ghost"
         >
@@ -309,7 +197,7 @@ export function TaskBrowserPanel({
         </Button>
         <Button
           disabled={!active}
-          onClick={() => webviewFor()?.reload()}
+          onClick={guest.reload}
           size="icon-sm"
           variant="ghost"
         >
@@ -321,7 +209,7 @@ export function TaskBrowserPanel({
             event.preventDefault();
             const target = resolveUrlOrSearch(draftUrl);
             if (target) {
-              navigateTo(target);
+              guest.navigateTo(target);
               // Blur so the "editing" guard releases and the resolved final URL
               // (after normalization/redirects) syncs back into the bar once the
               // navigation commits, instead of leaving what the user typed.
@@ -379,14 +267,7 @@ export function TaskBrowserPanel({
               return;
             }
             if (open) {
-              const webview = webviewFor();
-              if (webview) {
-                try {
-                  setZoomFactor(webview.getZoomFactor());
-                } catch {
-                  // Not dom-ready yet; keep the last known zoom.
-                }
-              }
+              guest.syncZoomFactor();
             }
             setMenuOpen(open);
           }}
@@ -401,35 +282,17 @@ export function TaskBrowserPanel({
             <div className="flex items-center justify-between px-2 py-1.5">
               <span className="text-sm">Zoom</span>
               <ZoomStepperControl
-                canZoomIn={zoomFactor < BROWSER_ZOOM_MAX}
-                canZoomOut={zoomFactor > BROWSER_ZOOM_MIN}
-                onZoomIn={() => {
-                  applyZoom(
-                    steppedZoom({
-                      direction: "in",
-                      factor: zoomFactor,
-                      max: BROWSER_ZOOM_MAX,
-                      min: BROWSER_ZOOM_MIN,
-                    }),
-                  );
-                }}
-                onZoomOut={() => {
-                  applyZoom(
-                    steppedZoom({
-                      direction: "out",
-                      factor: zoomFactor,
-                      max: BROWSER_ZOOM_MAX,
-                      min: BROWSER_ZOOM_MIN,
-                    }),
-                  );
-                }}
+                canZoomIn={guest.zoomFactor < BROWSER_ZOOM_MAX}
+                canZoomOut={guest.zoomFactor > BROWSER_ZOOM_MIN}
+                onZoomIn={guest.zoomIn}
+                onZoomOut={guest.zoomOut}
                 readout={
                   <ZoomLevelMenu
                     max={BROWSER_ZOOM_MAX}
                     min={BROWSER_ZOOM_MIN}
                     nested
-                    onSelect={applyZoom}
-                    zoom={zoomFactor}
+                    onSelect={guest.applyZoom}
+                    zoom={guest.zoomFactor}
                   />
                 }
               />
@@ -479,18 +342,14 @@ export function TaskBrowserPanel({
               <MagnifyingGlassIcon className="size-4" />
               Find in page
             </DropdownMenuItem>
-            <DropdownMenuItem
-              onSelect={() => {
-                webviewFor()?.reloadIgnoringCache();
-              }}
-            >
+            <DropdownMenuItem onSelect={guest.hardReload}>
               <ArrowCounterClockwiseIcon className="size-4" />
               Hard reload
             </DropdownMenuItem>
             <DropdownMenuSeparator />
             <DropdownMenuItem
               onSelect={() => {
-                const url = currentUrl();
+                const url = guest.currentUrl();
                 if (url) {
                   void navigator.clipboard.writeText(url);
                 }
@@ -517,30 +376,15 @@ export function TaskBrowserPanel({
       )}
       {active ? (
         <div className="relative flex-1" ref={slotRef}>
-          {loadError && (
-            <div className="absolute inset-0 flex flex-col items-center justify-center gap-3 bg-card p-6 text-center">
-              <WarningCircleIcon className="size-8 text-muted-foreground" />
-              <div className="space-y-1">
-                <p className="text-sm font-medium">
-                  This site can’t be reached
-                </p>
-                <p className="max-w-xs truncate text-xs text-muted-foreground">
-                  {loadError.url}
-                </p>
-                <p className="text-xs text-muted-foreground">
-                  {loadError.message}
-                </p>
-              </div>
-              <Button
-                onClick={() => {
-                  navigateTo(loadError.url);
-                }}
-                size="sm"
-                variant="outline"
-              >
-                Try again
-              </Button>
-            </div>
+          {guest.loadError && (
+            <GuestLoadErrorNotice
+              error={guest.loadError}
+              onRetry={() => {
+                if (guest.loadError) {
+                  guest.navigateTo(guest.loadError.url);
+                }
+              }}
+            />
           )}
         </div>
       ) : (
diff --git a/apps/studio/src/client/components/task/guest-load-error.tsx b/apps/studio/src/client/components/task/guest-load-error.tsx
new file mode 100644
index 000000000..80f40ffa5
--- /dev/null
+++ b/apps/studio/src/client/components/task/guest-load-error.tsx
@@ -0,0 +1,32 @@
+import { Button } from "@/client/components/ui/button";
+import { type GuestLoadError } from "@/client/hooks/use-guest-navigation";
+import { WarningCircleIcon } from "@phosphor-icons/react";
+
+/**
+ * Shown over a guest's slot when its main-frame navigation failed. The guest is
+ * parked while this is up (see useBrowserSlot's `hasLoadError`) so its own blank
+ * error page doesn't sit on top of this one.
+ */
+export function GuestLoadErrorNotice({
+  error,
+  onRetry,
+}: {
+  error: GuestLoadError;
+  onRetry: () => void;
+}) {
+  return (
+    <div className="absolute inset-0 flex flex-col items-center justify-center gap-3 bg-card p-6 text-center">
+      <WarningCircleIcon className="size-8 text-muted-foreground" />
+      <div className="space-y-1">
+        <p className="text-sm font-medium">This site can’t be reached</p>
+        <p className="max-w-xs truncate text-xs text-muted-foreground">
+          {error.url}
+        </p>
+        <p className="text-xs text-muted-foreground">{error.message}</p>
+      </div>
+      <Button onClick={onRetry} size="sm" variant="outline">
+        Try again
+      </Button>
+    </div>
+  );
+}
diff --git a/apps/studio/src/client/components/task/view.tsx b/apps/studio/src/client/components/task/view.tsx
index 93f6ba6dd..e06acc071 100644
--- a/apps/studio/src/client/components/task/view.tsx
+++ b/apps/studio/src/client/components/task/view.tsx
@@ -70,10 +70,12 @@ export function TaskView({
   const openFileViewer = useSetAtom(openFileViewerAtom);
   const assetBaseUrl = getAssetBaseUrl(task.id);
 
-  // Bumped to force the file viewer to remount when the user re-opens the
-  // already-active artifact, snapping an HTML preview back to its entry page
-  // after an in-iframe link navigated it away.
-  const [artifactReloadNonce, setArtifactReloadNonce] = useState(0);
+  // Re-selecting the artifact that is already open means "take me back to the
+  // start of it" -- the router sees an identical search state, so there is no
+  // navigation for the viewer to react to. Bumped on that gesture and handed to
+  // the HTML preview, which sends its guest home. Not a remount key: the guest
+  // is pooled and survives one.
+  const [artifactHomeNonce, setArtifactHomeNonce] = useState(0);
 
   const filePanel = artifactPanel?.type === "file" ? artifactPanel : undefined;
   const browserPanel = artifactPanel?.type === "browser";
@@ -167,7 +169,7 @@ export function TaskView({
 
   const handleFileSelect = (file: TaskFileViewerFile) => {
     if (filePanel?.filePath === file.filePath) {
-      setArtifactReloadNonce((nonce) => nonce + 1);
+      setArtifactHomeNonce((nonce) => nonce + 1);
     }
     void navigate({
       from: "/tasks/$id/",
@@ -238,7 +240,8 @@ export function TaskView({
                   <div className="flex h-full">
                     <FileViewer
                       file={currentFile}
-                      key={`${currentFile.url}#${artifactReloadNonce}`}
+                      goHomeNonce={artifactHomeNonce}
+                      key={currentFile.url}
                       onClose={handleArtifactPanelClose}
                       onExpand={() => {
                         openFileViewer({ files: [currentFile] });
diff --git a/apps/studio/src/client/hooks/use-browser-find.ts b/apps/studio/src/client/hooks/use-browser-find.ts
index a6989abc6..0ff49188d 100644
--- a/apps/studio/src/client/hooks/use-browser-find.ts
+++ b/apps/studio/src/client/hooks/use-browser-find.ts
@@ -17,10 +17,17 @@ interface FoundInPageEvent extends Event {
  */
 export function useBrowserFind({
   active,
+  covered = false,
   isActiveTab,
   targetId,
 }: {
   active: boolean;
+  // This host is behind a full-window overlay, so it is not the one Cmd+F
+  // should reach. The find opener is a single slot: without this, a host that
+  // parks its guest keeps claiming it, and an overlay that takes the slot and
+  // clears it on unmount leaves the panel -- whose own inputs never changed --
+  // never re-registering, so Cmd+F stops working entirely.
+  covered?: boolean;
   isActiveTab: boolean;
   targetId: BrowserTargetId;
 }) {
@@ -71,7 +78,7 @@ export function useBrowserFind({
   // the Cmd+F app command opens (and re-focuses) its find bar. See
   // browser-find-registry for why Cmd+F can't be a renderer keydown.
   useEffect(() => {
-    if (!active || !isActiveTab) {
+    if (!active || !isActiveTab || covered) {
       return;
     }
     return setBrowserFindOpener(() => {
@@ -79,7 +86,7 @@ export function useBrowserFind({
       findInputRef.current?.focus();
       findInputRef.current?.select();
     });
-  }, [active, isActiveTab]);
+  }, [active, covered, isActiveTab]);
 
   // Focus the find input when the bar opens (its first render, when the opener
   // above couldn't focus it yet). Deferred a frame so it wins over Radix
diff --git a/apps/studio/src/client/hooks/use-browser-slot.ts b/apps/studio/src/client/hooks/use-browser-slot.ts
index c359020ae..0a964ba8d 100644
--- a/apps/studio/src/client/hooks/use-browser-slot.ts
+++ b/apps/studio/src/client/hooks/use-browser-slot.ts
@@ -18,6 +18,7 @@ interface DeviceEmulation {
  */
 export function useBrowserSlot({
   active,
+  covered = false,
   emulatedDeviceHeight,
   emulatedDeviceWidth,
   hasLoadError,
@@ -25,6 +26,12 @@ export function useBrowserSlot({
   targetId,
 }: {
   active: boolean;
+  // A full-window overlay is drawn over this slot. The guest is body-mounted,
+  // outside every dialog's subtree, so no overlay occludes it -- it keeps
+  // painting over the dim layer as though nothing opened. Opening a dialog is
+  // also not a tab switch, which is the only park signal this hook otherwise
+  // gets, so a covered host has to say so itself.
+  covered?: boolean;
   // Device size to emulate (see emulated-devices.ts presets), or
   // null/undefined for the panel's natural size. Passed as separate
   // primitives rather than an object so a new object identity per render
@@ -64,7 +71,7 @@ export function useBrowserSlot({
 
     // On a load error, park the guest so its blank error page doesn't cover our
     // own error state rendered in the slot.
-    if (!isActiveTab || hasLoadError) {
+    if (!isActiveTab || hasLoadError || covered) {
       setPaintHost(targetId, slotOwner);
       syncEmulation(null);
       return;
@@ -139,6 +146,7 @@ export function useBrowserSlot({
     };
   }, [
     active,
+    covered,
     isActiveTab,
     hasLoadError,
     slotOwner,
diff --git a/apps/studio/src/client/hooks/use-guest-covered.ts b/apps/studio/src/client/hooks/use-guest-covered.ts
new file mode 100644
index 000000000..7dc323246
--- /dev/null
+++ b/apps/studio/src/client/hooks/use-guest-covered.ts
@@ -0,0 +1,26 @@
+import { filePreviewAtom } from "@/client/atoms/file-preview";
+import { isStudioModalOpenAtom } from "@/client/atoms/studio-modal";
+import { taskFileViewerAtom } from "@/client/atoms/task-file-viewer";
+import { useAtomValue } from "jotai";
+
+/**
+ * Whether a full-window overlay is currently drawn over the page, for a host
+ * that shows a browser guest.
+ *
+ * The guest is mounted on `document.body`, outside every dialog's subtree, so no
+ * overlay occludes it the way it occludes ordinary content -- it keeps painting
+ * over the dim layer as though nothing opened. Opening a dialog is also not a
+ * tab switch, which is the only park signal `useBrowserSlot` otherwise receives,
+ * so a host under an overlay has to say so itself.
+ *
+ * Covers all three sources, because they are independent slots and a menu
+ * accelerator can open one over another: the app-wide studio modals (settings,
+ * sign-in, ...), the file viewer's expand modal, and the chat's own
+ * image/diagram preview.
+ */
+export function useIsGuestCovered(): boolean {
+  const studioModalOpen = useAtomValue(isStudioModalOpenAtom);
+  const fileViewerModalOpen = useAtomValue(taskFileViewerAtom).isModalOpen;
+  const filePreviewOpen = useAtomValue(filePreviewAtom).isOpen;
+  return studioModalOpen || fileViewerModalOpen || filePreviewOpen;
+}
diff --git a/apps/studio/src/client/hooks/use-guest-menu-state.ts b/apps/studio/src/client/hooks/use-guest-menu-state.ts
new file mode 100644
index 000000000..405a98250
--- /dev/null
+++ b/apps/studio/src/client/hooks/use-guest-menu-state.ts
@@ -0,0 +1,31 @@
+import { useEffect, useState } from "react";
+
+/**
+ * Controlled open state for a menu that floats over a browser guest.
+ *
+ * Clicking into the guest `<webview>` — a separate WebContents — blurs the host
+ * window but never dispatches a pointer or focus event Radix can see, so its own
+ * outside-dismiss never fires and the menu would stay stuck open over the page
+ * with no way to click it away. Closing on window blur is what dismisses it, and
+ * it is why such a menu is also rendered `modal={false}`: the modal layer's body
+ * `pointer-events: none` would otherwise swallow the very click into the guest
+ * that this relies on.
+ */
+export function useGuestMenuState() {
+  const [open, setOpen] = useState(false);
+
+  useEffect(() => {
+    if (!open) {
+      return;
+    }
+    const close = () => {
+      setOpen(false);
+    };
+    window.addEventListener("blur", close);
+    return () => {
+      window.removeEventListener("blur", close);
+    };
+  }, [open]);
+
+  return [open, setOpen] as const;
+}
diff --git a/apps/studio/src/client/hooks/use-guest-navigation.ts b/apps/studio/src/client/hooks/use-guest-navigation.ts
new file mode 100644
index 000000000..9b8a36e2a
--- /dev/null
+++ b/apps/studio/src/client/hooks/use-guest-navigation.ts
@@ -0,0 +1,214 @@
+import { getWebviewElement } from "@/client/lib/browser-pool";
+import { BROWSER_ZOOM_MAX, BROWSER_ZOOM_MIN } from "@/shared/browser";
+import { steppedZoom } from "@/shared/zoom";
+import { type BrowserTargetId } from "@instrument-org/workspace/client";
+import { useEffect, useEffectEvent, useState } from "react";
+
+export interface GuestLoadError {
+  message: string;
+  url: string;
+}
+
+// Shape of the `<webview>` `did-fail-load` DOM event (Electron adds these
+// fields; the DOM lib types it as a plain Event).
+interface DidFailLoadEvent extends Event {
+  errorCode: number;
+  errorDescription: string;
+  isMainFrame: boolean;
+  validatedURL: string;
+}
+
+/**
+ * Navigation state and controls for a pooled browser guest, shared by every
+ * surface that hosts one: the task's agent browser and the HTML artifact
+ * preview.
+ *
+ * The guest navigates from more than the controls here -- agent CDP commands
+ * for the session guest, in-page links for both -- so back/forward availability
+ * and the current URL are mirrored off the guest's own events rather than
+ * tracked from what this hook was asked to do.
+ *
+ * `isUrlEditing` lets a host with an address bar hold off URL syncing while the
+ * user is typing in it; a host without one omits it.
+ */
+export function useGuestNavigation({
+  active,
+  isUrlEditing,
+  targetId,
+}: {
+  active: boolean;
+  isUrlEditing?: () => boolean;
+  targetId: BrowserTargetId;
+}) {
+  const [nav, setNav] = useState({ back: false, forward: false });
+  const [url, setUrl] = useState("");
+  const [zoomFactor, setZoomFactor] = useState(1);
+  // Set when a main-frame navigation fails (bad host, no network, ...). The
+  // guest is parked and the host shows its own error state over the slot
+  // instead of the guest's blank error page.
+  //
+  // Stamped with the guest it happened on, and read back only for that one. The
+  // browser panel swaps `targetId` in place when the selected session changes,
+  // without a remount, so a bare error would survive into the next guest and
+  // both park it behind a notice and name the previous session's URL. Filtering
+  // on read rather than clearing in an effect keeps that out of a second render
+  // pass, so no failed page is ever briefly shown as fine.
+  const [failure, setFailure] = useState<null | {
+    error: GuestLoadError;
+    targetId: BrowserTargetId;
+  }>(null);
+  const loadError =
+    active && failure?.targetId === targetId ? failure.error : null;
+
+  // Reads the host's latest editing state without making it a dependency, so
+  // the sync effect doesn't tear down and re-subscribe as the user focuses and
+  // blurs an address bar.
+  const isEditing = useEffectEvent(() => isUrlEditing?.() ?? false);
+
+  useEffect(() => {
+    if (!active) {
+      return;
+    }
+    const webview = getWebviewElement(targetId);
+    if (!webview) {
+      return;
+    }
+    const sync = () => {
+      // getURL/canGoBack throw if the guest hasn't attached its WebContents yet;
+      // the did-navigate events that also drive this only fire once it has.
+      try {
+        if (!isEditing()) {
+          const next = webview.getURL();
+          setUrl(next === "about:blank" ? "" : next);
+        }
+        setNav({ back: webview.canGoBack(), forward: webview.canGoForward() });
+      } catch {
+        // Not attached yet; a did-navigate will re-run sync once it is.
+      }
+    };
+    const onNavigate = () => {
+      setFailure(null);
+      sync();
+    };
+    const onStartLoading = () => {
+      setFailure(null);
+    };
+    const onFailLoad = (event: Event) => {
+      const detail = event as DidFailLoadEvent;
+      // Ignore sub-frame failures and user-aborted navigations (ERR_ABORTED),
+      // which fire routinely when a new navigation supersedes an in-flight one.
+      if (!detail.isMainFrame || detail.errorCode === -3) {
+        return;
+      }
+      setFailure({
+        error: {
+          message: detail.errorDescription || "This site can’t be reached",
+          url: detail.validatedURL,
+        },
+        targetId,
+      });
+      if (!isEditing() && detail.validatedURL) {
+        setUrl(detail.validatedURL);
+      }
+      // A committed error page makes the prior page a back entry, but
+      // did-navigate doesn't reliably fire on error-page commit, so refresh the
+      // nav buttons here instead of leaving them stale (back stuck disabled).
+      try {
+        setNav({ back: webview.canGoBack(), forward: webview.canGoForward() });
+      } catch {
+        // Guest not attached yet; a later did-navigate will sync.
+      }
+    };
+    sync();
+    webview.addEventListener("did-navigate", onNavigate);
+    webview.addEventListener("did-navigate-in-page", onNavigate);
+    webview.addEventListener("did-start-loading", onStartLoading);
+    webview.addEventListener("did-fail-load", onFailLoad);
+    return () => {
+      webview.removeEventListener("did-navigate", onNavigate);
+      webview.removeEventListener("did-navigate-in-page", onNavigate);
+      webview.removeEventListener("did-start-loading", onStartLoading);
+      webview.removeEventListener("did-fail-load", onFailLoad);
+    };
+  }, [active, targetId]);
+
+  const webviewFor = () => getWebviewElement(targetId);
+
+  // loadURL rejects on a failed navigation (bad host, offline, ...); the
+  // did-fail-load listener already surfaces the error, so swallow the rejection
+  // to avoid an unhandled promise error.
+  const navigateTo = (next: string) => {
+    void webviewFor()
+      ?.loadURL(next)
+      .catch(() => {
+        // Surfaced by the did-fail-load listener; nothing to do here.
+      });
+  };
+
+  const applyZoom = (factor: number) => {
+    const webview = webviewFor();
+    if (!webview) {
+      return;
+    }
+    webview.setZoomFactor(factor);
+    setZoomFactor(factor);
+  };
+
+  return {
+    applyZoom,
+    canGoBack: nav.back,
+    canGoForward: nav.forward,
+    /** Live read of the guest's URL, or undefined if it holds no real page. */
+    currentUrl: () => {
+      try {
+        // getURL throws until the guest's WebContents is dom-ready; `active` can
+        // lead that (it round-trips through main), so treat a throw as "no page".
+        const next = webviewFor()?.getURL();
+        return next && next !== "about:blank" ? next : undefined;
+      } catch {
+        return;
+      }
+    },
+    goBack: () => webviewFor()?.goBack(),
+    goForward: () => webviewFor()?.goForward(),
+    hardReload: () => webviewFor()?.reloadIgnoringCache(),
+    loadError,
+    navigateTo,
+    reload: () => webviewFor()?.reload(),
+    // Re-read the guest's own zoom before showing it: zoom is per-page and the
+    // guest may have been zoomed by a keyboard chord this hook never saw.
+    syncZoomFactor: () => {
+      const webview = webviewFor();
+      if (!webview) {
+        return;
+      }
+      try {
+        setZoomFactor(webview.getZoomFactor());
+      } catch {
+        // Not dom-ready yet; keep the last known zoom.
+      }
+    },
+    url,
+    zoomFactor,
+    zoomIn: () => {
+      applyZoom(
+        steppedZoom({
+          direction: "in",
+          factor: zoomFactor,
+          max: BROWSER_ZOOM_MAX,
+          min: BROWSER_ZOOM_MIN,
+        }),
+      );
+    },
+    zoomOut: () => {
+      applyZoom(
+        steppedZoom({
+          direction: "out",
+          factor: zoomFactor,
+          max: BROWSER_ZOOM_MAX,
+          min: BROWSER_ZOOM_MIN,
+        }),
+      );
+    },
+  };
+}
diff --git a/apps/studio/src/electron-main/browser-view/debug-snapshot.ts b/apps/studio/src/electron-main/browser-view/debug-snapshot.ts
index 76ffe5686..589750aa1 100644
--- a/apps/studio/src/electron-main/browser-view/debug-snapshot.ts
+++ b/apps/studio/src/electron-main/browser-view/debug-snapshot.ts
@@ -41,7 +41,8 @@ const BrowserViewDebugEntrySchema = z.object({
   pendingDownloadCount: z.number(),
   screencastActive: z.boolean(),
   screencastSessionId: z.number(),
-  sessionId: z.string(),
+  // Null for an artifact-preview entry, which has no session.
+  sessionId: z.string().nullable(),
   targetId: BrowserTargetIdSchema,
   title: z.string(),
   url: z.string(),
@@ -248,11 +249,14 @@ const openAsTab = devOnly
     }
     // Open the owning task's page for this session; the task page auto-opens the
     // browser artifact panel. The typed `to` catches route staleness at compile
-    // time; the concrete id/session ride as params/search.
+    // time; the concrete id/session ride as params/search. An artifact-preview
+    // entry has no session to select, so it just opens the task.
     sendAppCommand({
       newTab: true,
       params: { id: String(entry.id) },
-      search: { selectedSessionId: String(entry.sessionId) },
+      search: entry.sessionId
+        ? { selectedSessionId: String(entry.sessionId) }
+        : {},
       to: "/tasks/$id/",
       type: "navigate",
     });
diff --git a/apps/studio/src/electron-main/browser-view/downloads.ts b/apps/studio/src/electron-main/browser-view/downloads.ts
index d8566ef6c..4017e434f 100644
--- a/apps/studio/src/electron-main/browser-view/downloads.ts
+++ b/apps/studio/src/electron-main/browser-view/downloads.ts
@@ -35,7 +35,20 @@ export function attachDownloadHandler({
 }) {
   session.on("will-download", (_event, item) => {
     const entry = entries.get(targetId);
-    if (!entry?.authorizedDownloadPath) {
+    if (!entry) {
+      item.cancel();
+      return;
+    }
+    // An artifact preview has no agent driving it, so there is no authorized
+    // path to route a download into and nothing to synthesize a CDP event for.
+    // Leave it to Electron, which prompts for a location: a "Download CSV"
+    // button in a generated report worked on the iframe this replaced (it
+    // carried `allow-downloads`), and cancelling here would make it silently
+    // dead. The user asked for the file by clicking it.
+    if (!entry.sessionId) {
+      return;
+    }
+    if (!entry.authorizedDownloadPath) {
       item.cancel();
       return;
     }
diff --git a/apps/studio/src/electron-main/browser-view/entry.ts b/apps/studio/src/electron-main/browser-view/entry.ts
index 820f7e1e9..317ffd5bc 100644
--- a/apps/studio/src/electron-main/browser-view/entry.ts
+++ b/apps/studio/src/electron-main/browser-view/entry.ts
@@ -50,8 +50,12 @@ export interface BrowserEntry {
   pendingDownloadGuids: Map<string, string>;
   screencastInterval: null | ReturnType<typeof setInterval>;
   screencastSessionId: number;
-  sessionId: StoreId.Session;
-  // Stable, externally-meaningful target id: `${id}/${sessionId}`.
+  // Null for an artifact-preview guest: it belongs to a task, not to any one
+  // session, and is never reachable over CDP. Anything session-shaped (agent
+  // daemon cleanup, CDP heartbeats) keys off this being present.
+  sessionId: null | StoreId.Session;
+  // Stable, externally-meaningful target id: `${id}/${sessionId}` for a
+  // session guest, `${id}/artifact` for the task's preview guest.
   // Used as the manager Map key, the CDP URL path component, and the wire
   // identifier in BrowserConfig. Independent of webContents.id (which becomes
   // undefined after destruction in Electron 41+, electron/electron#50249).
@@ -83,7 +87,7 @@ export function createEntry({
 }: {
   id: TaskId;
   partitionDir: AbsolutePath;
-  sessionId: StoreId.Session;
+  sessionId: null | StoreId.Session;
   targetId: BrowserTargetId;
 }): BrowserEntry {
   return {
diff --git a/apps/studio/src/electron-main/browser-view/manager.ts b/apps/studio/src/electron-main/browser-view/manager.ts
index 631993fed..630790d2b 100644
--- a/apps/studio/src/electron-main/browser-view/manager.ts
+++ b/apps/studio/src/electron-main/browser-view/manager.ts
@@ -11,6 +11,7 @@ import {
   type BrowserConfig,
   type BrowserTarget,
   type BrowserTargetId,
+  encodeArtifactTargetId,
   encodeBrowserTargetId,
   type StoreId,
   type TaskId,
@@ -38,7 +39,10 @@ import { canStealFocus, createFocusGuard } from "./focus-guard";
 import { attachGuestInteractions } from "./guest-interactions";
 import { log } from "./log";
 import { stopScreencast } from "./screencast";
-import { guestWindowOpenHandler } from "./window-open-policy";
+import {
+  guestWindowOpenHandler,
+  shouldOpenArtifactLinkExternally,
+} from "./window-open-policy";
 
 // How long createTarget waits for the renderer to mount the guest `<webview>`
 // and Electron to fire `did-attach-webview`. The main-window renderer is alive
@@ -158,11 +162,29 @@ export function createBrowserViewManager(): BrowserViewManager {
     // guest's locked-down, same-partition session (see guestWindowOpenHandler),
     // so the opener/postMessage channel that "Continue with Google" and similar
     // flows complete through stays intact instead of hanging.
-    guest.setWindowOpenHandler((details) =>
-      focusGuard.isGuarded(targetId)
+    // An artifact-preview guest opens no child window at all: the allowance
+    // below exists for sign-in popups reached by browsing, which agent-written
+    // HTML has no flow for. Its `target="_blank"` links still go to the OS
+    // browser, the way they did on the iframe this replaced.
+    const isArtifactGuest = !entry.sessionId;
+    guest.setWindowOpenHandler((details) => {
+      if (isArtifactGuest) {
+        if (shouldOpenArtifactLinkExternally(details)) {
+          // Loaded on demand rather than imported: `open-external` reaches the
+          // preferences and app-state stores through its exception capture, and
+          // pulling that whole graph in at module scope breaks node tests of
+          // unrelated modules that transitively import this one. The open is
+          // fire-and-forget, so the handler still answers synchronously.
+          void import("../lib/open-external").then(({ openExternal }) =>
+            openExternal(details.url),
+          );
+        }
+        return { action: "deny" };
+      }
+      return focusGuard.isGuarded(targetId)
         ? { action: "deny" }
-        : guestWindowOpenHandler(details),
-    );
+        : guestWindowOpenHandler(details);
+    });
     // A sign-in popup may open a further popup (multi-step / account-chooser
     // flows); keep the shape policy on the child so those don't hang either.
     guest.on("did-create-window", (child) => {
@@ -336,16 +358,48 @@ export function createBrowserViewManager(): BrowserViewManager {
     });
   }
 
+  // The task's HTML artifact-preview guest. Same mount path as createTarget,
+  // differing only in the id kind and the (separate) storage profile it is
+  // given; see BrowserTargetIdSchema for why the two ids cannot collide.
+  function createArtifactTarget(
+    id: TaskId,
+    partitionDir: AbsolutePath,
+  ): Promise<{ targetId: BrowserTargetId }> {
+    return ensureTarget({
+      id,
+      partitionDir,
+      sessionId: null,
+      targetId: encodeArtifactTargetId(id),
+    });
+  }
+
   function createTarget(
     id: TaskId,
     sessionId: StoreId.Session,
     partitionDir: AbsolutePath,
   ): Promise<{ targetId: BrowserTargetId }> {
-    const targetId = encodeBrowserTargetId(id, sessionId);
+    return ensureTarget({
+      id,
+      partitionDir,
+      sessionId,
+      targetId: encodeBrowserTargetId(id, sessionId),
+    });
+  }
 
+  function ensureTarget({
+    id,
+    partitionDir,
+    sessionId,
+    targetId,
+  }: {
+    id: TaskId;
+    partitionDir: AbsolutePath;
+    sessionId: null | StoreId.Session;
+    targetId: BrowserTargetId;
+  }): Promise<{ targetId: BrowserTargetId }> {
     const existing = entries.get(targetId);
     if (existing) {
-      // Idempotent: a single (id, sessionId) pair owns at most one guest.
+      // Idempotent: a target id owns at most one guest.
       // Already bound -> reuse it; mount still in flight -> wait on it.
       if (existing.webContents && !existing.webContents.isDestroyed()) {
         return Promise.resolve({ targetId });
@@ -395,6 +449,12 @@ export function createBrowserViewManager(): BrowserViewManager {
       if (entry.id !== id) {
         continue;
       }
+      // This list is the agent's `/json` target discovery. An artifact-preview
+      // guest is the user's, not the agent's, so it stays out of it and the
+      // agent sees exactly the targets it always has.
+      if (!entry.sessionId) {
+        continue;
+      }
 
       const wc = entry.webContents;
       // electron/electron#50249: webContents is undefined after destruction in Electron 41+
@@ -440,6 +500,7 @@ export function createBrowserViewManager(): BrowserViewManager {
         destroyEntry(entries, targetId);
         notifyEntriesChanged();
       }),
+    createArtifactTarget,
     createTarget,
     getTargetMeta: (targetId) => {
       const entry = entries.get(targetId);
diff --git a/apps/studio/src/electron-main/browser-view/window-open-policy.test.ts b/apps/studio/src/electron-main/browser-view/window-open-policy.test.ts
index e63cddcc3..5cae7885c 100644
--- a/apps/studio/src/electron-main/browser-view/window-open-policy.test.ts
+++ b/apps/studio/src/electron-main/browser-view/window-open-policy.test.ts
@@ -1,7 +1,10 @@
 import { type HandlerDetails } from "electron";
 import { describe, expect, it } from "vitest";
 
-import { guestWindowOpenHandler } from "./window-open-policy";
+import {
+  guestWindowOpenHandler,
+  shouldOpenArtifactLinkExternally,
+} from "./window-open-policy";
 
 function details(overrides: Partial<HandlerDetails>): HandlerDetails {
   return {
@@ -84,3 +87,31 @@ describe("guestWindowOpenHandler", () => {
     ).toBe("allow");
   });
 });
+
+describe("shouldOpenArtifactLinkExternally", () => {
+  // The artifact guest opens no window of its own; these are the opens it
+  // hands to the OS browser instead, which is what a `target="_blank"` link in
+  // an agent-written report did on the iframe this surface replaced.
+  it.each([
+    { name: "https new tab", overrides: { disposition: "foreground-tab" } },
+    { name: "http new tab", overrides: { url: "http://example.test/docs" } },
+    { name: "background tab", overrides: { disposition: "background-tab" } },
+    { name: "new-window popup", overrides: { disposition: "new-window" } },
+  ] satisfies { name: string; overrides: Partial<HandlerDetails> }[])(
+    "hands $name to the OS browser",
+    ({ overrides }) => {
+      expect(shouldOpenArtifactLinkExternally(details(overrides))).toBe(true);
+    },
+  );
+
+  it.each([
+    { name: "file URL", overrides: { url: "file:///etc/passwd" } },
+    { name: "javascript URL", overrides: { url: "javascript:alert(1)" } },
+    { name: "malformed URL", overrides: { url: "not a url" } },
+  ] satisfies { name: string; overrides: Partial<HandlerDetails> }[])(
+    "refuses $name",
+    ({ overrides }) => {
+      expect(shouldOpenArtifactLinkExternally(details(overrides))).toBe(false);
+    },
+  );
+});
diff --git a/apps/studio/src/electron-main/browser-view/window-open-policy.ts b/apps/studio/src/electron-main/browser-view/window-open-policy.ts
index c149f4360..655b8defe 100644
--- a/apps/studio/src/electron-main/browser-view/window-open-policy.ts
+++ b/apps/studio/src/electron-main/browser-view/window-open-policy.ts
@@ -35,6 +35,29 @@ export function guestWindowOpenHandler(
   };
 }
 
+/**
+ * Whether an artifact-preview guest's window-open should be handed to the OS
+ * browser. Such a guest never opens a child window of its own -- it browses
+ * nothing, so it has no sign-in flow to keep alive -- but a `target="_blank"`
+ * link in an agent-written report is ordinary and still has to do something.
+ * On the sandboxed iframe this surface replaced, such a click bubbled to the
+ * main window's handler and was sent to the OS browser; refusing it outright
+ * would leave the link dead, with no address bar to follow it from.
+ *
+ * A predicate rather than a handler so this module stays free of Electron
+ * runtime imports and remains unit-testable; the caller does the opening.
+ */
+export function shouldOpenArtifactLinkExternally(
+  details: HandlerDetails,
+): boolean {
+  try {
+    const { protocol } = new URL(details.url);
+    return protocol === "http:" || protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
 function clampPopupDimension(value: null | string, fallback: number): number {
   const parsed = value == null ? Number.NaN : Number.parseInt(value, 10);
   if (Number.isNaN(parsed)) {
diff --git a/docs/architecture/in-app-browser.md b/docs/architecture/in-app-browser.md
index e2889e78f..d1b3635b7 100644
--- a/docs/architecture/in-app-browser.md
+++ b/docs/architecture/in-app-browser.md
@@ -17,10 +17,34 @@ Each guest stays parented to `document.body` for its whole life so that React re
 - **paint-host** — laid out at the guest's logical size but visually hidden (`opacity: 0.001`). Chromium still paints it on screen, so `capturePage()` and CDP input keep working while nothing is showing it.
 - **visible** — positioned over a host slot (the task page's browser panel) and scaled to fit, with input enabled.
 
-Capture requires the guest to be on-screen and unoccluded, which is why "hidden" is a near-zero opacity rather than `display: none`. At most one guest is visible at a time: a task's panel shows its guest only while its tab is foreground and parks it otherwise. **Hiding or closing the panel never disposes a guest** — only the main process's desired set does that.
+Capture requires the guest to be on-screen and unoccluded, which is why "hidden" is a near-zero opacity rather than `display: none`. **Hiding or closing the panel never disposes a guest** — only the main process's desired set does that.
+
+Nothing in the pool limits how many guests are visible: `showOverSlot` and `setPaintHost` are per-target. In practice the callers keep it to one, because a task's browser panel and its artifact preview are the same slot (`artifactPanelSchema` is a discriminated union, and `TaskView` renders one or the other) and each shows its guest only while its tab is foreground.
+
+A full-window overlay is the one thing that covers a slot without looking like a tab switch. The guest is mounted on `document.body`, outside every dialog's subtree, so no overlay occludes it — it keeps painting over the dim layer as though nothing opened. A host under one passes `covered`; see [`use-guest-covered.ts`](../../apps/studio/src/client/hooks/use-guest-covered.ts), which reports all three overlay sources (studio modals, the file viewer's expand modal, the chat's image preview).
 
 [`use-browser-slot.ts`](../../apps/studio/src/client/hooks/use-browser-slot.ts) measures the slot and drives show/park; [`use-browser-targets.ts`](../../apps/studio/src/client/hooks/use-browser-targets.ts) exposes which targets have actually attached.
 
+## Two target kinds
+
+`BrowserTargetId` has two admissible forms, one per guest kind ([`types.ts`](../../packages/workspace/src/types.ts)):
+
+```
+${taskId}/${sessionId}   session guest   -- the agent-drivable browser this doc is mostly about
+${taskId}/artifact       artifact guest  -- the task's HTML artifact preview
+```
+
+`artifact` is a fixed sentinel, not an id; session ids are `ses_`-prefixed ULIDs, so the two cannot collide. `decodeBrowserTargetId` returns a discriminated `{kind}` so callers that only make sense for one kind — the CDP bridge and the agent's target list, both session-only — have to say so.
+
+The artifact guest exists so the surface the agent verifies its own work on and the surface the user reads are the same kind of thing: both a real origin, both a real webContents. See [html-artifact-iframe-navigation](../findings/html-artifact-iframe-navigation.md). It differs from a session guest in four ways:
+
+- **One per task**, navigated between files with `loadURL` rather than one webContents per HTML file. Exactly one preview is ever mounted for it — `FileViewer` withholds Expand for HTML so a second host cannot exist.
+- **Its own storage profile, per task** (`<rootDir>/<private>/artifact-preview-session/<taskId>`). Origins are not enough on their own: `localStorage` and IndexedDB are keyed by origin, but cookies are domain-scoped, so a page on `assets.<a>.localhost` could set one for `localhost` and read it from another task's preview through a shared jar.
+- **Not agent-reachable.** `listTargets` skips it, so it never appears in the agent's `/json` discovery, and the CDP bridge refuses a WS upgrade for an artifact-kind id.
+- **Opens no child window**, though `target=_blank` still reaches the OS browser, and **downloads prompt** rather than being cancelled — both restoring what the sandboxed iframe did.
+
+**No lifetime machine.** Its id is derived from the task id, so `trash-task` closes it and removes its profile with no registry to consult; nothing else reaps it. One webContents per task whose HTML artifact you opened, for the life of the task.
+
 ## Attach lifecycle
 
 `createTarget` in [`manager.ts`](../../apps/studio/src/electron-main/browser-view/manager.ts) records an entry, then waits for the renderer to mount the guest and Electron to fire `did-attach-webview`. Target ids accepted in `will-attach-webview` are drained through a FIFO, and each entry carries a generation bumped per create so the renderer pool can diff a recreate of a just-destroyed id against the old one.
@@ -47,7 +71,7 @@ The wrapper rejects upstream flags and subcommands that would select another con
 
 `Emulation.setDeviceMetricsOverride` is **refused outright** for agent-browser callers in `dispatch-command.ts`, but available to the panel's "View as" menu through [`device-emulation.ts`](../../apps/studio/src/electron-main/browser-view/device-emulation.ts). The difference is `scale`: the panel computes it from the guest's live measured bounds, so the surface always shrinks to fit what is on screen. An external caller cannot know the guest's current on-screen size, and an unscaled oversized override is what corrupted the panel with dead space and cropped rendering. See also [in-app-browser-device-emulation](../findings/in-app-browser-device-emulation.md).
 
-Popups follow a shape policy in [`window-open-policy.ts`](../../apps/studio/src/electron-main/browser-view/window-open-policy.ts): real `window.open` popups to http(s) are **allowed** (denying them returns null and hangs "Continue with Google" style sign-in flows), while `target=_blank` and JS tab-opens report `foreground-tab`/`background-tab` and stay denied. Opens are additionally denied while agent CDP activity is driving the guest, so automation cannot spawn a window the user never asked for. Turning popups into real agent-drivable tabs is [a plan](../plans/active/browser-popups-as-agent-drivable-tabs.md), not current behavior.
+Popups follow a shape policy in [`window-open-policy.ts`](../../apps/studio/src/electron-main/browser-view/window-open-policy.ts): real `window.open` popups to http(s) are **allowed** (denying them returns null and hangs "Continue with Google" style sign-in flows), while `target=_blank` and JS tab-opens report `foreground-tab`/`background-tab` and stay denied. Opens are additionally denied while agent CDP activity is driving the guest, so automation cannot spawn a window the user never asked for, and an artifact guest opens no child window at all — though it hands `target=_blank` http(s) opens to `openExternal`, matching what those links did on the iframe it replaced. Turning popups into real agent-drivable tabs is [a plan](../plans/active/browser-popups-as-agent-drivable-tabs.md), not current behavior.
 
 ## Focus
 
@@ -55,11 +79,11 @@ Popups follow a shape policy in [`window-open-policy.ts`](../../apps/studio/src/
 
 ## Lifetime
 
-[`task-browser.ts`](../../packages/workspace/src/machines/task-browser.ts) supervises a task's browser as an XState machine with `Observed` / `Unobserved` / `GracePeriod` / `Stopping` / `Stopped` states, on two clocks: `AGENT_IDLE_TIMEOUT_MS` (1 hour) and `USER_PRESENCE_TIMEOUT_MS` (5 minutes). The renderer reports presence through `browser.live.presence` in the workspace RPC. Sessions are torn down through `agent-browser-cleanup.ts`; see [agent-browser-orphaned-daemons](../findings/agent-browser-orphaned-daemons.md) and [agent-browser-ref-map-idle-ttl](../findings/agent-browser-ref-map-idle-ttl.md) for the failure modes that shaped it.
+[`task-browser.ts`](../../packages/workspace/src/machines/task-browser.ts) supervises a task's **session** browser as an XState machine with `Observed` / `Unobserved` / `GracePeriod` / `Stopping` / `Stopped` states, on two clocks: `AGENT_IDLE_TIMEOUT_MS` (1 hour) and `USER_PRESENCE_TIMEOUT_MS` (5 minutes). The renderer reports presence through `browser.live.presence` in the workspace RPC. Sessions are torn down through `agent-browser-cleanup.ts`; see [agent-browser-orphaned-daemons](../findings/agent-browser-orphaned-daemons.md) and [agent-browser-ref-map-idle-ttl](../findings/agent-browser-ref-map-idle-ttl.md) for the failure modes that shaped it.
 
 ## Related
 
 - [agent-sandbox.md](agent-sandbox.md) — the `agent-browser` argv allowlist and asset-URL rewriting.
 - [asset-origin.md](asset-origin.md) — the per-task origin the guest loads when it is pointed at the task's own files.
 - [in-app-browser-full-page-screenshots](../findings/in-app-browser-full-page-screenshots.md) — why full-page capture is not just a CDP flag.
-- [html-artifact-iframe-navigation](../findings/html-artifact-iframe-navigation.md) — the artifact iframe, which is a different surface from this one.
+- [html-artifact-iframe-navigation](../findings/html-artifact-iframe-navigation.md) — why HTML artifacts moved off a sandboxed iframe onto this pool.
diff --git a/docs/findings/html-artifact-iframe-navigation.md b/docs/findings/html-artifact-iframe-navigation.md
index 27ff99ba6..3aa4ca13e 100644
--- a/docs/findings/html-artifact-iframe-navigation.md
+++ b/docs/findings/html-artifact-iframe-navigation.md
@@ -1,6 +1,6 @@
 # HTML file artifacts: in-iframe link navigation can't be tracked or driven
 
-**Status:** open — minimal reset-to-root shipped; full browser chrome deferred. Last updated 2026-07-17.
+**Status:** resolved — HTML artifacts render in a `<webview>` guest, which has real navigation. Last updated 2026-08-04.
 
 ## Symptom
 
@@ -26,8 +26,43 @@ Escape-to-root only, via remounting the iframe so it reloads `src` (the entry pa
 
 Both snap the preview back to the artifact's entry page. Note this reloads `src`, not the navigated-away sub-page — the sub-page URL is unreadable cross-origin, so true reload/back of a sub-page isn't possible here.
 
-## What might resolve it later
+## Resolution
 
-Real back/forward/address chrome requires changing the primitive, not the iframe. Route HTML file artifacts through the existing `<webview>` guest pool (`apps/studio/src/client/lib/browser-pool.ts` + `apps/studio/src/electron-main/browser-view/manager.ts`) pointed at the asset URL, and reuse a generalized version of the browser panel's chrome. That pool and manager are keyed purely by an opaque `BrowserTargetId`, but target creation currently flows through `workspace.browser.open` (a task/session browsing session), so this needs a new non-session target kind plus the overlay-slot plumbing (body-mounted guest positioned over a measured slot).
+The primitive changed. HTML artifacts render through the same `<webview>` guest pool the agent browser uses ([`html-artifact-preview.tsx`](../../apps/studio/src/client/components/html-artifact-preview.tsx)), pointed at the same asset URL. A guest's `goBack()` / `goForward()` / `getURL()` / navigation events are all available, so the preview has real back, forward, reload, hard reload, find-in-page, zoom, and a return-to-entry-page control, plus a read-only path readout. Both reload nonces are gone: escaping a link navigation is `loadURL(entryUrl)` from any depth, and reloading a navigated-to sub-page works for the first time.
 
-Tradeoff to weigh before doing this: a `<webview>` guest loads the asset origin as a real origin with cookies/storage, dropping the deliberate opaque-sandbox isolation the iframe gives untrusted agent-generated HTML. The rejected alternative — injecting a script + `postMessage` history bridge into the HTML — was ruled out: it only works for cooperating HTML and adds fragile two-way iframe messaging.
+The guest is a second target kind, `${taskId}/artifact` (see `BrowserTargetIdSchema`), created through its own `workspace.artifactPreview.open` rather than `browser.open`, which is session-keyed. It is excluded from `listTargets` and refused by the CDP bridge, so the agent's target list and CDP surface are unchanged.
+
+**No lifetime machine.** The target id is derived from the task id, so `trash-task` closes it and removes its profile without any registry, and the app's own teardown takes the rest. One webContents per task whose HTML artifact you opened, for the life of the task. An earlier attempt supervised these with a presence lease and a grace period; it cost an XState machine, its tests, and a family of teardown races, for a resource that is already bounded by the number of tasks you open an artifact in.
+
+**One host, deliberately.** `FileViewer` withholds Expand for HTML files. Two hosts sharing one guest have to agree on which file is on screen, who owns Cmd+F, and which may paint — none of which a viewer can answer from its own props. The artifact panel already gives an artifact the full pane, so the affordance is withheld rather than arbitrated.
+
+### The tradeoff resolved the other way
+
+The concern recorded here was that a guest "drops the deliberate opaque-sandbox isolation". Measured against what the iframe actually granted, the move is a net tightening:
+
+| | iframe (before) | artifact guest (now) |
+| --- | --- | --- |
+| Origin | opaque | real (`assets.<taskId>.localhost`) |
+| Storage / cookies | none | own profile, isolated from the browsing profile |
+| Camera, mic, geolocation, USB | **granted via `allow`** | denied by the session permission handler |
+| Popups | granted | **denied** (`target=_blank` still opens in the OS browser) |
+| Cross-task isolation | n/a | by origin *and* by a storage profile per task |
+
+The iframe's `sandbox` already granted scripts, forms, modals, popups and pointer-lock, and its `allow` list granted camera, microphone, geolocation, clipboard, display-capture, MIDI, payment and USB. What is new is that agent HTML can persist storage and set cookies, scoped to a per-task asset origin holding nothing but that task's own files, in a profile (`<rootDir>/<private>/artifact-preview-session/<taskId>`) separate both from the agent's browsing profile and from every other task's preview.
+
+Per task rather than one shared directory because origin is not enough on its own: `localStorage` and IndexedDB are keyed by origin, but cookies are scoped by domain, so a page on `assets.<a>.localhost` could set one for `localhost` and reach another task's preview through a shared jar.
+
+### What the guest had to keep doing
+
+Two things a report can ordinarily do worked on the iframe by inheriting the host page's behavior, and had to be restored rather than falling out of the guest's stricter defaults:
+
+- **`target="_blank"` links.** In the iframe these bubbled to the main window's `setWindowOpenHandler`, which sends them to the OS browser. An artifact guest opens no child window, but hands http(s) opens to `openExternal` — otherwise an ordinary external link in a report is silently dead, with no address bar to follow it from.
+- **Downloads.** The iframe carried `allow-downloads`. The guest session cancels any download without an agent-authorized path, which is right for an agent-driven guest and wrong for a preview, so an artifact guest lets Electron prompt.
+
+### Why this was worth doing beyond the chrome
+
+The agent and the user load the same URL. Rendering them on different primitives meant everything origin-scoped behaved differently between the surface the agent screenshots to check its own work and the surface the user reads: `localStorage`, cookies, IndexedDB, and same-origin `fetch` of a sibling file. Agent-authored HTML that persists a filter selection, or reads its own `data.json`, could pass the agent's check and fail in front of the user. Both now render as a real origin through the identical Chromium path. Sibling fetches are same-origin and need no CORS; the `cors()` on the assets origin remains for other consumers.
+
+## Rejected alternative
+
+Injecting a script + `postMessage` history bridge into the HTML: works only for cooperating HTML and adds fragile two-way iframe messaging.
diff --git a/packages/workspace/src/client.ts b/packages/workspace/src/client.ts
index 6cee6019f..d6b780c73 100644
--- a/packages/workspace/src/client.ts
+++ b/packages/workspace/src/client.ts
@@ -36,5 +36,6 @@ export {
   type BrowserTargetId,
   BrowserTargetIdSchema,
   decodeBrowserTargetId,
+  encodeArtifactTargetId,
   encodeBrowserTargetId,
 } from "./types";
diff --git a/packages/workspace/src/constants.ts b/packages/workspace/src/constants.ts
index 6920b735b..dee5b3071 100644
--- a/packages/workspace/src/constants.ts
+++ b/packages/workspace/src/constants.ts
@@ -6,6 +6,13 @@ export const REGISTRY_FOLDER_NAMES = {
 import { TASK_PRIVATE_FOLDER_NAME } from "@instrument-org/shared";
 
 export const TASK_FOLDER_NAMES = {
+  // Storage profile root for the HTML artifact-preview guests, kept apart from
+  // `browserSession` so agent-authored pages get their own cookie jar and
+  // storage rather than sharing the browsing profile. One directory per task
+  // underneath it (see getArtifactPreviewSessionDir): origins isolate storage,
+  // but cookies are domain-scoped, so a shared jar would be a cross-task
+  // channel between two pieces of untrusted HTML.
+  artifactPreviewSession: "artifact-preview-session",
   attachments: "attachments",
   browserSession: "browser-session",
   downloads: "downloads",
diff --git a/packages/workspace/src/electron.ts b/packages/workspace/src/electron.ts
index 37fac33ba..0dee01ace 100644
--- a/packages/workspace/src/electron.ts
+++ b/packages/workspace/src/electron.ts
@@ -40,11 +40,13 @@ export {
   WebSearchResponseSchema,
 } from "./schemas/web-search";
 export {
+  ARTIFACT_TARGET_KEY,
   type BrowserConfig,
   type BrowserTarget,
   type BrowserTargetId,
   BrowserTargetIdSchema,
   decodeBrowserTargetId,
+  encodeArtifactTargetId,
   encodeBrowserTargetId,
   type WorkspaceConfig,
 } from "./types";
diff --git a/packages/workspace/src/lib/task-dir-utils.ts b/packages/workspace/src/lib/task-dir-utils.ts
index 3af9bc1eb..381169f98 100644
--- a/packages/workspace/src/lib/task-dir-utils.ts
+++ b/packages/workspace/src/lib/task-dir-utils.ts
@@ -11,6 +11,28 @@ import { type TaskId } from "../schemas/task-id";
 import { absolutePathJoin } from "./absolute-path-join";
 import { getWorkspaceConfig } from "./workspace-config";
 
+/**
+ * Storage profile for one task's HTML artifact-preview guest.
+ *
+ * Per task, not one shared profile: the distinct asset origins isolate
+ * `localStorage` and IndexedDB, but cookies are scoped by domain rather than by
+ * origin, so a page served from `assets.<a>.localhost` can set one for
+ * `localhost` and any other task's preview sharing the jar would send and read
+ * it. Agent-authored HTML is untrusted, so that is a channel between two tasks.
+ *
+ * Lives beside the workspace's other private state rather than inside the task,
+ * so a Chromium profile never lands in a folder the user browses or exports;
+ * trash-task removes it along with the task.
+ */
+export function getArtifactPreviewSessionDir(id: TaskId): AbsolutePath {
+  return absolutePathJoin(
+    getWorkspaceConfig().rootDir,
+    TASK_FOLDER_NAMES.private,
+    TASK_FOLDER_NAMES.artifactPreviewSession,
+    id,
+  );
+}
+
 export function getBrowserSessionDir(): AbsolutePath {
   return absolutePathJoin(
     getWorkspaceConfig().rootDir,
diff --git a/packages/workspace/src/lib/trash-task.ts b/packages/workspace/src/lib/trash-task.ts
index dff24b30e..67de63abd 100644
--- a/packages/workspace/src/lib/trash-task.ts
+++ b/packages/workspace/src/lib/trash-task.ts
@@ -5,7 +5,7 @@ import { setTimeout as setTimeoutPromise } from "node:timers/promises";
 
 import { type WorkspaceActorRef } from "../machines/workspace";
 import { type TaskId } from "../schemas/task-id";
-import { type WorkspaceConfig } from "../types";
+import { encodeArtifactTargetId, type WorkspaceConfig } from "../types";
 import { absolutePathJoin } from "./absolute-path-join";
 import { TypedError } from "./errors";
 import { pathExists } from "./path-exists";
@@ -14,7 +14,7 @@ import {
   markStorageAsDisposing,
   unmarkStorageAsDisposing,
 } from "./session-store-storage";
-import { taskDir } from "./task-dir-utils";
+import { getArtifactPreviewSessionDir, taskDir } from "./task-dir-utils";
 
 interface RemoveTaskOptions {
   id: TaskId;
@@ -43,6 +43,12 @@ export async function trashTask({
       // 500ms sleep was already best-effort, this is a strict upper bound.
       await Promise.race([browserReaped, setTimeoutPromise(2000)]);
 
+      // Close the task's HTML artifact-preview guest, if it has one. No
+      // registry to consult: its target id is derived from the task id, and
+      // closeTarget resolves immediately for one that never existed. Awaited
+      // alongside the browser reap so Chromium has released the profile below.
+      await workspaceConfig.browser.closeTarget(encodeArtifactTargetId(id));
+
       // Mark storage as disposing to prevent recreation during deletion
       markStorageAsDisposing(id);
 
@@ -69,6 +75,18 @@ export async function trashTask({
 
         await workspaceConfig.trashItem(taskDir(taskId));
 
+        // The preview's storage profile lives outside the task folder (a
+        // Chromium profile has no business in a directory the user browses), so
+        // trashing the task does not take it. Best-effort: a directory left
+        // behind is dead weight for a task that no longer exists, not worth
+        // failing the deletion the user asked for.
+        const previewProfile = getArtifactPreviewSessionDir(taskId);
+        if (await pathExists(previewProfile)) {
+          await rmrf(previewProfile).catch(() => {
+            // Nothing to do: the task itself is already gone.
+          });
+        }
+
         // In the off chance that a future task with the same id is
         // created, we remove the app being trashed.
         workspaceRef.send({
diff --git a/packages/workspace/src/logic/server/routes/cdp-bridge.ts b/packages/workspace/src/logic/server/routes/cdp-bridge.ts
index bb0484e37..690ab54e4 100644
--- a/packages/workspace/src/logic/server/routes/cdp-bridge.ts
+++ b/packages/workspace/src/logic/server/routes/cdp-bridge.ts
@@ -11,6 +11,7 @@ import { TaskIdSchema } from "../../../schemas/task-id";
 import {
   type BrowserTargetId,
   BrowserTargetIdSchema,
+  decodeBrowserTargetId,
   type WorkspaceConfig,
 } from "../../../types";
 import { CDP_BASE_PATH, CDP_PAGE_PATH_PREFIX } from "../constants";
@@ -94,12 +95,16 @@ export function setupCdpWebSocketBridge(
     // No query parameters; everything routing-relevant is in the path so
     // the WS upgrade alone tells us which (id, sessionId) is wired.
     const rawTargetId = req.url.slice(CDP_PAGE_PATH_PREFIX.length);
-    const parsed = BrowserTargetIdSchema.safeParse(rawTargetId.split("?")[0]);
-    if (!parsed.success) {
+    const decoded = decodeBrowserTargetId(rawTargetId.split("?")[0] ?? "");
+    // Artifact-preview guests are not agent-drivable: they parse as target ids
+    // but exist only to show the user their own HTML. Refuse the upgrade so
+    // the CDP surface stays exactly the set of session guests it has always
+    // been. `listTargets` excludes them too, so nothing advertises one here.
+    if (decoded?.kind !== "session") {
       socket.destroy();
       return;
     }
-    const targetId = parsed.data;
+    const targetId = BrowserTargetIdSchema.parse(rawTargetId.split("?")[0]);
 
     wss.handleUpgrade(req, socket, head, (clientWs) => {
       handleCdpClient(clientWs, targetId, workspaceConfig, workspaceRef);
@@ -133,9 +138,11 @@ function handleCdpClient(
 
   // Surface this WS connection to the taskBrowser machine so it can fan
   // out `agent-browser close --session <id>` at reap time. Lookup is cheap
-  // and missing meta means the target was already destroyed; skip.
+  // and missing meta means the target was already destroyed; skip. A null
+  // sessionId is an artifact-preview target, which the upgrade handler already
+  // refuses -- there is no session to attach.
   const initialMeta = workspaceConfig.browser.getTargetMeta(targetId);
-  if (initialMeta) {
+  if (initialMeta?.sessionId) {
     workspaceRef.send({
       type: "workspaceServer.attachAgentSession",
       value: {
@@ -229,7 +236,7 @@ function handleCdpClient(
     // The agent is the only writer on this WS so this matches real agent
     // command rate without throttling.
     const meta = workspaceConfig.browser.getTargetMeta(targetId);
-    if (meta) {
+    if (meta?.sessionId) {
       workspaceRef.send({
         type: "workspaceServer.updateCdpHeartbeat",
         value: {
diff --git a/packages/workspace/src/machines/task-browser.test.ts b/packages/workspace/src/machines/task-browser.test.ts
index 573aef5ca..9804e5aa1 100644
--- a/packages/workspace/src/machines/task-browser.test.ts
+++ b/packages/workspace/src/machines/task-browser.test.ts
@@ -14,6 +14,7 @@ import { TaskIdSchema } from "../schemas/task-id";
 import {
   type BrowserConfig,
   type BrowserTargetId,
+  encodeArtifactTargetId,
   encodeBrowserTargetId,
 } from "../types";
 import {
@@ -51,12 +52,16 @@ vi.mock(import("../lib/agent-browser-cleanup"), () => ({
 const { closeAgentBrowserSessionsForSessions } =
   await import("../lib/agent-browser-cleanup");
 
+const createArtifactTargetMock: BrowserConfig["createArtifactTarget"] = (id) =>
+  Promise.resolve({ targetId: encodeArtifactTargetId(id) });
+
 const createTargetMock: BrowserConfig["createTarget"] = (id, sessionId) =>
   Promise.resolve({ targetId: encodeBrowserTargetId(id, sessionId) });
 
 function makeBrowser(): BrowserConfig {
   return {
     closeTarget: vi.fn(asyncNoop),
+    createArtifactTarget: vi.fn(createArtifactTargetMock),
     createTarget: vi.fn(createTargetMock),
     getTargetMeta: vi.fn(() => null),
     listTargets: vi.fn(emptyTargets),
diff --git a/packages/workspace/src/rpc/index.ts b/packages/workspace/src/rpc/index.ts
index 2370dc1af..b91abe406 100644
--- a/packages/workspace/src/rpc/index.ts
+++ b/packages/workspace/src/rpc/index.ts
@@ -1,3 +1,4 @@
+import { artifactPreview } from "./routes/artifact-preview";
 import { browser } from "./routes/browser";
 import { debug } from "./routes/debug";
 import { message } from "./routes/message";
@@ -12,6 +13,7 @@ import { storage } from "./routes/storage";
 import { task } from "./routes/task";
 
 export const router = {
+  artifactPreview,
   browser,
   debug,
   message,
diff --git a/packages/workspace/src/rpc/routes/artifact-preview.ts b/packages/workspace/src/rpc/routes/artifact-preview.ts
new file mode 100644
index 000000000..a08e9e6c2
--- /dev/null
+++ b/packages/workspace/src/rpc/routes/artifact-preview.ts
@@ -0,0 +1,41 @@
+import { z } from "zod";
+
+import { getArtifactPreviewSessionDir } from "../../lib/task-dir-utils";
+import { TaskIdSchema } from "../../schemas/task-id";
+import { BrowserTargetIdSchema } from "../../types";
+import { base } from "../base";
+
+// Create (or reuse) the task's HTML artifact-preview guest.
+//
+// Deliberately not `browser.open`: that one takes a session id because it
+// registers with the session-keyed taskBrowser machine, whose teardown fans out
+// `agent-browser close --session`. A preview has no session, so it gets its own
+// door and its own storage profile.
+//
+// Idempotent per task: one guest that navigates between files, the way a browser
+// tab does, rather than one webContents per HTML file. Its id is derivable from
+// the task id, which is what lets trash-task close it without any bookkeeping
+// here -- there is no lifetime machine and nothing to register.
+const open = base
+  .errors({
+    ARTIFACT_PREVIEW_OPEN_FAILED: {
+      message: "Failed to open the artifact preview",
+    },
+  })
+  .input(z.object({ id: TaskIdSchema }))
+  .output(z.object({ targetId: BrowserTargetIdSchema }))
+  .handler(async ({ context, errors, input }) => {
+    const { id } = input;
+
+    const target = await context.workspaceConfig.browser
+      .createArtifactTarget(id, getArtifactPreviewSessionDir(id))
+      .catch((error: unknown) => {
+        throw errors.ARTIFACT_PREVIEW_OPEN_FAILED({
+          message: error instanceof Error ? error.message : "Unknown error",
+        });
+      });
+
+    return { targetId: target.targetId };
+  });
+
+export const artifactPreview = { open };
diff --git a/packages/workspace/src/test/helpers/mock-task-config.ts b/packages/workspace/src/test/helpers/mock-task-config.ts
index 889342536..6f19b14aa 100644
--- a/packages/workspace/src/test/helpers/mock-task-config.ts
+++ b/packages/workspace/src/test/helpers/mock-task-config.ts
@@ -26,6 +26,7 @@ import {
 } from "../../schemas/web-search";
 import {
   type BrowserConfig,
+  encodeArtifactTargetId,
   encodeBrowserTargetId,
   type WorkspaceConfig,
 } from "../../types";
@@ -154,6 +155,8 @@ export function createMockTaskConfigForDir(
 export function createStubBrowserConfig(): BrowserConfig {
   return {
     closeTarget: () => Promise.resolve(),
+    createArtifactTarget: (id) =>
+      Promise.resolve({ targetId: encodeArtifactTargetId(id) }),
     createTarget: (id, sessionId) =>
       Promise.resolve({
         targetId: encodeBrowserTargetId(id, sessionId),
diff --git a/packages/workspace/src/test/setup.ts b/packages/workspace/src/test/setup.ts
index b4b490478..c2dcb7bb3 100644
--- a/packages/workspace/src/test/setup.ts
+++ b/packages/workspace/src/test/setup.ts
@@ -31,6 +31,7 @@ setWorkspaceConfig({
   appVersion: "0.0.0-test",
   browser: {
     closeTarget: () => Promise.resolve(),
+    createArtifactTarget: rejectBrowserTarget,
     createTarget: rejectBrowserTarget,
     getTargetMeta: () => null,
     listTargets: () => Promise.resolve([]),
diff --git a/packages/workspace/src/types.ts b/packages/workspace/src/types.ts
index 315574641..c1aa3b1b8 100644
--- a/packages/workspace/src/types.ts
+++ b/packages/workspace/src/types.ts
@@ -18,6 +18,13 @@ import { type WebSearchClient } from "./schemas/web-search";
 
 export interface BrowserConfig {
   closeTarget: (targetId: BrowserTargetId) => Promise<void>;
+  // The task's artifact-preview guest: one per task, navigated between HTML
+  // files rather than recreated per file. Separate from `createTarget` because
+  // it has no session -- see BrowserTargetIdSchema for the two id kinds.
+  createArtifactTarget: (
+    id: TaskId,
+    partitionDir: AbsolutePath,
+  ) => Promise<{ targetId: BrowserTargetId }>;
   createTarget: (
     id: TaskId,
     sessionId: StoreId.Session,
@@ -26,7 +33,9 @@ export interface BrowserConfig {
   getTargetMeta: (targetId: BrowserTargetId) => null | {
     id: TaskId;
     partitionDir: AbsolutePath;
-    sessionId: StoreId.Session;
+    // Null for an artifact-preview target, which belongs to a task rather than
+    // to any one session.
+    sessionId: null | StoreId.Session;
   };
   listTargets: (id: TaskId) => Promise<BrowserTarget[]>;
   onTargetDestroyed: (
@@ -60,13 +69,26 @@ export interface BrowserTarget {
 
 export type TaskStatus = (typeof TASK_STATUSES)[number];
 
-// The bridge routing key for a single browser view: a (id, sessionId)
-// tuple encoded as `${id}/${sessionId}`. The schema delegates to the
-// existing TaskId and StoreId.Session validators so a parse failure
-// pinpoints the offending half. Use `encodeBrowserTargetId` /
-// `decodeBrowserTargetId` to construct or parse one; never build by hand.
+/**
+ * Second half of an artifact-preview target id. A fixed sentinel rather than an
+ * id: session ids are `ses_`-prefixed ULIDs, so the two forms cannot collide.
+ */
+export const ARTIFACT_TARGET_KEY = "artifact";
+
+// The bridge routing key for a single browser view. Two admissible forms, one
+// per guest kind:
+//
+//   `${id}/${sessionId}`  session guest  -- the task's agent-drivable browser
+//   `${id}/artifact`      artifact guest -- the task's HTML artifact preview
+//
+// The session form delegates to the existing TaskId and StoreId.Session
+// validators so a parse failure pinpoints the offending half. Use
+// `encodeBrowserTargetId` / `encodeArtifactTargetId` / `decodeBrowserTargetId`
+// to construct or parse one; never build by hand.
 export const BrowserTargetIdSchema = z
-  .custom<`${TaskId}/${StoreId.Session}`>()
+  .custom<
+    `${TaskId}/${StoreId.Session}` | `${TaskId}/${typeof ARTIFACT_TARGET_KEY}`
+  >()
   .superRefine((val, ctx) => {
     if (typeof val !== "string") {
       ctx.addIssue({
@@ -84,7 +106,7 @@ export const BrowserTargetIdSchema = z
         fatal: true,
         input: val,
         message:
-          "BrowserTargetId must be `${id}/${sessionId}` with both halves non-empty",
+          "BrowserTargetId must be `${id}/${sessionId}` or `${id}/artifact` with both halves non-empty",
       });
       return;
     }
@@ -94,7 +116,11 @@ export const BrowserTargetIdSchema = z
         ctx.addIssue({ ...issue, path: ["id", ...issue.path] });
       }
     }
-    const sessionResult = StoreId.SessionSchema.safeParse(val.slice(slash + 1));
+    const rest = val.slice(slash + 1);
+    if (rest === ARTIFACT_TARGET_KEY) {
+      return;
+    }
+    const sessionResult = StoreId.SessionSchema.safeParse(rest);
     if (!sessionResult.success) {
       for (const issue of sessionResult.error.issues) {
         ctx.addIssue({ ...issue, path: ["sessionId", ...issue.path] });
@@ -148,18 +174,33 @@ type CdpSendArgs<M extends CdpMethod> =
         ? [params?: P]
         : never;
 
+/**
+ * Parse a target id into its kind and parts. Discriminated on `kind` so callers
+ * that only make sense for one guest kind -- the CDP bridge and the agent's
+ * target list, both of which are session-only -- have to say so.
+ */
 export function decodeBrowserTargetId(
   targetId: string,
-): null | { id: TaskId; sessionId: StoreId.Session } {
+):
+  | null
+  | { id: TaskId; kind: "artifact" }
+  | { id: TaskId; kind: "session"; sessionId: StoreId.Session } {
   const result = BrowserTargetIdSchema.safeParse(targetId);
   if (!result.success) {
     return null;
   }
   const slash = result.data.indexOf("/");
-  return {
-    id: result.data.slice(0, slash) as TaskId,
-    sessionId: result.data.slice(slash + 1) as StoreId.Session,
-  };
+  const id = result.data.slice(0, slash) as TaskId;
+  const rest = result.data.slice(slash + 1);
+  if (rest === ARTIFACT_TARGET_KEY) {
+    return { id, kind: "artifact" };
+  }
+  return { id, kind: "session", sessionId: rest as StoreId.Session };
+}
+
+/** The task's single artifact-preview target id (see ARTIFACT_TARGET_KEY). */
+export function encodeArtifactTargetId(id: TaskId): BrowserTargetId {
+  return BrowserTargetIdSchema.parse(`${id}/${ARTIFACT_TARGET_KEY}`);
 }
 
 export function encodeBrowserTargetId(