pi-studio 0.9.47 → 0.9.49

package/client/studio-client.js

@@ -85,6 +85,7 @@
       const showMeResponseBtn = document.getElementById("showMeResponseBtn");
       const quizBtn = document.getElementById("quizBtn");
       const lensSelect = document.getElementById("lensSelect");
+      const importFileBtn = document.getElementById("importFileBtn");
       const fileInput = document.getElementById("fileInput");
       const resourceDirBtn = document.getElementById("resourceDirBtn");
       const resourceDirLabel = document.getElementById("resourceDirLabel");
@@ -226,7 +227,10 @@
       if (
         !previewResourceHelpers
         || typeof previewResourceHelpers.areStudioPreviewResourceContextsEqual !== "function"
+        || typeof previewResourceHelpers.buildStudioPdfVersionSignature !== "function"
+        || typeof previewResourceHelpers.createStudioPdfVersionObservationState !== "function"
         || typeof previewResourceHelpers.hydrateStudioPreviewLocalImages !== "function"
+        || typeof previewResourceHelpers.observeStudioPdfVersion !== "function"
       ) {
         throw new Error("Studio preview resource helpers failed to load.");
       }
@@ -268,10 +272,19 @@
       let studioPdfFocusFrameEl = null;
       let studioPdfFocusTitleEl = null;
       let studioPdfFocusOpenLinkEl = null;
+      let studioPdfFocusSystemViewerBtn = null;
+      let studioPdfFocusRevealBtn = null;
+      let studioPdfFocusAutoRefreshBtn = null;
       let studioPdfFocusFullscreenBtn = null;
       let studioPdfFocusCloseBtn = null;
       let studioPdfFocusLastFocusedEl = null;
       let studioPdfFocusMovedFrameState = null;
+      let studioPdfFocusResourceQuery = null;
+      let studioPdfFocusSourceCard = null;
+      let studioPdfFocusStandaloneAutoRefreshState = null;
+      const studioPdfCardAutoRefreshStates = new WeakMap();
+      const STUDIO_PDF_AUTO_REFRESH_INTERVAL_MS = 1_000;
+      const STUDIO_PDF_AUTO_REFRESH_STABLE_OBSERVATIONS = 2;
       let studioHtmlFocusOverlayEl = null;
       let studioHtmlFocusShellEl = null;
       let studioHtmlFocusFullscreenBtn = null;
@@ -289,6 +302,16 @@
       let studioImageFocusLastFocusedEl = null;
       let studioImageFocusZoomMode = "fit";
       let studioImageFocusZoom = 1;
+      let studioDecisionOverlayEl = null;
+      let studioDecisionDialogEl = null;
+      let studioDecisionTitleEl = null;
+      let studioDecisionMessageEl = null;
+      let studioDecisionInputEl = null;
+      let studioDecisionCancelBtn = null;
+      let studioDecisionSecondaryBtn = null;
+      let studioDecisionConfirmBtn = null;
+      let studioDecisionState = null;
+      let studioImportDecisionOpen = false;
       let pendingRequestId = null;
       let pendingKind = null;
       let stickyStudioKind = null;
@@ -2595,7 +2618,7 @@
             event.preventDefault();
             event.stopPropagation();
             closeStudioUiRefreshMenus();
-            resetEditorOrigin();
+            void resetEditorOrigin();
           });
           sourceOpenCurrentFileTabBtn = makeStudioUiRefreshElement("button", "source-open-file-tab-btn", "Open current file in new editor tab");
           sourceOpenCurrentFileTabBtn.type = "button";
@@ -3625,6 +3648,207 @@
         });
       }
 
+      function finishStudioDecision(value, restoreFocus) {
+        const state = studioDecisionState;
+        if (!state) return;
+        studioDecisionState = null;
+        if (studioDecisionOverlayEl) studioDecisionOverlayEl.hidden = true;
+        if (document.body) document.body.classList.remove("studio-decision-open");
+        const returnFocusEl = state.returnFocusEl;
+        state.resolve(value);
+        if (restoreFocus !== false && returnFocusEl && typeof returnFocusEl.focus === "function") {
+          window.setTimeout(() => {
+            if (returnFocusEl.isConnected) returnFocusEl.focus({ preventScroll: true });
+          }, 0);
+        }
+      }
+
+      function getStudioDecisionFocusableElements() {
+        return [studioDecisionInputEl, studioDecisionCancelBtn, studioDecisionSecondaryBtn, studioDecisionConfirmBtn]
+          .filter((element) => element && !element.hidden && !element.disabled);
+      }
+
+      function ensureStudioDecisionDialog() {
+        if (studioDecisionOverlayEl) return studioDecisionOverlayEl;
+
+        const overlay = document.createElement("div");
+        overlay.className = "studio-decision-overlay";
+        overlay.hidden = true;
+
+        const dialog = document.createElement("div");
+        dialog.className = "studio-decision-dialog";
+        dialog.setAttribute("role", "alertdialog");
+        dialog.setAttribute("aria-modal", "true");
+        dialog.setAttribute("aria-labelledby", "studioDecisionTitle");
+        dialog.setAttribute("aria-describedby", "studioDecisionMessage");
+
+        const title = document.createElement("h2");
+        title.id = "studioDecisionTitle";
+        title.className = "studio-decision-title";
+        dialog.appendChild(title);
+
+        const message = document.createElement("div");
+        message.id = "studioDecisionMessage";
+        message.className = "studio-decision-message";
+        dialog.appendChild(message);
+
+        const input = document.createElement("input");
+        input.type = "text";
+        input.className = "studio-decision-input";
+        input.hidden = true;
+        input.autocomplete = "off";
+        input.spellcheck = false;
+        input.setAttribute("autocapitalize", "off");
+        input.setAttribute("aria-label", "Value");
+        dialog.appendChild(input);
+
+        const actions = document.createElement("div");
+        actions.className = "studio-decision-actions";
+
+        const cancelBtn = document.createElement("button");
+        cancelBtn.type = "button";
+        cancelBtn.className = "studio-decision-cancel";
+        cancelBtn.textContent = "Cancel";
+        cancelBtn.addEventListener("click", () => finishStudioDecision(null));
+        actions.appendChild(cancelBtn);
+
+        const secondaryBtn = document.createElement("button");
+        secondaryBtn.type = "button";
+        secondaryBtn.className = "studio-decision-secondary";
+        secondaryBtn.hidden = true;
+        secondaryBtn.addEventListener("click", () => {
+          const handler = studioDecisionState && studioDecisionState.onSecondary;
+          if (typeof handler !== "function") return;
+          try {
+            const result = handler();
+            if (result && typeof result.catch === "function") {
+              result.catch((error) => {
+                setStatus("Action failed: " + (error && error.message ? error.message : String(error || "unknown error")), "warning");
+              });
+            }
+          } catch (error) {
+            setStatus("Action failed: " + (error && error.message ? error.message : String(error || "unknown error")), "warning");
+          }
+        });
+        actions.appendChild(secondaryBtn);
+
+        const confirmBtn = document.createElement("button");
+        confirmBtn.type = "button";
+        confirmBtn.className = "studio-decision-confirm";
+        confirmBtn.textContent = "Confirm";
+        confirmBtn.addEventListener("click", () => {
+          if (!studioDecisionState) return;
+          finishStudioDecision(studioDecisionState.mode === "prompt" ? input.value : true);
+        });
+        actions.appendChild(confirmBtn);
+
+        dialog.appendChild(actions);
+        overlay.appendChild(dialog);
+        document.body.appendChild(overlay);
+
+        overlay.addEventListener("click", (event) => {
+          if (event.target === overlay) finishStudioDecision(null);
+        });
+        dialog.addEventListener("keydown", (event) => {
+          event.stopPropagation();
+          if (event.key === "Escape") {
+            event.preventDefault();
+            finishStudioDecision(null);
+            return;
+          }
+          if (event.key === "Enter" && event.target === input) {
+            event.preventDefault();
+            confirmBtn.click();
+            return;
+          }
+          if (event.key !== "Tab") return;
+          const focusable = getStudioDecisionFocusableElements();
+          if (focusable.length < 2) return;
+          const currentIndex = focusable.indexOf(document.activeElement);
+          const nextIndex = event.shiftKey
+            ? (currentIndex <= 0 ? focusable.length - 1 : currentIndex - 1)
+            : (currentIndex < 0 || currentIndex === focusable.length - 1 ? 0 : currentIndex + 1);
+          event.preventDefault();
+          focusable[nextIndex].focus();
+        });
+
+        studioDecisionOverlayEl = overlay;
+        studioDecisionDialogEl = dialog;
+        studioDecisionTitleEl = title;
+        studioDecisionMessageEl = message;
+        studioDecisionInputEl = input;
+        studioDecisionCancelBtn = cancelBtn;
+        studioDecisionSecondaryBtn = secondaryBtn;
+        studioDecisionConfirmBtn = confirmBtn;
+        return overlay;
+      }
+
+      function openStudioDecision(options) {
+        const settings = options && typeof options === "object" ? options : {};
+        const mode = settings.mode === "prompt" ? "prompt" : "confirm";
+        ensureStudioDecisionDialog();
+        if (studioDecisionState) finishStudioDecision(null, false);
+        const returnFocusEl = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+
+        const secondaryLabel = String(settings.secondaryLabel || "").trim();
+        studioDecisionTitleEl.textContent = String(settings.title || (mode === "prompt" ? "Enter a value" : "Confirm action"));
+        studioDecisionMessageEl.textContent = String(settings.message || "");
+        studioDecisionInputEl.hidden = mode !== "prompt";
+        studioDecisionInputEl.value = mode === "prompt" ? String(settings.defaultValue || "") : "";
+        studioDecisionInputEl.placeholder = mode === "prompt" ? String(settings.placeholder || "") : "";
+        studioDecisionInputEl.setAttribute("aria-label", String(settings.inputLabel || "Value"));
+        studioDecisionCancelBtn.textContent = String(settings.cancelLabel || "Cancel");
+        studioDecisionSecondaryBtn.hidden = !secondaryLabel;
+        studioDecisionSecondaryBtn.disabled = settings.secondaryDisabled === true;
+        studioDecisionSecondaryBtn.textContent = secondaryLabel;
+        studioDecisionConfirmBtn.textContent = String(settings.confirmLabel || (mode === "prompt" ? "Continue" : "Confirm"));
+        studioDecisionConfirmBtn.classList.toggle("is-destructive", settings.destructive === true);
+        studioDecisionDialogEl.classList.toggle("is-destructive", settings.destructive === true);
+        studioDecisionOverlayEl.hidden = false;
+        if (document.body) document.body.classList.add("studio-decision-open");
+
+        return new Promise((resolve) => {
+          const decisionState = {
+            mode,
+            resolve,
+            returnFocusEl,
+            onSecondary: typeof settings.onSecondary === "function" ? settings.onSecondary : null,
+          };
+          studioDecisionState = decisionState;
+          const schedule = typeof window.requestAnimationFrame === "function"
+            ? window.requestAnimationFrame.bind(window)
+            : (callback) => window.setTimeout(callback, 16);
+          schedule(() => {
+            if (studioDecisionState !== decisionState) return;
+            if (mode === "prompt") {
+              studioDecisionInputEl.focus();
+              studioDecisionInputEl.select();
+            } else {
+              studioDecisionCancelBtn.focus();
+            }
+          });
+        });
+      }
+
+      async function requestStudioConfirmation(message, options) {
+        const value = await openStudioDecision({
+          ...(options && typeof options === "object" ? options : {}),
+          mode: "confirm",
+          message: String(message || ""),
+        });
+        return value === true;
+      }
+
+      async function requestStudioTextInput(message, defaultValue, options) {
+        const value = await openStudioDecision({
+          ...(options && typeof options === "object" ? options : {}),
+          mode: "prompt",
+          message: String(message || ""),
+          defaultValue: String(defaultValue || ""),
+        });
+        return typeof value === "string" ? value : null;
+      }
+
       renderStatus();
 
       window.addEventListener("focus", () => {
@@ -3714,14 +3938,17 @@
         }
       }
 
-      function resetEditorOrigin() {
+      async function resetEditorOrigin() {
         const descriptor = getCurrentStudioDocumentDescriptor();
         const message = descriptor.fileBacked
           ? ("Reset editor origin and detach the current text from\n\n" + descriptor.label + "\n\ninto a new draft? The file on disk will not be changed, and the current scratchpad/review notes will carry into the new draft.")
           : ("Reset editor origin and start a new independent draft? The current editor text, scratchpad, and review notes will carry into the new draft.");
-        if (!window.confirm(message)) {
-          return;
-        }
+        const confirmed = await requestStudioConfirmation(message, {
+          title: descriptor.fileBacked ? "Detach editor from file?" : "Reset editor origin?",
+          confirmLabel: descriptor.fileBacked ? "Detach" : "Reset origin",
+          destructive: true,
+        });
+        if (!confirmed) return;
         const nextLabel = String(sourceTextEl.value || "").trim() ? "draft" : "blank";
         setSourceState({
           source: "blank",
@@ -4271,6 +4498,15 @@
 
         if (handleStudioImageFocusShortcut(event)) return;
 
+        const otherModalOwnsEvent = scratchpadOwnsEvent
+          || reviewNotesOwnsEvent
+          || outlineOwnsEvent
+          || shortcutsOwnsEvent
+          || htmlFocusOwnsEvent
+          || imageFocusOwnsEvent
+          || quizOwnsEvent;
+        if (!otherModalOwnsEvent && handleStudioPdfRefreshShortcut(event)) return;
+
         if (isScratchpadOpen() && plainEscape) {
           event.preventDefault();
           closeScratchpad();
@@ -6633,7 +6869,7 @@
       }
 
       function parseStudioPdfBlockOptions(body) {
-        const options = { path: "", title: "", caption: "", page: "", height: "" };
+        const options = { path: "", title: "", caption: "", page: "", height: "", watch: "" };
         String(body || "").split(/\r?\n/).forEach((line) => {
           const raw = String(line || "").trim();
           if (!raw || raw.startsWith("#")) return;
@@ -6646,6 +6882,7 @@
             else if (key === "caption") options.caption = value;
             else if (key === "page") options.page = value;
             else if (key === "height") options.height = value;
+            else if (key === "watch" || key === "auto-refresh" || key === "autorefresh") options.watch = value;
             return;
           }
           if (!options.path) options.path = stripMatchingQuotes(raw);
@@ -6677,6 +6914,10 @@
         return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
       }
 
+      function normalizeStudioPdfAutoRefresh(value) {
+        return /^(?:1|true|yes|on|watch)$/i.test(String(value || "").trim());
+      }
+
       function isStudioPdfFocusOpen() {
         return Boolean(studioPdfFocusOverlayEl && studioPdfFocusOverlayEl.hidden === false);
       }
@@ -6723,18 +6964,49 @@
         openLink.className = "studio-pdf-focus-link";
         openLink.target = "_blank";
         openLink.rel = "noopener noreferrer";
-        openLink.textContent = "Open PDF";
+        openLink.textContent = "Browser tab";
+        openLink.title = "Open this PDF in a browser tab.";
         actions.appendChild(openLink);
 
+        const systemViewerBtn = document.createElement("button");
+        systemViewerBtn.type = "button";
+        systemViewerBtn.className = "studio-pdf-focus-btn studio-pdf-focus-system-viewer";
+        systemViewerBtn.textContent = "System viewer";
+        systemViewerBtn.title = "Open the local PDF in the operating system's default PDF viewer.";
+        systemViewerBtn.addEventListener("click", () => {
+          void runStudioPdfLocalAction("system-viewer", studioPdfFocusResourceQuery);
+        });
+        actions.appendChild(systemViewerBtn);
+
+        const revealBtn = document.createElement("button");
+        revealBtn.type = "button";
+        revealBtn.className = "studio-pdf-focus-btn studio-pdf-focus-reveal";
+        revealBtn.textContent = "Show in folder";
+        revealBtn.title = "Reveal the local PDF in Finder or the system file manager.";
+        revealBtn.addEventListener("click", () => {
+          void runStudioPdfLocalAction("reveal", studioPdfFocusResourceQuery);
+        });
+        actions.appendChild(revealBtn);
+
         const refreshBtn = document.createElement("button");
         refreshBtn.type = "button";
         refreshBtn.className = "studio-pdf-focus-btn studio-pdf-focus-refresh";
         refreshBtn.textContent = "Refresh";
-        refreshBtn.title = "Reload this PDF preview from disk.";
+        refreshBtn.title = "Reload this PDF preview from disk. Shortcut: Cmd/Ctrl+Alt+R.";
         refreshBtn.setAttribute("aria-label", "Refresh PDF preview from disk");
         refreshBtn.addEventListener("click", () => refreshStudioPdfFocusViewer());
         actions.appendChild(refreshBtn);
 
+        const autoRefreshBtn = document.createElement("button");
+        autoRefreshBtn.type = "button";
+        autoRefreshBtn.className = "studio-pdf-focus-btn studio-pdf-focus-auto-refresh";
+        autoRefreshBtn.textContent = "Auto-refresh";
+        autoRefreshBtn.title = "Watch this local PDF and reload it after a changed file is stable on disk.";
+        autoRefreshBtn.setAttribute("aria-label", "Enable PDF auto-refresh");
+        autoRefreshBtn.setAttribute("aria-pressed", "false");
+        autoRefreshBtn.addEventListener("click", () => toggleStudioPdfFocusAutoRefresh());
+        actions.appendChild(autoRefreshBtn);
+
         const fullscreenBtn = document.createElement("button");
         fullscreenBtn.type = "button";
         fullscreenBtn.className = "studio-pdf-focus-btn studio-pdf-focus-fullscreen";
@@ -6789,16 +7061,23 @@
         studioPdfFocusFrameEl = frame;
         studioPdfFocusTitleEl = titleEl;
         studioPdfFocusOpenLinkEl = openLink;
+        studioPdfFocusSystemViewerBtn = systemViewerBtn;
+        studioPdfFocusRevealBtn = revealBtn;
+        studioPdfFocusAutoRefreshBtn = autoRefreshBtn;
         studioPdfFocusFullscreenBtn = fullscreenBtn;
         studioPdfFocusCloseBtn = closeBtn;
         syncStudioPdfFocusFullscreenButton();
+        syncStudioPdfFocusResourceActions();
         return overlay;
       }
 
-      function openStudioPdfFocusViewer(viewerUrl, title, sourceFrame) {
+      function openStudioPdfFocusViewer(viewerUrl, title, sourceFrame, resourceQuery, sourceCard) {
         const src = String(viewerUrl || "").trim();
         if (!src) return;
         ensureStudioPdfFocusViewer();
+        studioPdfFocusResourceQuery = normalizeStudioPdfResourceQuery(resourceQuery);
+        setStudioPdfFocusAutoRefreshSource(sourceCard, studioPdfFocusResourceQuery);
+        syncStudioPdfFocusResourceActions();
         studioPdfFocusLastFocusedEl = document.activeElement instanceof HTMLElement ? document.activeElement : null;
         if (studioPdfFocusTitleEl) studioPdfFocusTitleEl.textContent = String(title || "PDF preview").trim() || "PDF preview";
         if (studioPdfFocusOpenLinkEl) studioPdfFocusOpenLinkEl.href = src;
@@ -6827,6 +7106,9 @@
         restoreStudioPdfFocusMovedFrame();
         if (studioPdfFocusFrameEl) studioPdfFocusFrameEl.src = "about:blank";
         if (document.body) document.body.classList.remove("studio-pdf-focus-open");
+        clearStudioPdfFocusAutoRefreshSource();
+        studioPdfFocusResourceQuery = null;
+        syncStudioPdfFocusResourceActions();
         syncStudioPdfFocusFullscreenButton();
         const focusTarget = studioPdfFocusLastFocusedEl;
         studioPdfFocusLastFocusedEl = null;
@@ -6836,24 +7118,274 @@
         return true;
       }
 
-      function buildStudioPdfResourceUrl(options, useEditorResourceContext) {
-        const token = getToken();
-        if (!token) return "";
+      function buildStudioPdfResourceQuery(options, useEditorResourceContext) {
         const pdfPath = String(options && options.path ? options.path : "").trim();
-        if (!pdfPath) return "";
+        if (!pdfPath) return null;
         const explicitSourcePath = options && typeof options.sourcePath === "string" ? options.sourcePath.trim() : "";
         const explicitResourceDir = options && typeof options.resourceDir === "string" ? normalizeStudioResourceDirValue(options.resourceDir) : "";
         const effectivePath = getEffectiveSavePath();
         const sourcePath = explicitSourcePath || (useEditorResourceContext ? (effectivePath || sourceState.path || "") : "");
         const resourceDir = explicitResourceDir || getCurrentResourceDirValue();
-        const params = new URLSearchParams({ token, path: pdfPath });
-        if (sourcePath) {
-          params.set("sourcePath", sourcePath);
+        const query = { path: pdfPath };
+        if (sourcePath) query.sourcePath = sourcePath;
+        if (resourceDir) query.resourceDir = resourceDir;
+        return query;
+      }
+
+      function buildStudioPdfResourceUrl(options, useEditorResourceContext) {
+        const token = getToken();
+        const query = buildStudioPdfResourceQuery(options, useEditorResourceContext);
+        if (!token || !query) return "";
+        return "/pdf-resource?" + new URLSearchParams({ token, ...query }).toString();
+      }
+
+      function normalizeStudioPdfResourceQuery(value) {
+        if (!value || typeof value !== "object") return null;
+        const path = typeof value.path === "string" ? value.path.trim() : "";
+        if (!path) return null;
+        const query = { path };
+        if (typeof value.sourcePath === "string" && value.sourcePath.trim()) query.sourcePath = value.sourcePath.trim();
+        if (typeof value.resourceDir === "string" && value.resourceDir.trim()) query.resourceDir = value.resourceDir.trim();
+        return query;
+      }
+
+      function syncStudioPdfAutoRefreshButton(button, enabled, available) {
+        if (!button) return;
+        const active = Boolean(enabled && available);
+        button.disabled = !available;
+        button.setAttribute("aria-pressed", active ? "true" : "false");
+        button.setAttribute("aria-label", active ? "Disable PDF auto-refresh" : "Enable PDF auto-refresh");
+        button.textContent = "Auto-refresh";
+        button.title = active
+          ? "Auto-refresh is on. Studio checks this PDF while the tab is visible and reloads it after a changed file is stable on disk."
+          : "Watch this local PDF and reload it after a changed file is stable on disk.";
+      }
+
+      function createStudioPdfAutoRefreshState(resourceQuery, hooks) {
+        return {
+          resourceQuery: normalizeStudioPdfResourceQuery(resourceQuery),
+          enabled: false,
+          timer: null,
+          inFlight: false,
+          generation: 0,
+          observation: previewResourceHelpers.createStudioPdfVersionObservationState(),
+          isAlive: hooks && typeof hooks.isAlive === "function" ? hooks.isAlive : () => false,
+          refresh: hooks && typeof hooks.refresh === "function" ? hooks.refresh : () => false,
+          sync: hooks && typeof hooks.sync === "function" ? hooks.sync : () => {},
+        };
+      }
+
+      function resetStudioPdfAutoRefreshObservation(state) {
+        if (!state) return;
+        state.observation = previewResourceHelpers.createStudioPdfVersionObservationState();
+      }
+
+      function scheduleStudioPdfAutoRefreshPoll(state, delayMs) {
+        if (!state || !state.enabled) return;
+        if (state.timer) window.clearTimeout(state.timer);
+        state.timer = window.setTimeout(() => {
+          state.timer = null;
+          void pollStudioPdfAutoRefreshState(state);
+        }, Math.max(0, Number(delayMs) || 0));
+      }
+
+      function stopStudioPdfAutoRefreshState(state) {
+        if (!state) return;
+        state.enabled = false;
+        state.inFlight = false;
+        state.generation += 1;
+        if (state.timer) window.clearTimeout(state.timer);
+        state.timer = null;
+        resetStudioPdfAutoRefreshObservation(state);
+        state.sync();
+      }
+
+      function setStudioPdfAutoRefreshEnabled(state, enabled, options) {
+        if (!state) return false;
+        const nextEnabled = Boolean(enabled && state.resourceQuery);
+        if (state.enabled === nextEnabled) {
+          state.sync();
+          return nextEnabled;
+        }
+        if (state.timer) window.clearTimeout(state.timer);
+        state.timer = null;
+        state.enabled = nextEnabled;
+        state.inFlight = false;
+        state.generation += 1;
+        resetStudioPdfAutoRefreshObservation(state);
+        state.sync();
+        if (nextEnabled) {
+          if (!options || !options.silent) state.refresh();
+          scheduleStudioPdfAutoRefreshPoll(state, 0);
+        }
+        if (!options || !options.silent) {
+          setStatus(nextEnabled ? "PDF auto-refresh on." : "PDF auto-refresh off.", "success");
+        }
+        return nextEnabled;
+      }
+
+      async function fetchStudioPdfVersionSignature(resourceQuery) {
+        const url = buildStudioPdfResourceUrl(resourceQuery, false);
+        if (!url) throw new Error("Could not resolve this PDF for auto-refresh.");
+        const response = await fetchWithTimeout(url, {
+          method: "HEAD",
+          cache: "no-store",
+        }, 4_000, "PDF auto-refresh check");
+        if (!response.ok) throw new Error("PDF auto-refresh check failed with HTTP " + response.status + ".");
+        return previewResourceHelpers.buildStudioPdfVersionSignature(response.headers);
+      }
+
+      async function pollStudioPdfAutoRefreshState(state) {
+        if (!state || !state.enabled || state.inFlight) return;
+        if (!state.isAlive()) {
+          stopStudioPdfAutoRefreshState(state);
+          return;
+        }
+        if (document.hidden || document.visibilityState === "hidden") {
+          scheduleStudioPdfAutoRefreshPoll(state, STUDIO_PDF_AUTO_REFRESH_INTERVAL_MS);
+          return;
         }
-        if (resourceDir) {
-          params.set("resourceDir", resourceDir);
+        const generation = state.generation;
+        state.inFlight = true;
+        try {
+          const signature = await fetchStudioPdfVersionSignature(state.resourceQuery);
+          if (!state.enabled || state.generation !== generation) return;
+          if (document.hidden || document.visibilityState === "hidden") return;
+          if (!state.isAlive()) {
+            stopStudioPdfAutoRefreshState(state);
+            return;
+          }
+          const observed = previewResourceHelpers.observeStudioPdfVersion(
+            state.observation,
+            signature,
+            STUDIO_PDF_AUTO_REFRESH_STABLE_OBSERVATIONS,
+          );
+          state.observation = observed.state;
+          if (observed.changed) state.refresh();
+        } catch {
+          // LaTeX tools may briefly replace or lock the output PDF. Retry quietly.
+        } finally {
+          if (state.generation !== generation) return;
+          state.inFlight = false;
+          if (state.enabled) scheduleStudioPdfAutoRefreshPoll(state, STUDIO_PDF_AUTO_REFRESH_INTERVAL_MS);
         }
-        return "/pdf-resource?" + params.toString();
+      }
+
+      function syncStudioPdfCardAutoRefreshButton(card) {
+        if (!card) return;
+        const state = studioPdfCardAutoRefreshStates.get(card) || null;
+        const button = typeof card.querySelector === "function" ? card.querySelector(".studio-pdf-card-auto-refresh") : null;
+        syncStudioPdfAutoRefreshButton(button, state && state.enabled, Boolean(state && state.resourceQuery));
+      }
+
+      function ensureStudioPdfCardAutoRefreshState(card, resourceQuery) {
+        if (!card) return null;
+        let state = studioPdfCardAutoRefreshStates.get(card) || null;
+        if (state) return state;
+        state = createStudioPdfAutoRefreshState(resourceQuery, {
+          isAlive: () => Boolean(card.isConnected || (isStudioPdfFocusOpen() && studioPdfFocusSourceCard === card)),
+          refresh: () => {
+            if (isStudioPdfFocusOpen() && studioPdfFocusSourceCard === card) {
+              return refreshStudioPdfFocusViewer({ automatic: true });
+            }
+            return refreshStudioPdfCard(card, { automatic: true });
+          },
+          sync: () => {
+            syncStudioPdfCardAutoRefreshButton(card);
+            if (studioPdfFocusSourceCard === card) syncStudioPdfFocusAutoRefreshButton();
+          },
+        });
+        studioPdfCardAutoRefreshStates.set(card, state);
+        syncStudioPdfCardAutoRefreshButton(card);
+        return state;
+      }
+
+      function setStudioPdfCardAutoRefresh(card, enabled, options) {
+        const state = studioPdfCardAutoRefreshStates.get(card) || null;
+        return setStudioPdfAutoRefreshEnabled(state, enabled, options);
+      }
+
+      function getStudioPdfFocusAutoRefreshState() {
+        if (studioPdfFocusSourceCard) return studioPdfCardAutoRefreshStates.get(studioPdfFocusSourceCard) || null;
+        return studioPdfFocusStandaloneAutoRefreshState;
+      }
+
+      function syncStudioPdfFocusAutoRefreshButton() {
+        const state = getStudioPdfFocusAutoRefreshState();
+        syncStudioPdfAutoRefreshButton(
+          studioPdfFocusAutoRefreshBtn,
+          state && state.enabled,
+          Boolean(state && state.resourceQuery),
+        );
+      }
+
+      function clearStudioPdfFocusAutoRefreshSource() {
+        if (studioPdfFocusStandaloneAutoRefreshState) stopStudioPdfAutoRefreshState(studioPdfFocusStandaloneAutoRefreshState);
+        studioPdfFocusStandaloneAutoRefreshState = null;
+        studioPdfFocusSourceCard = null;
+        syncStudioPdfFocusAutoRefreshButton();
+      }
+
+      function setStudioPdfFocusAutoRefreshSource(sourceCard, resourceQuery) {
+        clearStudioPdfFocusAutoRefreshSource();
+        const card = sourceCard instanceof Element ? sourceCard : null;
+        if (card) {
+          studioPdfFocusSourceCard = card;
+          ensureStudioPdfCardAutoRefreshState(card, resourceQuery);
+          syncStudioPdfFocusAutoRefreshButton();
+          return;
+        }
+        const query = normalizeStudioPdfResourceQuery(resourceQuery);
+        if (!query) {
+          syncStudioPdfFocusAutoRefreshButton();
+          return;
+        }
+        studioPdfFocusStandaloneAutoRefreshState = createStudioPdfAutoRefreshState(query, {
+          isAlive: () => Boolean(isStudioPdfFocusOpen() && !studioPdfFocusSourceCard),
+          refresh: () => refreshStudioPdfFocusViewer({ automatic: true }),
+          sync: () => syncStudioPdfFocusAutoRefreshButton(),
+        });
+        syncStudioPdfFocusAutoRefreshButton();
+      }
+
+      function toggleStudioPdfFocusAutoRefresh() {
+        const state = getStudioPdfFocusAutoRefreshState();
+        if (!state) {
+          setStatus("Could not resolve this PDF for auto-refresh.", "warning");
+          return false;
+        }
+        return setStudioPdfAutoRefreshEnabled(state, !state.enabled);
+      }
+
+      async function runStudioPdfLocalAction(action, resourceQuery) {
+        const query = normalizeStudioPdfResourceQuery(resourceQuery);
+        if (!query) {
+          setStatus("Could not resolve this PDF's local path.", "warning");
+          return false;
+        }
+        const openInSystemViewer = action === "system-viewer";
+        const endpoint = openInSystemViewer ? "/open-local-resource" : "/reveal-local-resource";
+        try {
+          const payload = await fetchStudioJson(endpoint, {
+            method: "POST",
+            body: JSON.stringify(query),
+          });
+          setStatus(payload && payload.message
+            ? payload.message
+            : (openInSystemViewer ? "Opened PDF in the system viewer." : "Revealed PDF in the file manager."), "success");
+          return true;
+        } catch (error) {
+          setStatus((error && error.message)
+            ? error.message
+            : (openInSystemViewer ? "Could not open PDF in the system viewer." : "Could not reveal PDF in the file manager."), "warning");
+          return false;
+        }
+      }
+
+      function syncStudioPdfFocusResourceActions() {
+        const available = Boolean(normalizeStudioPdfResourceQuery(studioPdfFocusResourceQuery));
+        if (studioPdfFocusSystemViewerBtn) studioPdfFocusSystemViewerBtn.disabled = !available;
+        if (studioPdfFocusRevealBtn) studioPdfFocusRevealBtn.disabled = !available;
       }
 
       function buildRefreshedStudioPdfViewerUrl(value) {
@@ -6886,7 +7418,7 @@
         if (focusBtn && focusBtn.dataset) focusBtn.dataset.studioPdfViewerUrl = nextUrl;
       }
 
-      function refreshStudioPdfCard(card) {
+      function refreshStudioPdfCard(card, options) {
         if (!card) return false;
         const frame = typeof card.querySelector === "function" ? card.querySelector("iframe.studio-pdf-frame") : null;
         const currentUrl = String(card.dataset && card.dataset.studioPdfViewerUrl ? card.dataset.studioPdfViewerUrl : "").trim()
@@ -6894,7 +7426,14 @@
         const nextUrl = buildRefreshedStudioPdfViewerUrl(currentUrl);
         if (!nextUrl) return false;
         syncStudioPdfCardViewerUrl(card, nextUrl);
-        setStatus("Refreshed PDF preview from disk.", "success");
+        if (!options || !options.automatic) {
+          resetStudioPdfAutoRefreshObservation(studioPdfCardAutoRefreshStates.get(card) || null);
+        }
+        if (!options || !options.silent) {
+          setStatus(options && options.automatic
+            ? "PDF changed on disk; refreshed preview."
+            : "Refreshed PDF preview from disk.", "success");
+        }
         return true;
       }
 
@@ -6905,7 +7444,7 @@
         return studioPdfFocusFrameEl;
       }
 
-      function refreshStudioPdfFocusViewer() {
+      function refreshStudioPdfFocusViewer(options) {
         const frame = getStudioPdfFocusActiveFrame();
         const currentUrl = String(frame && frame.src ? frame.src : "").trim()
           || String(studioPdfFocusOpenLinkEl && studioPdfFocusOpenLinkEl.href ? studioPdfFocusOpenLinkEl.href : "").trim();
@@ -6916,7 +7455,58 @@
         }
         if (frame) frame.src = nextUrl;
         if (studioPdfFocusOpenLinkEl) studioPdfFocusOpenLinkEl.href = nextUrl;
-        setStatus("Refreshed PDF preview from disk.", "success");
+        if (studioPdfFocusSourceCard) syncStudioPdfCardViewerUrl(studioPdfFocusSourceCard, nextUrl);
+        if (!options || !options.automatic) {
+          resetStudioPdfAutoRefreshObservation(getStudioPdfFocusAutoRefreshState());
+        }
+        if (!options || !options.silent) {
+          setStatus(options && options.automatic
+            ? "PDF changed on disk; refreshed preview."
+            : "Refreshed PDF preview from disk.", "success");
+        }
+        return true;
+      }
+
+      function getVisibleStudioPdfCards() {
+        return Array.from(document.querySelectorAll(".studio-pdf-card")).filter((card) => {
+          if (!card || !card.isConnected || card.hidden) return false;
+          if (typeof card.getClientRects === "function" && card.getClientRects().length === 0) return false;
+          try {
+            const style = window.getComputedStyle(card);
+            return style.display !== "none" && style.visibility !== "hidden";
+          } catch {
+            return true;
+          }
+        });
+      }
+
+      function refreshVisibleStudioPdfPreviews() {
+        if (isStudioPdfFocusOpen()) return refreshStudioPdfFocusViewer();
+        const cards = getVisibleStudioPdfCards();
+        let refreshed = 0;
+        cards.forEach((card) => {
+          if (refreshStudioPdfCard(card, { silent: true })) refreshed += 1;
+        });
+        if (refreshed > 0) {
+          setStatus(refreshed === 1
+            ? "Refreshed PDF preview from disk."
+            : ("Refreshed " + refreshed + " PDF previews from disk."), "success");
+          return true;
+        }
+        return false;
+      }
+
+      function handleStudioPdfRefreshShortcut(event) {
+        if (!event) return false;
+        const key = typeof event.key === "string" ? event.key.toLowerCase() : "";
+        const code = typeof event.code === "string" ? event.code : "";
+        const matches = (key === "r" || code === "KeyR")
+          && (event.metaKey || event.ctrlKey)
+          && event.altKey
+          && !event.shiftKey;
+        if (!matches) return false;
+        if (!refreshVisibleStudioPdfPreviews()) return false;
+        event.preventDefault();
         return true;
       }
 
@@ -6989,8 +7579,15 @@
           || String(card && card.dataset ? (card.dataset.studioPdfTitle || "") : "").trim()
           || "PDF preview";
         const sourceFrame = card && typeof card.querySelector === "function" ? card.querySelector("iframe.studio-pdf-frame") : null;
+        const resourceQuery = card && card.dataset
+          ? normalizeStudioPdfResourceQuery({
+              path: card.dataset.studioPdfPath || "",
+              sourcePath: card.dataset.studioPdfSourcePath || "",
+              resourceDir: card.dataset.studioPdfResourceDir || "",
+            })
+          : null;
         if (!viewerUrl) return false;
-        openStudioPdfFocusViewer(viewerUrl, title, sourceFrame);
+        openStudioPdfFocusViewer(viewerUrl, title, sourceFrame, resourceQuery, card);
         return true;
       }
 
@@ -7403,6 +8000,8 @@
         const caption = String(options.caption || "").trim();
         const height = normalizeStudioPdfHeight(options.height);
         const page = normalizeStudioPdfPage(options.page);
+        const autoRefreshRequested = normalizeStudioPdfAutoRefresh(options.watch);
+        const resourceQuery = buildStudioPdfResourceQuery(options, useEditorResourceContext);
         const resourceUrl = buildStudioPdfResourceUrl(options, useEditorResourceContext);
         const viewerUrl = resourceUrl && page ? resourceUrl + "#page=" + encodeURIComponent(String(page)) : resourceUrl;
 
@@ -7411,6 +8010,9 @@
         if (card.dataset) {
           card.dataset.studioPdfViewerUrl = viewerUrl || "";
           card.dataset.studioPdfTitle = title;
+          card.dataset.studioPdfPath = resourceQuery && resourceQuery.path ? resourceQuery.path : "";
+          card.dataset.studioPdfSourcePath = resourceQuery && resourceQuery.sourcePath ? resourceQuery.sourcePath : "";
+          card.dataset.studioPdfResourceDir = resourceQuery && resourceQuery.resourceDir ? resourceQuery.resourceDir : "";
         }
 
         const header = document.createElement("figcaption");
@@ -7447,14 +8049,39 @@
           openLink.href = viewerUrl;
           openLink.target = "_blank";
           openLink.rel = "noopener noreferrer";
-          openLink.textContent = "Open PDF";
+          openLink.textContent = "Browser tab";
+          openLink.title = "Open this PDF in a browser tab.";
           actions.appendChild(openLink);
 
+          const systemViewerBtn = document.createElement("button");
+          systemViewerBtn.type = "button";
+          systemViewerBtn.className = "studio-pdf-card-action studio-pdf-card-system-viewer";
+          systemViewerBtn.textContent = "System viewer";
+          systemViewerBtn.title = "Open the local PDF in the operating system's default PDF viewer.";
+          systemViewerBtn.addEventListener("click", (event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            void runStudioPdfLocalAction("system-viewer", resourceQuery);
+          });
+          actions.appendChild(systemViewerBtn);
+
+          const revealBtn = document.createElement("button");
+          revealBtn.type = "button";
+          revealBtn.className = "studio-pdf-card-action studio-pdf-card-reveal";
+          revealBtn.textContent = "Show in folder";
+          revealBtn.title = "Reveal the local PDF in Finder or the system file manager.";
+          revealBtn.addEventListener("click", (event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            void runStudioPdfLocalAction("reveal", resourceQuery);
+          });
+          actions.appendChild(revealBtn);
+
           const refreshBtn = document.createElement("button");
           refreshBtn.type = "button";
           refreshBtn.className = "studio-pdf-card-action studio-pdf-card-refresh";
           refreshBtn.textContent = "Refresh";
-          refreshBtn.title = "Reload this PDF preview from disk.";
+          refreshBtn.title = "Reload this PDF preview from disk. Shortcut: Cmd/Ctrl+Alt+R.";
           refreshBtn.addEventListener("click", (event) => {
             event.preventDefault();
             event.stopPropagation();
@@ -7462,6 +8089,25 @@
           });
           actions.appendChild(refreshBtn);
 
+          const autoRefreshBtn = document.createElement("button");
+          autoRefreshBtn.type = "button";
+          autoRefreshBtn.className = "studio-pdf-card-action studio-pdf-card-auto-refresh";
+          autoRefreshBtn.textContent = "Auto-refresh";
+          autoRefreshBtn.title = "Watch this local PDF and reload it after a changed file is stable on disk.";
+          autoRefreshBtn.setAttribute("aria-label", "Enable PDF auto-refresh");
+          autoRefreshBtn.setAttribute("aria-pressed", "false");
+          autoRefreshBtn.addEventListener("click", (event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            const state = ensureStudioPdfCardAutoRefreshState(card, resourceQuery);
+            if (!state) {
+              setStatus("Could not resolve this PDF for auto-refresh.", "warning");
+              return;
+            }
+            setStudioPdfCardAutoRefresh(card, !state.enabled);
+          });
+          actions.appendChild(autoRefreshBtn);
+
           header.appendChild(actions);
         }
         card.appendChild(header);
@@ -7488,6 +8134,12 @@
         iframe.loading = "lazy";
         iframe.style.height = height + "px";
         card.appendChild(iframe);
+        const autoRefreshState = ensureStudioPdfCardAutoRefreshState(card, resourceQuery);
+        if (autoRefreshRequested) {
+          setStudioPdfAutoRefreshEnabled(autoRefreshState, true, { silent: true });
+        } else {
+          syncStudioPdfCardAutoRefreshButton(card);
+        }
         return card;
       }
 
@@ -8777,7 +9429,13 @@
               } else {
                 failPendingStudioTab(studioLaunch, "Studio did not return a preview-tab URL for this PDF export.");
                 const viewerUrl = getStudioPdfViewerUrlForExportPayload(payload);
-                if (viewerUrl) openStudioPdfFocusViewer(viewerUrl, downloadName);
+                const resourceQuery = exportPath
+                  ? buildStudioPdfResourceQuery({
+                      path: exportPath,
+                      resourceDir: exportPath.split(/[\\/]/).slice(0, -1).join("/"),
+                    }, false)
+                  : null;
+                if (viewerUrl) openStudioPdfFocusViewer(viewerUrl, downloadName, null, resourceQuery);
               }
               if (writeError) {
                 setStatus(openedStudio
@@ -11399,6 +12057,7 @@
         const canRefreshFromDisk = hasRefreshableFilePath();
 
         fileInput.disabled = uiBusy;
+        if (importFileBtn) importFileBtn.disabled = uiBusy;
         if (sourceBadgeEl) sourceBadgeEl.disabled = uiBusy;
         if (sourceResetOriginBtn) sourceResetOriginBtn.disabled = uiBusy;
         if (sourceOpenCurrentFileTabBtn) {
@@ -11714,12 +12373,15 @@
         return true;
       }
 
-      function clearStudioWorkspace() {
+      async function clearStudioWorkspace() {
         if (uiBusy) {
           setStatus("Studio is busy.", "warning");
           return;
         }
-        const confirmed = window.confirm("Reset the editor to a fresh blank draft in this browser tab? Saved files and responses are not changed.");
+        const confirmed = await requestStudioConfirmation(
+          "Reset the editor to a fresh blank draft in this browser tab? Saved files and responses are not changed.",
+          { title: "Reset editor?", confirmLabel: "Reset editor", destructive: true },
+        );
         if (!confirmed) return;
         const preservedResponseState = {
           responseHistory: Array.isArray(responseHistory) ? responseHistory.slice() : [],
@@ -12863,7 +13525,7 @@
         if (!raw || raw.charAt(0) === "#") return false;
         if (/^\/\//.test(raw)) return false;
         if (/^(?:https?|mailto|tel|data|blob|javascript|about):/i.test(raw)) return false;
-        if (/^\/(?:pdf-resource|html-preview-resource|export-pdf|export-html|render-preview|render-math|local-preview-link|reveal-local-resource)(?:[?#/]|$)/i.test(raw)) return false;
+        if (/^\/(?:pdf-resource|html-preview-resource|export-pdf|export-html|render-preview|render-math|import-file-copy|local-preview-link|reveal-local-resource|open-local-resource)(?:[?#/]|$)/i.test(raw)) return false;
         return true;
       }
 
@@ -12949,6 +13611,7 @@
         if (kind === "pdf") {
           appendPreviewLinkMenuButton(menu, "Open PDF preview", "open-pdf");
           appendPreviewLinkMenuButton(menu, "Open in new Studio tab", "open-preview-new");
+          appendPreviewLinkMenuButton(menu, "Open in system viewer", "open-system");
         } else if (kind === "text") {
           appendPreviewLinkMenuButton(menu, "Open file tab", "open-new");
           appendPreviewLinkMenuButton(menu, "Open here", "open-here");
@@ -12989,7 +13652,14 @@
           setStatus("Could not resolve this PDF link. Open the source file or set a working directory first.", "warning");
           return false;
         }
-        openStudioPdfFocusViewer(viewerUrl, title || href);
+        const cleanPath = stripPreviewLocalLinkUrlSuffix(href);
+        const context = contextOverride && typeof contextOverride === "object" ? contextOverride : {};
+        const resourceQuery = buildStudioPdfResourceQuery({
+          path: cleanPath,
+          sourcePath: context.sourcePath || "",
+          resourceDir: context.resourceDir || "",
+        }, true);
+        openStudioPdfFocusViewer(viewerUrl, title || href, null, resourceQuery);
         return true;
       }
 
@@ -13022,16 +13692,17 @@
         }
       }
 
-      function confirmPreviewOfficeConversion(href, destination) {
+      async function confirmPreviewOfficeConversion(href, destination) {
         if (getPreviewLocalLinkKind(href) !== "office") return true;
         const label = getPreviewOfficeConversionLabel(href);
         const target = destination === "here"
           ? "replace the current editor contents with an editable Markdown copy"
           : "open an editable Markdown copy in a new Studio tab";
-        const confirmed = window.confirm(
+        const confirmed = await requestStudioConfirmation(
           "Convert " + label + " to Markdown?\n\n"
           + "Studio will use Pandoc to " + target + ". Some layout or formatting may change. "
-          + "The original DOCX/ODT file will not be overwritten, and edits will not round-trip back to it."
+          + "The original DOCX/ODT file will not be overwritten, and edits will not round-trip back to it.",
+          { title: "Convert document?", confirmLabel: "Convert" },
         );
         if (!confirmed) setStatus("Document conversion cancelled.", "warning");
         return confirmed;
@@ -13043,13 +13714,17 @@
       }
 
       async function openPreviewDocumentHere(href, contextOverride, options) {
-        if (!confirmPreviewOfficeConversion(href, "here")) return;
+        if (!(await confirmPreviewOfficeConversion(href, "here"))) return;
         if (editorHasPotentialUnsavedContent()) {
           const kind = getPreviewLocalLinkKind(href);
           const prompt = kind === "office"
             ? "Replace the current editor contents with this converted Markdown copy? Unsaved editor changes may be lost."
             : "Open this file-backed document in the current editor?\n\nThis will replace the current editor contents and attach the editor to the file on disk, so Save editor and Refresh from disk use that file. Unsaved editor changes may be lost.";
-          const confirmed = window.confirm(prompt);
+          const confirmed = await requestStudioConfirmation(prompt, {
+            title: "Replace editor contents?",
+            confirmLabel: "Replace",
+            destructive: true,
+          });
           if (!confirmed) return;
         }
         const payload = await fetchPreviewLocalLink("document", href, contextOverride);
@@ -13080,7 +13755,7 @@
       }
 
       async function openPreviewDocumentInNewEditor(href, contextOverride) {
-        if (!confirmPreviewOfficeConversion(href, "new")) return;
+        if (!(await confirmPreviewOfficeConversion(href, "new"))) return;
         let launch = null;
         try {
           launch = openPendingStudioTab("document");
@@ -13136,6 +13811,10 @@
             openPreviewPdfLink(href, context.title || href, context);
             return;
           }
+          if (action === "open-system") {
+            await runStudioPdfLocalAction("system-viewer", getPreviewLinkResourceQuery(href, context));
+            return;
+          }
           if (action === "open-new") {
             await openPreviewDocumentInNewEditor(href, context);
             return;
@@ -14824,7 +15503,10 @@
             return;
           }
           if (String(scratchpadText || "").trim() && String(scratchpadText || "") !== String(text || "")) {
-            const confirmed = window.confirm("Replace the current scratchpad with this recent scratchpad? Current scratchpad text will remain saved under its current document/draft identity, but this panel will show the loaded text for the current document.");
+            const confirmed = await requestStudioConfirmation(
+              "Replace the current scratchpad with this recent scratchpad? Current scratchpad text will remain saved under its current document/draft identity, but this panel will show the loaded text for the current document.",
+              { title: "Replace scratchpad?", confirmLabel: "Replace", destructive: true },
+            );
             if (!confirmed) return;
           }
           setScratchpadText(text);
@@ -18646,7 +19328,7 @@
           deleteBtn.textContent = "Delete";
           deleteBtn.title = "Delete this local comment.";
           deleteBtn.addEventListener("click", () => {
-            deleteReviewNote(note.id);
+            void deleteReviewNote(note.id);
           });
           actions.appendChild(deleteBtn);
 
@@ -19010,24 +19692,29 @@
         });
       }
 
-      function deleteReviewNote(noteId) {
+      async function deleteReviewNote(noteId) {
         const note = reviewNotes.find((entry) => entry && entry.id === noteId);
         if (!note) return;
-        const confirmed = window.confirm("Delete this local comment?");
+        const confirmed = await requestStudioConfirmation("Delete this local comment?", {
+          title: "Delete comment?",
+          confirmLabel: "Delete",
+          destructive: true,
+        });
         if (!confirmed) return;
         setReviewNotes(reviewNotes.filter((entry) => entry && entry.id !== noteId));
         setStatus("Deleted local comment.", "success");
       }
 
-      function deleteAllReviewNotes() {
+      async function deleteAllReviewNotes() {
         if (!reviewNotes.length) {
           setStatus("No local comments to delete.", "warning");
           return;
         }
         const count = reviewNotes.length;
-        const confirmed = window.confirm(
+        const confirmed = await requestStudioConfirmation(
           "Delete all " + count + " local comment" + (count === 1 ? "" : "s") + " for this document?\n\n"
             + "Existing inline [an: ...] annotations in the editor text will not be removed.",
+          { title: "Delete all comments?", confirmLabel: "Delete all", destructive: true },
         );
         if (!confirmed) return;
         setReviewNotes([]);
@@ -21238,7 +21925,7 @@
         });
       }
 
-      function loadSelectedResponseIntoEditor(options) {
+      async function loadSelectedResponseIntoEditor(options) {
         if (!latestResponseMarkdown.trim()) {
           setStatus("No response available yet.", "warning");
           return false;
@@ -21249,12 +21936,15 @@
           && sourceState.source === "last-response"
           && Boolean(currentEditorText.trim())
           && normalizeForCompare(currentEditorText) !== latestResponseNormalized;
-        if (
-          replacingEditedResponse
-          && !window.confirm("Replace your edited response with a fresh copy? Existing edits and annotations will be lost.")
-        ) {
-          setStatus("Kept the current editor text.");
-          return false;
+        if (replacingEditedResponse) {
+          const confirmed = await requestStudioConfirmation(
+            "Replace your edited response with a fresh copy? Existing edits and annotations will be lost.",
+            { title: "Replace edited response?", confirmLabel: "Replace", destructive: true },
+          );
+          if (!confirmed) {
+            setStatus("Kept the current editor text.");
+            return false;
+          }
         }
         setEditorText(latestResponseMarkdown, { preserveScroll: false, preserveSelection: false });
         setSourceState({ source: "last-response", label: "last model response", path: null });
@@ -21272,11 +21962,11 @@
       }
 
       loadResponseBtn.addEventListener("click", () => {
-        loadSelectedResponseIntoEditor();
+        void loadSelectedResponseIntoEditor();
       });
 
       annotateResponseBtn.addEventListener("click", () => {
-        loadSelectedResponseIntoEditor({ annotate: true });
+        void loadSelectedResponseIntoEditor({ annotate: true });
       });
 
       loadCritiqueNotesBtn.addEventListener("click", () => {
@@ -21411,7 +22101,7 @@
         setFooterThemeMenuOpen(false);
       });
 
-      saveAsBtn.addEventListener("click", () => {
+      saveAsBtn.addEventListener("click", async () => {
         const content = sourceTextEl.value;
         if (!content.trim()) {
           setStatus("Editor is empty. Nothing to save.", "warning");
@@ -21421,7 +22111,10 @@
         var suggestedName = sourceState.label ? stripImportedFileLabel(sourceState.label) : "draft.md";
         var suggestedDir = getCurrentResourceDirValue() ? getCurrentResourceDirValue().replace(/\/$/, "") + "/" : "./";
         const suggested = sourceState.path || (suggestedDir + suggestedName);
-        const path = window.prompt("Save editor content as:", suggested);
+        const path = await requestStudioTextInput("Save editor content as:", suggested, {
+          title: "Save editor as",
+          confirmLabel: "Save",
+        });
         if (!path) return;
 
         const requestId = beginUiAction("save_as");
@@ -21441,16 +22134,19 @@
         }
       });
 
-      saveOverBtn.addEventListener("click", () => {
+      saveOverBtn.addEventListener("click", async () => {
         var effectivePath = getEffectiveSavePath();
         if (!effectivePath) {
           setStatus("Save editor requires a file path. Open via /studio <path>, set a working dir, or use Save editor as…", "warning");
           return;
         }
 
-        if (!window.confirm("Overwrite " + effectivePath + "?")) {
-          return;
-        }
+        const confirmed = await requestStudioConfirmation("Overwrite " + effectivePath + "?", {
+          title: "Overwrite file?",
+          confirmLabel: "Overwrite",
+          destructive: true,
+        });
+        if (!confirmed) return;
 
         const requestId = beginUiAction("save_over");
         if (!requestId) return;
@@ -21471,14 +22167,17 @@
       });
 
       if (refreshFromDiskBtn) {
-        refreshFromDiskBtn.addEventListener("click", () => {
+        refreshFromDiskBtn.addEventListener("click", async () => {
           if (!hasRefreshableFilePath()) {
             setStatus("Refresh from disk needs a file path. Use Files → Open here, Files → Open file tab, or /studio-editor-only <path> for a refreshable editor tab.", "warning");
             return;
           }
 
           if (editorDiffersFromFileBackedBaseline()) {
-            const confirmed = window.confirm("Replace current editor contents with the latest version from disk?");
+            const confirmed = await requestStudioConfirmation(
+              "Replace current editor contents with the latest version from disk?",
+              { title: "Refresh from disk?", confirmLabel: "Replace", destructive: true },
+            );
             if (!confirmed) return;
           }
 
@@ -21501,7 +22200,7 @@
 
       if (clearWorkspaceBtn) {
         clearWorkspaceBtn.addEventListener("click", () => {
-          clearStudioWorkspace();
+          void clearStudioWorkspace();
         });
       }
 
@@ -21764,7 +22463,7 @@
 
       if (reviewNotesDeleteAllBtn) {
         reviewNotesDeleteAllBtn.addEventListener("click", () => {
-          deleteAllReviewNotes();
+          void deleteAllReviewNotes();
         });
       }
 
@@ -21966,9 +22665,13 @@
       }
 
       if (scratchpadClearBtn) {
-        scratchpadClearBtn.addEventListener("click", () => {
+        scratchpadClearBtn.addEventListener("click", async () => {
           if (!String(scratchpadText || "").length) return;
-          const confirmed = window.confirm("Clear scratchpad text?");
+          const confirmed = await requestStudioConfirmation("Clear scratchpad text?", {
+            title: "Clear scratchpad?",
+            confirmLabel: "Clear",
+            destructive: true,
+          });
           if (!confirmed) return;
           setScratchpadText("");
           if (scratchpadTextEl) scratchpadTextEl.focus();
@@ -21977,7 +22680,7 @@
       }
 
       if (saveAnnotatedBtn) {
-        saveAnnotatedBtn.addEventListener("click", () => {
+        saveAnnotatedBtn.addEventListener("click", async () => {
           const content = sourceTextEl.value;
           if (!content.trim()) {
             setStatus("Editor is empty. Nothing to save.", "warning");
@@ -21985,7 +22688,10 @@
           }
 
           const suggested = buildAnnotatedSaveSuggestion();
-          const path = window.prompt("Save annotated editor content as:", suggested);
+          const path = await requestStudioTextInput("Save annotated editor content as:", suggested, {
+            title: "Save annotated editor as",
+            confirmLabel: "Save",
+          });
           if (!path) return;
 
           const requestId = beginUiAction("save_as");
@@ -22007,14 +22713,17 @@
       }
 
       if (stripAnnotationsBtn) {
-        stripAnnotationsBtn.addEventListener("click", () => {
+        stripAnnotationsBtn.addEventListener("click", async () => {
           const content = sourceTextEl.value;
           if (!hasAnnotationMarkers(content)) {
             setStatus("No [an: ...] markers found in editor.", "warning");
             return;
           }
 
-          const confirmed = window.confirm("Remove all [an: ...] markers from editor text? This cannot be undone.");
+          const confirmed = await requestStudioConfirmation(
+            "Remove all [an: ...] markers from editor text? This cannot be undone.",
+            { title: "Remove all annotations?", confirmLabel: "Remove", destructive: true },
+          );
           if (!confirmed) return;
 
           const strippedContent = stripAnnotationMarkers(content);
@@ -22049,7 +22758,7 @@
       }
       if (sourceBadgeEl) {
         sourceBadgeEl.addEventListener("click", () => {
-          if (!studioUiRefreshEnabled) resetEditorOrigin();
+          if (!studioUiRefreshEnabled) void resetEditorOrigin();
         });
       }
       if (resourceDirBtn) {
@@ -22092,6 +22801,72 @@
         });
       }
 
+      function applyImportedFileCopy(text, filename) {
+        const name = String(filename || "imported file").trim() || "imported file";
+        setEditorText(String(text || ""), { preserveScroll: false, preserveSelection: false });
+        setSourceState({
+          source: "upload",
+          label: "imported copy: " + name,
+          path: null,
+        });
+        refreshResponseUi();
+        const detectedLang = detectLanguageFromName(name);
+        if (detectedLang) setEditorLanguage(detectedLang);
+        setStatus("Imported file copy: " + name + ".", "success");
+      }
+
+      function chooseStudioFileCopyWithBrowser() {
+        fileInput.value = "";
+        setStatus("If no file picker appeared, enter the file path and select Import from path.");
+        try {
+          fileInput.click();
+        } catch {
+          setStatus("This browser could not open its file picker. Enter the file path and select Import from path.", "warning");
+        }
+      }
+
+      async function openStudioFileCopyDialog() {
+        const resourceDir = getCurrentResourceDirValue();
+        const suggestedPath = resourceDir ? resourceDir.replace(/[\\/]$/, "") + "/" : "./";
+        let path = null;
+        studioImportDecisionOpen = true;
+        try {
+          path = await requestStudioTextInput(
+            "Enter the path to a file you want to import, or use Browse to open your browser’s file picker.",
+            suggestedPath,
+            {
+              title: "Import file copy",
+              confirmLabel: "Import from path",
+              secondaryLabel: "Browse…",
+              onSecondary: chooseStudioFileCopyWithBrowser,
+              inputLabel: "File path on computer running Pi",
+              placeholder: "/path/to/file.md",
+            },
+          );
+        } finally {
+          studioImportDecisionOpen = false;
+        }
+        if (!path) return;
+        try {
+          const payload = await fetchStudioJson("/import-file-copy", {
+            method: "POST",
+            body: JSON.stringify({ path }),
+          });
+          if (typeof payload.text !== "string") throw new Error("Studio did not return file text.");
+          applyImportedFileCopy(payload.text, typeof payload.filename === "string" ? payload.filename : path);
+        } catch (error) {
+          setStatus("Could not import file copy: " + (error && error.message ? error.message : String(error || "unknown error")), "warning");
+        }
+      }
+
+      if (importFileBtn) {
+        importFileBtn.addEventListener("click", (event) => {
+          event.preventDefault();
+          event.stopPropagation();
+          void openStudioFileCopyDialog();
+        });
+      }
+
       fileInput.addEventListener("change", () => {
         const file = fileInput.files && fileInput.files[0];
         if (!file) return;
@@ -22103,21 +22878,11 @@
         const reader = new FileReader();
         reader.onload = () => {
           const text = typeof reader.result === "string" ? reader.result : "";
-          setEditorText(text, { preserveScroll: false, preserveSelection: false });
-          setSourceState({
-            source: "upload",
-            label: "imported copy: " + file.name,
-            path: null,
-          });
-          refreshResponseUi();
-          const detectedLang = detectLanguageFromName(file.name);
-          if (detectedLang) {
-            setEditorLanguage(detectedLang);
-          }
-          setStatus("Imported file copy: " + file.name + ".", "success");
+          if (studioImportDecisionOpen) finishStudioDecision(null);
+          applyImportedFileCopy(text, file.name);
         };
         reader.onerror = () => {
-          setStatus("Failed to read file.", "error");
+          setStatus("Failed to read file. Enter its path in the import dialog or choose another file.", "error");
         };
         reader.readAsText(file);
       });