pi-studio 0.9.6 → 0.9.7

package/CHANGELOG.md

@@ -4,6 +4,15 @@ All notable changes to `pi-studio` are documented here.
 
 ## [Unreleased]
 
+## [0.9.7] — 2026-05-19
+
+### Added
+- Added Focus support for interactive HTML previews, using the existing sandboxed preview iframe in-place so form input and script state survive focus/unfocus.
+
+### Changed
+- `/studio` launched over SSH now skips opening the remote host browser by default, prints a local tunnel hint instead, and keeps local/non-SSH browser auto-open behavior unchanged. Use `/studio --open-remote` to request the previous remote-browser behavior.
+- Moved the HTML preview Focus control next to the preview title to match PDF Focus placement.
+
 ## [0.9.6] — 2026-05-19
 
 ### Changed

package/client/studio-client.js

@@ -192,6 +192,11 @@
       let studioPdfFocusCloseBtn = null;
       let studioPdfFocusLastFocusedEl = null;
       let studioPdfFocusMovedFrameState = null;
+      let studioHtmlFocusOverlayEl = null;
+      let studioHtmlFocusShellEl = null;
+      let studioHtmlFocusFullscreenBtn = null;
+      let studioHtmlFocusLastFocusedEl = null;
+      let studioHtmlFocusRestoreState = null;
       let pendingRequestId = null;
       let pendingKind = null;
       let stickyStudioKind = null;
@@ -3156,6 +3161,12 @@
           && typeof studioPdfFocusDialogEl.contains === "function"
           && studioPdfFocusDialogEl.contains(event.target)
         );
+        const htmlFocusOwnsEvent = Boolean(
+          studioHtmlFocusShellEl
+          && event.target
+          && typeof studioHtmlFocusShellEl.contains === "function"
+          && studioHtmlFocusShellEl.contains(event.target)
+        );
         const quizOwnsEvent = Boolean(
           quizDialogEl
           && event.target
@@ -3175,6 +3186,12 @@
           return;
         }
 
+        if (isStudioHtmlFocusOpen() && plainEscape) {
+          event.preventDefault();
+          closeStudioHtmlFocusViewer();
+          return;
+        }
+
         if (isScratchpadOpen() && plainEscape) {
           event.preventDefault();
           closeScratchpad();
@@ -3193,7 +3210,7 @@
           return;
         }
 
-        if (scratchpadOwnsEvent || reviewNotesOwnsEvent || outlineOwnsEvent || pdfFocusOwnsEvent || quizOwnsEvent) {
+        if (scratchpadOwnsEvent || reviewNotesOwnsEvent || outlineOwnsEvent || pdfFocusOwnsEvent || htmlFocusOwnsEvent || quizOwnsEvent) {
           return;
         }
 
@@ -3854,6 +3871,10 @@
           return;
         }
         if (event.source && record.iframe.contentWindow && event.source !== record.iframe.contentWindow) return;
+        if (record.shell && record.shell.classList && record.shell.classList.contains("is-focused")) {
+          if (record.detail) record.detail.textContent = "HTML preview";
+          return;
+        }
         const rawHeight = Number(data.height);
         if (!Number.isFinite(rawHeight) || rawHeight <= 0) return;
         const measuredHeight = Math.ceil(rawHeight + 2);
@@ -3875,30 +3896,232 @@
 
       window.addEventListener("message", handleHtmlArtifactFrameSizeMessage);
 
+      function isStudioHtmlFocusOpen() {
+        return Boolean(studioHtmlFocusOverlayEl && studioHtmlFocusOverlayEl.hidden === false && studioHtmlFocusShellEl);
+      }
+
+      function ensureStudioHtmlFocusViewer() {
+        if (studioHtmlFocusOverlayEl) return studioHtmlFocusOverlayEl;
+
+        const overlay = document.createElement("div");
+        overlay.className = "studio-pdf-focus-overlay studio-html-focus-overlay";
+        overlay.hidden = true;
+        overlay.setAttribute("aria-hidden", "true");
+        overlay.addEventListener("click", (event) => {
+          if (event.target === overlay) closeStudioHtmlFocusViewer();
+        });
+        document.addEventListener("fullscreenchange", syncStudioHtmlFocusFullscreenButton);
+        document.body.appendChild(overlay);
+        studioHtmlFocusOverlayEl = overlay;
+        syncStudioHtmlFocusFullscreenButton();
+        return overlay;
+      }
+
+      function getStudioHtmlFocusButton(shell) {
+        return shell && typeof shell.querySelector === "function"
+          ? shell.querySelector(".studio-html-artifact-focus-btn")
+          : null;
+      }
+
+      function getStudioHtmlFullscreenButton(shell) {
+        return shell && typeof shell.querySelector === "function"
+          ? shell.querySelector(".studio-html-artifact-fullscreen-btn")
+          : null;
+      }
+
+      function setStudioHtmlFocusButtonMode(button, focused) {
+        if (!button) return;
+        button.replaceChildren(makeStudioUiRefreshIcon(focused ? "focus-exit" : "focus"));
+        button.title = focused
+          ? "Exit HTML preview focus view."
+          : "Open this HTML preview in a larger Studio overlay.";
+        button.setAttribute("aria-label", focused ? "Exit HTML preview focus view" : "Focus HTML preview");
+        button.setAttribute("aria-pressed", focused ? "true" : "false");
+      }
+
+      function syncStudioHtmlFocusFullscreenButton() {
+        const button = studioHtmlFocusFullscreenBtn;
+        if (!button) return;
+        const shell = studioHtmlFocusShellEl;
+        const isFullscreen = Boolean(shell && document.fullscreenElement && document.fullscreenElement === shell);
+        button.replaceChildren(makeStudioUiRefreshIcon(isFullscreen ? "fullscreen-exit" : "fullscreen"));
+        const label = isFullscreen ? "Exit fullscreen" : "Fullscreen";
+        button.title = isFullscreen
+          ? "Exit browser fullscreen and keep the HTML preview focus view open."
+          : "Ask the browser to make this HTML preview fullscreen.";
+        button.setAttribute("aria-label", label);
+        button.setAttribute("aria-pressed", isFullscreen ? "true" : "false");
+      }
+
+      async function toggleStudioHtmlFocusFullscreen() {
+        const shell = studioHtmlFocusShellEl;
+        if (!shell) return;
+        const isFullscreen = Boolean(document.fullscreenElement && document.fullscreenElement === shell);
+        if (isFullscreen) {
+          try {
+            if (typeof document.exitFullscreen === "function") await document.exitFullscreen();
+          } catch (error) {
+            setStatus("Could not exit HTML preview fullscreen: " + (error && error.message ? error.message : String(error || "unknown error")), "warning");
+          } finally {
+            syncStudioHtmlFocusFullscreenButton();
+          }
+          return;
+        }
+        if (typeof shell.requestFullscreen !== "function") {
+          setStatus("Browser fullscreen is not available for this HTML preview.", "warning");
+          return;
+        }
+        try {
+          await shell.requestFullscreen();
+        } catch (error) {
+          setStatus("Could not enter HTML preview fullscreen: " + (error && error.message ? error.message : String(error || "unknown error")), "warning");
+        } finally {
+          syncStudioHtmlFocusFullscreenButton();
+        }
+      }
+
+      function openStudioHtmlFocusViewer(title, shell) {
+        // Keep the existing sandboxed iframe in place. Reparenting srcdoc iframes can
+        // recreate their browsing context and lose form/script state.
+        const focusShell = shell instanceof HTMLElement ? shell : null;
+        if (!focusShell || !focusShell.isConnected) return false;
+        if (isStudioHtmlFocusOpen() && studioHtmlFocusShellEl === focusShell) return true;
+        if (isStudioHtmlFocusOpen()) closeStudioHtmlFocusViewer();
+        ensureStudioHtmlFocusViewer();
+
+        studioHtmlFocusLastFocusedEl = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+        studioHtmlFocusShellEl = focusShell;
+        studioHtmlFocusRestoreState = {
+          role: focusShell.getAttribute("role"),
+          ariaModal: focusShell.getAttribute("aria-modal"),
+          ariaLabel: focusShell.getAttribute("aria-label"),
+        };
+
+        focusShell.classList.add("is-focused");
+        focusShell.setAttribute("role", "dialog");
+        focusShell.setAttribute("aria-modal", "true");
+        focusShell.setAttribute("aria-label", String(title || "HTML preview").trim() || "HTML preview");
+
+        const focusButton = getStudioHtmlFocusButton(focusShell);
+        setStudioHtmlFocusButtonMode(focusButton, true);
+        studioHtmlFocusFullscreenBtn = getStudioHtmlFullscreenButton(focusShell);
+        if (studioHtmlFocusFullscreenBtn) studioHtmlFocusFullscreenBtn.hidden = false;
+
+        if (document.body) document.body.classList.add("studio-html-focus-open", "studio-pdf-focus-open");
+        if (studioHtmlFocusOverlayEl) {
+          studioHtmlFocusOverlayEl.hidden = false;
+          studioHtmlFocusOverlayEl.setAttribute("aria-hidden", "false");
+        }
+        syncStudioHtmlFocusFullscreenButton();
+        closeStudioUiRefreshMenus();
+        closeExportPreviewMenu();
+        window.setTimeout(() => {
+          if (focusButton && typeof focusButton.focus === "function") focusButton.focus();
+        }, 0);
+        return true;
+      }
+
+      function closeStudioHtmlFocusViewer() {
+        if (!isStudioHtmlFocusOpen()) return false;
+        const shell = studioHtmlFocusShellEl;
+        if (document.fullscreenElement && shell && document.fullscreenElement === shell) {
+          try {
+            const exitResult = document.exitFullscreen && document.exitFullscreen();
+            if (exitResult && typeof exitResult.catch === "function") exitResult.catch(() => {});
+          } catch {}
+        }
+        if (studioHtmlFocusOverlayEl) {
+          studioHtmlFocusOverlayEl.hidden = true;
+          studioHtmlFocusOverlayEl.setAttribute("aria-hidden", "true");
+        }
+        if (shell) {
+          shell.classList.remove("is-focused");
+          const restore = studioHtmlFocusRestoreState || {};
+          if (restore.role === null || typeof restore.role === "undefined") shell.removeAttribute("role");
+          else shell.setAttribute("role", restore.role);
+          if (restore.ariaModal === null || typeof restore.ariaModal === "undefined") shell.removeAttribute("aria-modal");
+          else shell.setAttribute("aria-modal", restore.ariaModal);
+          if (restore.ariaLabel === null || typeof restore.ariaLabel === "undefined") shell.removeAttribute("aria-label");
+          else shell.setAttribute("aria-label", restore.ariaLabel);
+          setStudioHtmlFocusButtonMode(getStudioHtmlFocusButton(shell), false);
+        }
+        if (studioHtmlFocusFullscreenBtn) studioHtmlFocusFullscreenBtn.hidden = true;
+        studioHtmlFocusShellEl = null;
+        studioHtmlFocusFullscreenBtn = null;
+        studioHtmlFocusRestoreState = null;
+        if (document.body) document.body.classList.remove("studio-html-focus-open", "studio-pdf-focus-open");
+        const focusTarget = studioHtmlFocusLastFocusedEl;
+        studioHtmlFocusLastFocusedEl = null;
+        if (focusTarget && typeof focusTarget.focus === "function" && document.contains(focusTarget)) {
+          window.setTimeout(() => focusTarget.focus(), 0);
+        }
+        return true;
+      }
+
+      function openStudioHtmlFocusFromButton(buttonEl) {
+        if (!buttonEl) return false;
+        const shell = buttonEl.closest && buttonEl.closest(".studio-html-artifact-shell");
+        if (!shell) return false;
+        if (isStudioHtmlFocusOpen() && studioHtmlFocusShellEl === shell) {
+          return closeStudioHtmlFocusViewer();
+        }
+        const title = String(shell.dataset && shell.dataset.studioHtmlTitle ? shell.dataset.studioHtmlTitle : "").trim()
+          || String(buttonEl.dataset && buttonEl.dataset.studioHtmlTitle ? buttonEl.dataset.studioHtmlTitle : "").trim()
+          || "HTML preview";
+        return openStudioHtmlFocusViewer(title, shell);
+      }
+
+      function handleStudioHtmlFocusButtonClick(event) {
+        const target = event && event.target;
+        const buttonEl = target instanceof Element ? target.closest(".studio-html-artifact-focus-btn") : null;
+        if (!buttonEl) return;
+        event.preventDefault();
+        event.stopPropagation();
+        if (typeof event.stopImmediatePropagation === "function") {
+          event.stopImmediatePropagation();
+        }
+        if (!openStudioHtmlFocusFromButton(buttonEl)) {
+          setStatus("Could not open HTML preview focus view.", "warning");
+        }
+      }
+
       function renderHtmlArtifactPreview(targetEl, html, pane, options) {
         if (!targetEl) return;
         const title = options && options.title ? String(options.title) : "HTML preview";
         const previewId = "html_artifact_" + Date.now().toString(36) + "_" + Math.random().toString(36).slice(2, 10);
         pruneDisconnectedHtmlArtifactFrames();
+        if (isStudioHtmlFocusOpen()) closeStudioHtmlFocusViewer();
         clearPreviewJumpHighlight(targetEl);
         finishPreviewRender(targetEl);
         targetEl.innerHTML = "";
 
         const shell = document.createElement("div");
         shell.className = "studio-html-artifact-shell";
+        if (shell.dataset) shell.dataset.studioHtmlTitle = title;
 
         const toolbar = document.createElement("div");
         toolbar.className = "studio-html-artifact-toolbar";
+        const titleGroup = document.createElement("div");
+        titleGroup.className = "studio-html-artifact-title-group";
+        const focusBtn = document.createElement("button");
+        focusBtn.type = "button";
+        focusBtn.className = "studio-html-artifact-focus-btn";
+        focusBtn.title = "Open this HTML preview in a larger Studio overlay.";
+        focusBtn.setAttribute("aria-label", "Focus HTML preview");
+        if (focusBtn.dataset) focusBtn.dataset.studioHtmlTitle = title;
+        focusBtn.appendChild(makeStudioUiRefreshIcon("focus"));
+        focusBtn.addEventListener("click", handleStudioHtmlFocusButtonClick);
+        titleGroup.appendChild(focusBtn);
         const label = document.createElement("span");
         label.className = "studio-html-artifact-label";
         label.textContent = title;
+        titleGroup.appendChild(label);
         const detail = document.createElement("span");
         detail.className = "studio-html-artifact-detail";
         detail.textContent = "HTML preview";
 
         const tools = document.createElement("span");
         tools.className = "studio-html-artifact-tools";
-        tools.appendChild(detail);
 
         const zoomControls = document.createElement("span");
         zoomControls.className = "studio-html-artifact-zoom-controls";
@@ -3948,10 +4171,24 @@
         zoomControls.appendChild(zoomOutBtn);
         zoomControls.appendChild(zoomResetBtn);
         zoomControls.appendChild(zoomInBtn);
+        const fullscreenBtn = document.createElement("button");
+        fullscreenBtn.type = "button";
+        fullscreenBtn.className = "studio-html-artifact-fullscreen-btn";
+        fullscreenBtn.hidden = true;
+        fullscreenBtn.addEventListener("pointerdown", (event) => { event.stopPropagation(); });
+        fullscreenBtn.addEventListener("mousedown", (event) => { event.stopPropagation(); });
+        fullscreenBtn.addEventListener("click", (event) => {
+          event.preventDefault();
+          event.stopPropagation();
+          toggleStudioHtmlFocusFullscreen();
+        });
+        fullscreenBtn.appendChild(makeStudioUiRefreshIcon("fullscreen"));
         updateZoomUi();
+        tools.appendChild(detail);
         tools.appendChild(zoomControls);
+        tools.appendChild(fullscreenBtn);
 
-        toolbar.appendChild(label);
+        toolbar.appendChild(titleGroup);
         toolbar.appendChild(tools);
         shell.appendChild(toolbar);
 
@@ -15398,6 +15635,13 @@
         handleStudioPdfFocusButtonClick(event);
       }, true);
 
+      document.addEventListener("click", (event) => {
+        const target = event.target;
+        const focusBtn = target instanceof Element ? target.closest(".studio-html-artifact-focus-btn") : null;
+        if (!focusBtn) return;
+        handleStudioHtmlFocusButtonClick(event);
+      }, true);
+
       document.addEventListener("click", (event) => {
         const target = event.target;
         const copyBtn = target instanceof Element ? target.closest(".studio-copy-block-btn") : null;

package/client/studio.css

@@ -1635,7 +1635,8 @@
       background: #fff;
     }
 
-    body.studio-pdf-focus-open {
+    body.studio-pdf-focus-open,
+    body.studio-html-focus-open {
       overflow: hidden;
     }
 
@@ -2115,6 +2116,31 @@
       box-shadow: 0 1px 2px var(--shadow-color);
     }
 
+    .rendered-markdown .studio-html-artifact-shell.is-focused {
+      position: fixed;
+      top: 50%;
+      left: 50%;
+      z-index: 71;
+      width: min(96vw, 1440px);
+      height: min(92vh, 1080px);
+      min-height: 420px;
+      margin: 0;
+      transform: translate(-50%, -50%);
+      border-radius: 14px;
+      box-shadow: 0 24px 70px var(--shadow-color);
+    }
+
+    .rendered-markdown .studio-html-artifact-shell.is-focused:fullscreen {
+      top: 0;
+      left: 0;
+      width: 100vw;
+      height: 100vh;
+      min-height: 100vh;
+      transform: none;
+      border: 0;
+      border-radius: 0;
+    }
+
     .rendered-markdown .studio-html-artifact-toolbar {
       display: flex;
       align-items: center;
@@ -2129,6 +2155,20 @@
       line-height: 1.25;
     }
 
+    .rendered-markdown .studio-html-artifact-shell.is-focused .studio-html-artifact-toolbar {
+      gap: 12px;
+      padding: 9px 12px;
+      border-bottom-color: var(--panel-border);
+    }
+
+    .rendered-markdown .studio-html-artifact-title-group {
+      min-width: 0;
+      flex: 1 1 auto;
+      display: inline-flex;
+      align-items: center;
+      gap: 8px;
+    }
+
     .rendered-markdown .studio-html-artifact-label {
       min-width: 0;
       overflow: hidden;
@@ -2138,6 +2178,48 @@
       font-weight: 600;
     }
 
+    .rendered-markdown .studio-html-artifact-focus-btn,
+    .rendered-markdown .studio-html-artifact-fullscreen-btn {
+      flex: 0 0 auto;
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      width: 26px;
+      min-width: 26px;
+      height: 26px;
+      padding: 0;
+      border: 1px solid transparent;
+      border-radius: 8px;
+      background: transparent;
+      color: var(--studio-info-text, var(--muted));
+    }
+
+    .rendered-markdown .studio-html-artifact-shell.is-focused .studio-html-artifact-focus-btn,
+    .rendered-markdown .studio-html-artifact-shell.is-focused .studio-html-artifact-fullscreen-btn {
+      width: 29px;
+      min-width: 29px;
+      height: 29px;
+    }
+
+    .rendered-markdown .studio-html-artifact-fullscreen-btn[hidden] {
+      display: none !important;
+    }
+
+    .rendered-markdown .studio-html-artifact-focus-btn:not(:disabled):hover,
+    .rendered-markdown .studio-html-artifact-focus-btn:focus-visible,
+    .rendered-markdown .studio-html-artifact-fullscreen-btn:not(:disabled):hover,
+    .rendered-markdown .studio-html-artifact-fullscreen-btn:focus-visible {
+      background: var(--panel);
+      border-color: var(--control-border);
+      color: var(--text);
+    }
+
+    .rendered-markdown .studio-html-artifact-focus-btn .studio-refresh-icon,
+    .rendered-markdown .studio-html-artifact-fullscreen-btn .studio-refresh-icon {
+      width: 14px;
+      height: 14px;
+    }
+
     .rendered-markdown .studio-html-artifact-tools {
       flex: 0 0 auto;
       display: inline-flex;
@@ -2204,6 +2286,11 @@
       background: #fff;
     }
 
+    .rendered-markdown .studio-html-artifact-shell.is-focused .studio-html-artifact-frame {
+      min-height: 0;
+      height: auto !important;
+    }
+
     .rendered-markdown .studio-html-artifact-shell.is-height-capped .studio-html-artifact-toolbar {
       border-bottom-color: var(--control-border);
     }

package/index.ts

@@ -8276,9 +8276,33 @@ function isSshSession(): boolean {
 	);
 }
 
-function buildStudioSshTunnelHint(port: number, studioUrl: string): string | null {
+function parseStudioLaunchOpenFlags(rawArgs: string): { args: string; openRemoteBrowser: boolean; error?: string } {
+	const parsed = tokenizeStudioCommandArgs(rawArgs);
+	if (parsed.error) return { args: rawArgs, openRemoteBrowser: false, error: parsed.error };
+	const remaining: string[] = [];
+	let openRemoteBrowser = false;
+	for (const token of parsed.tokens) {
+		if (token === "--open-remote" || token === "--open-remote-browser") {
+			openRemoteBrowser = true;
+			continue;
+		}
+		remaining.push(token);
+	}
+	return { args: remaining.join(" "), openRemoteBrowser };
+}
+
+function shouldAutoOpenStudioBrowser(options?: { openRemoteBrowser?: boolean }): boolean {
+	return !isSshSession() || Boolean(options?.openRemoteBrowser);
+}
+
+function buildStudioSshTunnelHint(port: number): string | null {
 	if (!isSshSession()) return null;
-	return `SSH detected. Full Studio URL: ${studioUrl}. Forward the remote Studio port with: ssh -L ${port}:127.0.0.1:${port} <remote-host>. Open the full URL locally through the tunnel, preserving its ?token=... parameter. If you choose a different local port, change only the port in the URL; keep the token.`;
+	return [
+		"SSH detected. Studio was not opened in the remote browser.",
+		"To open it locally, run this on your local machine:",
+		`  ssh -L ${port}:127.0.0.1:${port} <remote-host>`,
+		"Then open the Studio URL above in your local browser.",
+	].join("\n");
 }
 
 function resolveRequestedStudioDocumentFromUrl(
@@ -12512,6 +12536,12 @@ export default function (pi: ExtensionAPI) {
 		mode: StudioUiMode,
 		options?: { defaultSource?: "blank" | "last-response"; commandLabel?: string; replaceExistingFull?: boolean },
 	) => {
+		const launchOpenFlags = parseStudioLaunchOpenFlags(trimmed);
+		if (launchOpenFlags.error) {
+			ctx.ui.notify(`${launchOpenFlags.error} Use ${options?.commandLabel ?? "/studio"} --help`, "error");
+			return;
+		}
+		const launchArgs = launchOpenFlags.args;
 		if (mode === "full" && hasConnectedFullStudioView()) {
 			if (options?.replaceExistingFull) {
 				closeStudioClientsByMode("full", 4001, "Full Studio replaced");
@@ -12520,7 +12550,7 @@ export default function (pi: ExtensionAPI) {
 				if (serverState) {
 					const url = buildStudioUrl(serverState.port, serverState.token, "full");
 					ctx.ui.notify(`Studio URL: ${url}`, "info");
-					const sshTunnelHint = buildStudioSshTunnelHint(serverState.port, url);
+					const sshTunnelHint = buildStudioSshTunnelHint(serverState.port);
 					if (sshTunnelHint) ctx.ui.notify(sshTunnelHint, "info");
 				}
 				return;
@@ -12542,23 +12572,30 @@ export default function (pi: ExtensionAPI) {
 			// ignore theme read errors
 		}
 
-		const selected = resolveStudioLaunchDocument(trimmed, ctx, options);
+		const selected = resolveStudioLaunchDocument(launchArgs, ctx, options);
 		if (!selected) return;
 		initialStudioDocument = selected;
 
 		const state = await ensureServer();
 		const url = buildStudioUrl(state.port, state.token, mode, selected);
-		const sshTunnelHint = buildStudioSshTunnelHint(state.port, url);
+		const sshTunnelHint = buildStudioSshTunnelHint(state.port);
 		const openedLabel = mode === "editor-only" ? "pi Studio editor-only view" : "pi Studio";
 
+		const shouldOpenBrowser = shouldAutoOpenStudioBrowser({
+			openRemoteBrowser: launchOpenFlags.openRemoteBrowser,
+		});
 		try {
-			await openUrlInDefaultBrowser(url);
-			if (selected.source === "file") {
-				ctx.ui.notify(`Opened ${openedLabel} with file loaded: ${selected.label}`, "info");
-			} else if (selected.source === "last-response") {
-				ctx.ui.notify(`Opened ${openedLabel} with last model response (${selected.text.length} chars).`, "info");
+			if (!shouldOpenBrowser) {
+				ctx.ui.notify(`${openedLabel} is ready. Browser auto-open was skipped because SSH was detected.`, "info");
 			} else {
-				ctx.ui.notify(`Opened ${openedLabel} with blank editor.`, "info");
+				await openUrlInDefaultBrowser(url);
+				if (selected.source === "file") {
+					ctx.ui.notify(`Opened ${openedLabel} with file loaded: ${selected.label}`, "info");
+				} else if (selected.source === "last-response") {
+					ctx.ui.notify(`Opened ${openedLabel} with last model response (${selected.text.length} chars).`, "info");
+				} else {
+					ctx.ui.notify(`Opened ${openedLabel} with blank editor.`, "info");
+				}
 			}
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
@@ -12595,7 +12632,7 @@ export default function (pi: ExtensionAPI) {
 					`Studio running at ${url} (busy: ${isStudioBusy() ? "yes" : "no"}; full views: ${counts.full}; editor-only views: ${counts.editorOnly})`,
 					"info",
 				);
-				const sshTunnelHint = buildStudioSshTunnelHint(serverState.port, url);
+				const sshTunnelHint = buildStudioSshTunnelHint(serverState.port);
 				if (sshTunnelHint) ctx.ui.notify(sshTunnelHint, "info");
 				return;
 			}
@@ -12607,6 +12644,7 @@ export default function (pi: ExtensionAPI) {
 						+ "  /studio <path>    Open studio with file preloaded\n"
 						+ "  /studio --blank   Open with blank editor\n"
 						+ "  /studio --last    Open with last model response\n"
+						+ "  /studio --open-remote  Over SSH, open the remote browser anyway\n"
 						+ "  /studio --status  Show studio status\n"
 						+ "  /studio --stop    Stop studio server\n"
 						+ "  Note: only one full /studio view is allowed per Pi session.\n"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-studio",
-  "version": "0.9.6",
+  "version": "0.9.7",
   "description": "Two-pane browser workspace for pi with prompt/response editing, annotations, critiques, active quiz, prompt/response history, live previews, and tmux-backed REPL/literate REPL workflows",
   "type": "module",
   "license": "MIT",