pressship 0.1.13 → 0.1.15

package/assets/web/app.js

@@ -3,6 +3,10 @@
 let token = document.querySelector('meta[name="pressship-token"]').content;
 
 let markdownParser = basicMarkdownToHtml;
+let studioPackageSizePollTimer = null;
+let monacoConfigured = false;
+
+const STUDIO_CLI_PREFIX = "npx pressship";
 
 void import("/vendor/marked.esm.js")
   .then(({ marked }) => {
@@ -11,9 +15,11 @@ void import("/vendor/marked.esm.js")
       breaks: true
     });
     markdownParser = (markdown) => marked.parse(markdown, { async: false });
+    refreshStudioAiMarkdownIfReady();
   })
   .catch(() => {
     markdownParser = basicMarkdownToHtml;
+    refreshStudioAiMarkdownIfReady();
   });
 
 const MARKDOWN_ALLOWED_TAGS = new Set([
@@ -120,6 +126,8 @@ function clampStudioLayoutValue(key, value) {
 }
 
 const STUDIO_SIDEBAR_TAB_KEY = "pressship.studio.sidebar.tab.v1";
+const STUDIO_PANEL_STORAGE_KEY = "pressship.studio.panels.v1";
+const STUDIO_THEME_STORAGE_KEY = "pressship.studio.theme.v1";
 
 function loadStudioSidebarTab(pluginKey) {
   if (!pluginKey) {
@@ -147,6 +155,60 @@ function saveStudioSidebarTab(pluginKey, tab) {
   }
 }
 
+function loadStudioPanelState() {
+  try {
+    const raw = typeof localStorage !== "undefined" ? localStorage.getItem(STUDIO_PANEL_STORAGE_KEY) : null;
+    const parsed = raw ? JSON.parse(raw) : {};
+    return normalizeStudioPanelState(parsed);
+  } catch {
+    return normalizeStudioPanelState();
+  }
+}
+
+function normalizeStudioPanelState(value = {}) {
+  return {
+    files: value.files !== false,
+    sidebar: value.sidebar !== false
+  };
+}
+
+function saveStudioPanelState(panels) {
+  try {
+    localStorage.setItem(STUDIO_PANEL_STORAGE_KEY, JSON.stringify(normalizeStudioPanelState(panels)));
+  } catch {
+    // ignore
+  }
+}
+
+function normalizeStudioTheme(value) {
+  return value === "light" ? "light" : "dark";
+}
+
+function loadStudioTheme() {
+  try {
+    const raw = typeof localStorage !== "undefined" ? localStorage.getItem(STUDIO_THEME_STORAGE_KEY) : null;
+    return normalizeStudioTheme(raw);
+  } catch {
+    return "dark";
+  }
+}
+
+function saveStudioTheme(theme) {
+  try {
+    localStorage.setItem(STUDIO_THEME_STORAGE_KEY, normalizeStudioTheme(theme));
+  } catch {
+    // ignore
+  }
+}
+
+function studioTheme() {
+  return normalizeStudioTheme(state.studio.theme);
+}
+
+function studioMonacoTheme() {
+  return studioTheme() === "light" ? "pressship-studio-light" : "pressship-studio-dark";
+}
+
 function createInitialStudioRelease() {
   return {
     tags: null,
@@ -169,7 +231,31 @@ function createInitialStudioRelease() {
     switchingResolution: "",
     switchJobId: null,
     switchConflict: null,
-    switchError: ""
+    switchError: "",
+    ignoredCollapsed: true
+  };
+}
+
+function createInitialStudioIgnoreState() {
+  return {
+    ignorePath: "",
+    patterns: [],
+    ignoredFiles: []
+  };
+}
+
+function createInitialStudioPackageSize() {
+  return {
+    loading: false,
+    error: "",
+    sizeBytes: null,
+    maxSizeBytes: 10 * 1024 * 1024,
+    overLimit: false,
+    fileCount: 0,
+    topLevelFolder: "",
+    largestFiles: [],
+    calculatedAt: null,
+    stale: false
   };
 }
 
@@ -342,6 +428,7 @@ const state = {
     id: null,
     plugin: null,
     files: [],
+    directories: [],
     selectedFile: null,
     fileContent: "",
     draftContent: "",
@@ -359,8 +446,11 @@ const state = {
     playgroundUrl: "",
     playgroundUrls: null,
     activeTab: "editor",
+    openFiles: [],
     terminalOpen: true,
     collapsedFolders: new Set(),
+    expandedIgnoredFolders: new Set(),
+    loadingFolders: new Set(),
     terminal: [],
     aiPrompt: "",
     aiJobId: null,
@@ -374,9 +464,17 @@ const state = {
     editorKind: null,
     editorModels: [],
     layout: loadStudioLayout(),
+    panels: loadStudioPanelState(),
+    theme: loadStudioTheme(),
     sidebarTab: "ai",
     playgroundVersionModal: null,
     release: createInitialStudioRelease(),
+    ignoreState: createInitialStudioIgnoreState(),
+    packageSize: createInitialStudioPackageSize(),
+    ignoreLoading: false,
+    ignoreError: "",
+    ignoreBusyPattern: "",
+    ignoreBusyPath: "",
     pendingConfirms: new Map()
   },
   activeView: "dashboard",
@@ -423,6 +521,30 @@ const els = {
 const isMac =
   typeof navigator !== "undefined" && /Mac|iPhone|iPad|iPod/i.test(navigator.platform || "");
 let monacoPromise = null;
+const VIEW_ROUTE_PATHS = {
+  dashboard: "/dashboard",
+  studio: "/studio",
+  remote: "/wordpress.org",
+  local: "/local",
+  release: "/release",
+  settings: "/settings"
+};
+const ROUTE_VIEW_ALIASES = {
+  "": "dashboard",
+  dashboard: "dashboard",
+  studio: "studio",
+  "wordpress.org": "remote",
+  remote: "remote",
+  local: "local",
+  release: "release",
+  settings: "settings"
+};
+let applyingLocationRoute = false;
+let initialRouteLoaderVisible = false;
+let studioFileSyncInFlight = false;
+let studioLastExternalSyncAt = 0;
+let studioLastDiskConflictKey = "";
+
 document.querySelectorAll("[data-kbd-mod]").forEach((node) => {
   node.textContent = isMac ? "⌘" : "Ctrl+";
 });
@@ -482,6 +604,14 @@ document.addEventListener("keydown", (event) => {
     return;
   }
 
+  if (mod && event.key.toLowerCase() === "s" && !event.shiftKey && !event.altKey && state.activeView === "studio") {
+    event.preventDefault();
+    if (canSaveStudioFile()) {
+      void saveStudioFile();
+    }
+    return;
+  }
+
   if (event.key === "Escape" && state.command.open) {
     event.preventDefault();
     closeCommandPalette();
@@ -525,6 +655,258 @@ els.commandInput?.addEventListener("input", () => {
   renderCommandPalette();
 });
 
+window.addEventListener("popstate", () => {
+  void applyLocationRoute({ replaceRoute: true });
+});
+
+window.addEventListener("focus", () => {
+  syncSelectedStudioFileOnResume();
+});
+
+document.addEventListener("visibilitychange", () => {
+  if (!document.hidden) {
+    syncSelectedStudioFileOnResume();
+  }
+});
+
+function normalizeViewId(view) {
+  return Object.prototype.hasOwnProperty.call(VIEW_ROUTE_PATHS, view) ? view : "dashboard";
+}
+
+function normalizeBrowserPath(pathname = window.location.pathname) {
+  const trimmed = pathname.replace(/\/+$/, "");
+  return trimmed || "/";
+}
+
+function shouldShowInitialRouteLoader() {
+  const path = normalizeBrowserPath();
+  return path !== "/" && path !== VIEW_ROUTE_PATHS.dashboard;
+}
+
+function showInitialRouteLoader() {
+  if (!shouldShowInitialRouteLoader() || initialRouteLoaderVisible) {
+    return;
+  }
+  initialRouteLoaderVisible = true;
+  document.body.classList.add("is-initial-route-loading");
+  const loader = document.createElement("div");
+  loader.id = "initial-route-loader";
+  loader.className = "ps-initial-route-loader";
+  loader.setAttribute("role", "status");
+  loader.setAttribute("aria-live", "polite");
+  loader.innerHTML = `
+    <div class="ps-initial-route-loader-card">
+      <img src="/brand/pressship-symbol.png" alt="" />
+      <span class="dashicons dashicons-update" aria-hidden="true"></span>
+      <strong>Loading Pressship Studio</strong>
+      <p>Restoring the requested page...</p>
+    </div>
+  `;
+  document.body.append(loader);
+}
+
+function hideInitialRouteLoader() {
+  if (!initialRouteLoaderVisible) {
+    return;
+  }
+  initialRouteLoaderVisible = false;
+  document.body.classList.remove("is-initial-route-loading");
+  document.getElementById("initial-route-loader")?.remove();
+}
+
+function decodeRouteSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+
+function encodeRouteSegments(value) {
+  return String(value ?? "")
+    .split("/")
+    .filter(Boolean)
+    .map((segment) => encodeURIComponent(segment))
+    .join("/");
+}
+
+function parseLocationRoute(pathname = window.location.pathname) {
+  const segments = pathname
+    .split("/")
+    .filter(Boolean)
+    .map((segment) => decodeRouteSegment(segment));
+  const head = segments[0] ?? "";
+
+  if (head === "studio") {
+    return {
+      view: "studio",
+      studio: {
+        project: segments[1] ?? "",
+        filePath: segments.slice(2).join("/")
+      }
+    };
+  }
+
+  return {
+    view: ROUTE_VIEW_ALIASES[head] ?? "dashboard"
+  };
+}
+
+function applyActiveViewShell(view) {
+  const nextView = normalizeViewId(view);
+  state.activeView = nextView;
+  document.body.dataset.activeView = nextView;
+  document.querySelectorAll(".view").forEach((node) => node.classList.remove("is-active"));
+  document.getElementById(`view-${nextView}`)?.classList.add("is-active");
+  document
+    .querySelectorAll("#adminmenu li")
+    .forEach((node) => node.classList.remove("wp-has-current-submenu"));
+  document
+    .querySelector(`#adminmenu li[data-view="${nextView}"]`)
+    ?.classList.add("wp-has-current-submenu");
+  return nextView;
+}
+
+function primeInitialRouteState(route) {
+  const nextView = applyActiveViewShell(route.view);
+  if (nextView !== "studio" || !route.studio?.project || state.studio.id) {
+    return;
+  }
+
+  const filePath = route.studio.filePath;
+  state.studio = {
+    ...state.studio,
+    scope: null,
+    id: route.studio.project,
+    plugin: { slug: route.studio.project, name: route.studio.project },
+    files: [],
+    directories: [],
+    selectedFile: filePath
+      ? {
+          path: filePath,
+          name: filePath.split("/").pop() ?? filePath,
+          directory: filePath.includes("/") ? filePath.split("/").slice(0, -1).join("/") : "",
+          size: 0
+        }
+      : null,
+    fileContent: "",
+    draftContent: "",
+    readOnly: true,
+    dirty: false,
+    loading: true,
+    running: false,
+    checking: false,
+    jobId: null,
+    checkJobId: null,
+    activeTab: "editor",
+    openFiles: filePath ? [filePath] : [],
+    terminal: [
+      `Opening ${route.studio.project} from URL...`,
+      { message: `$ ${studioOpenCliCommand()}`, tone: "command" }
+    ],
+    collapsedFolders: new Set(),
+    expandedIgnoredFolders: new Set(),
+    loadingFolders: new Set(),
+    pendingConfirms: new Map()
+  };
+}
+
+function studioProjectRouteSegment() {
+  const plugin = state.studio.plugin;
+  const localPlugin = state.local.find((item) => item.id === state.studio.id);
+  return plugin?.slug || localPlugin?.slug || plugin?.name || state.studio.id || "";
+}
+
+function studioRoutePathForState() {
+  if (!state.studio.id) {
+    return VIEW_ROUTE_PATHS.studio;
+  }
+  const project = studioProjectRouteSegment();
+  if (!project) {
+    return VIEW_ROUTE_PATHS.studio;
+  }
+  const filePath =
+    state.studio.activeTab === "editor" && state.studio.selectedFile?.path
+      ? encodeRouteSegments(state.studio.selectedFile.path)
+      : "";
+  const projectPath = encodeURIComponent(project);
+  return filePath ? `/studio/${projectPath}/${filePath}` : `/studio/${projectPath}`;
+}
+
+function routePathForState() {
+  const view = normalizeViewId(state.activeView);
+  return view === "studio" ? studioRoutePathForState() : VIEW_ROUTE_PATHS[view];
+}
+
+function updateRouteFromState(options = {}) {
+  if (applyingLocationRoute && !options.force) {
+    return;
+  }
+  const nextPath = routePathForState();
+  if (normalizeBrowserPath(nextPath) === normalizeBrowserPath()) {
+    return;
+  }
+  const method = options.replace ? "replaceState" : "pushState";
+  history[method]({ pressshipView: state.activeView }, "", nextPath);
+}
+
+function resolveStudioRouteProject(project) {
+  if (!project) {
+    return null;
+  }
+  const normalizedProject = project.toLowerCase();
+  const matchesProject = (candidate) => {
+    if (!candidate) {
+      return false;
+    }
+    return candidate === project || candidate.toLowerCase() === normalizedProject;
+  };
+  const localPlugin = state.local.find((plugin) =>
+    [plugin.slug, plugin.id, plugin.name].some((candidate) => matchesProject(candidate))
+  );
+  if (localPlugin) {
+    return { scope: "local", id: localPlugin.id };
+  }
+
+  const remotePlugin = state.remote.find((plugin) =>
+    [plugin.slug, plugin.name].some((candidate) => matchesProject(candidate))
+  );
+  return { scope: "remote", id: remotePlugin?.slug || project };
+}
+
+async function applyLocationRoute(options = {}) {
+  const route = parseLocationRoute();
+  applyingLocationRoute = true;
+  try {
+    if (route.view === "studio") {
+      if (route.studio?.project) {
+        const target = resolveStudioRouteProject(route.studio.project);
+        if (target) {
+          await openStudio(target.scope, target.id, {
+            filePath: route.studio.filePath,
+            updateRoute: false
+          });
+        } else {
+          await showView("studio", { updateRoute: false });
+          renderStudio();
+        }
+      } else {
+        await showView("studio", { updateRoute: false });
+        renderStudio();
+      }
+    } else {
+      await showView(route.view, { updateRoute: false });
+    }
+  } finally {
+    applyingLocationRoute = false;
+  }
+
+  if (options.replaceRoute !== false) {
+    updateRouteFromState({ replace: true, force: true });
+  }
+}
+
+showInitialRouteLoader();
 void boot();
 
 async function boot() {
@@ -532,13 +914,15 @@ async function boot() {
     state.bootstrap = await api("/api/bootstrap");
     refreshTokenFromBootstrap(state.bootstrap);
   } catch (error) {
+    hideInitialRouteLoader();
     notice(`Could not load bootstrap state: ${error.message}`, "error");
     return;
   }
   state.settings = state.bootstrap.settings ?? null;
   state.playgrounds = state.bootstrap.playgrounds ?? [];
   state.aiAssistance.harnesses = state.bootstrap.aiHarnesses ?? [];
-  document.body.dataset.activeView = state.activeView;
+  const initialRoute = parseLocationRoute();
+  primeInitialRouteState(initialRoute);
   renderAccount();
   for (const job of state.bootstrap.jobs ?? []) {
     upsertJob(job);
@@ -549,8 +933,16 @@ async function boot() {
   renderDashboard();
   renderStudio();
   renderPlaygroundsMenu();
+  if (state.activeView === "release") {
+    void loadReleaseBoard();
+  }
   void loadAiAssistance();
-  await Promise.all([loadRemote(), loadLocal()]);
+  try {
+    await Promise.all([loadRemote(), loadLocal()]);
+    await applyLocationRoute({ replaceRoute: true });
+  } finally {
+    hideInitialRouteLoader();
+  }
 }
 
 function renderAccount() {
@@ -598,14 +990,48 @@ async function runAction(name, element) {
         await selectStudioFile(element.dataset.path);
         return;
 
+      case "studio-ignore-file":
+        await addStudioIgnoreRule(studioFileIgnorePattern(element.dataset.path), {
+          path: element.dataset.path,
+          label: element.dataset.path
+        });
+        return;
+
+      case "studio-ignore-folder":
+        await addStudioIgnoreRule(studioFolderIgnorePattern(element.dataset.path), {
+          path: element.dataset.path,
+          label: `${element.dataset.path}/`
+        });
+        return;
+
+      case "studio-unignore-rule":
+        await removeStudioIgnoreRule(element.dataset.pattern);
+        return;
+
+      case "studio-close-file-tab":
+        await closeStudioFileTab(element.dataset.path);
+        return;
+
       case "studio-toggle-folder":
-        toggleStudioFolder(element.dataset.folder);
+        await toggleStudioFolder(element.dataset.folder);
         return;
 
       case "studio-toggle-terminal":
         toggleStudioTerminal();
         return;
 
+      case "studio-toggle-files":
+        toggleStudioPanel("files");
+        return;
+
+      case "studio-toggle-sidebar":
+        toggleStudioPanel("sidebar");
+        return;
+
+      case "studio-open-sidebar-tab":
+        openStudioSidebarTab(element.dataset.tab);
+        return;
+
       case "studio-save":
         await saveStudioFile();
         return;
@@ -614,6 +1040,14 @@ async function runAction(name, element) {
         await runStudioCheck();
         return;
 
+      case "studio-package-size":
+        await refreshStudioPackageSize({ force: true, notify: true });
+        return;
+
+      case "studio-toggle-theme":
+        toggleStudioTheme();
+        return;
+
       case "studio-check-note":
         revealStudioCheckNote(Number(element.dataset.line || 1), Number(element.dataset.column || 1));
         return;
@@ -727,7 +1161,14 @@ async function runAction(name, element) {
         return;
 
       case "studio-release-refresh":
-        await loadStudioReleaseTags({ force: true });
+        await Promise.all([
+          loadStudioReleaseTags({ force: true }),
+          refreshStudioIgnoreState({ files: true })
+        ]);
+        return;
+
+      case "studio-release-toggle-ignored":
+        toggleStudioReleaseIgnored();
         return;
 
       case "studio-release-switch":
@@ -1089,6 +1530,7 @@ async function openStudio(scope, id, options = {}) {
     id,
     plugin: null,
     files: [],
+    directories: [],
     selectedFile: null,
     fileContent: "",
     draftContent: "",
@@ -1106,9 +1548,15 @@ async function openStudio(scope, id, options = {}) {
     playgroundUrl: "",
     playgroundUrls: null,
     activeTab: "editor",
+    openFiles: [],
     terminalOpen: true,
     collapsedFolders: new Set(),
-    terminal: [`Pressship Studio opened for ${scope === "local" ? "local plugin" : "WordPress.org plugin"} ${id}.`],
+    expandedIgnoredFolders: new Set(),
+    loadingFolders: new Set(),
+    terminal: [
+      `Pressship Studio opened for ${scope === "local" ? "local plugin" : "WordPress.org plugin"} ${id}.`,
+      { message: `$ ${studioOpenCliCommand()}`, tone: "command" }
+    ],
     aiPrompt: "",
     aiJobId: null,
     aiRunning: false,
@@ -1121,13 +1569,21 @@ async function openStudio(scope, id, options = {}) {
     editorKind: null,
     editorModels: [],
     layout: state.studio.layout ?? loadStudioLayout(),
+    panels: normalizeStudioPanelState(state.studio.panels ?? loadStudioPanelState()),
+    theme: normalizeStudioTheme(state.studio.theme ?? loadStudioTheme()),
     sidebarTab,
     playgroundVersionModal: null,
     release: createInitialStudioRelease(),
+    ignoreState: createInitialStudioIgnoreState(),
+    packageSize: createInitialStudioPackageSize(),
+    ignoreLoading: false,
+    ignoreError: "",
+    ignoreBusyPattern: "",
+    ignoreBusyPath: "",
     pendingConfirms: new Map()
   };
   saveStudioSidebarTab(pluginKey, sidebarTab);
-  showView("studio");
+  await showView("studio", { updateRoute: false });
   renderStudio();
   if (scope === "local" && sidebarTab === "release") {
     void loadStudioReleaseTags();
@@ -1139,33 +1595,56 @@ async function openStudio(scope, id, options = {}) {
     state.studio.loading = false;
 
     if (scope === "local") {
-      const [result, checkState] = await Promise.all([
+      const [result, checkState, ignoreState] = await Promise.all([
         api(`/api/plugins/local/${encodeURIComponent(id)}/files`),
-        api(`/api/plugins/local/${encodeURIComponent(id)}/check-state`).catch(() => ({ state: null }))
+        api(`/api/plugins/local/${encodeURIComponent(id)}/check-state`).catch(() => ({ state: null })),
+        api(`/api/plugins/local/${encodeURIComponent(id)}/ignore-state`).catch(() => createInitialStudioIgnoreState())
       ]);
       state.studio.files = result.files ?? [];
+      state.studio.directories = result.directories ?? [];
       applyStudioCheckState(checkState.state);
+      applyStudioIgnoreState(ignoreState);
       renderStudio();
-      const initialFile = chooseInitialStudioFile(state.studio.files, state.studio.plugin?.slug);
+      const requestedFile = options.filePath
+        ? state.studio.files.find((file) => file.path === options.filePath)
+        : null;
+      if (options.filePath && !requestedFile) {
+        appendStudioTerminal(`Route file not found: ${options.filePath}`, "warning");
+      }
+      const initialFile = requestedFile ?? chooseInitialStudioFile(state.studio.files, state.studio.plugin?.slug);
       if (initialFile) {
-        await selectStudioFile(initialFile.path);
+        await selectStudioFile(initialFile.path, {
+          updateRoute: options.updateRoute,
+          replaceRoute: options.replaceRoute
+        });
       } else {
         state.studio.draftContent = "";
         remountStudioEditorIfNeeded();
+        if (options.updateRoute !== false) {
+          updateRouteFromState({ replace: options.replaceRoute });
+        }
       }
+      void refreshStudioPackageSize({ render: true });
     } else {
       state.studio.files = [{ path: "readme.txt", name: "readme.txt", directory: "", size: detail.readme?.length ?? 0 }];
       state.studio.selectedFile = state.studio.files[0];
+      state.studio.openFiles = ["readme.txt"];
       state.studio.fileContent = detail.readme ?? "No hosted readme.txt could be loaded.";
       state.studio.draftContent = state.studio.fileContent;
       state.studio.readOnly = true;
       renderStudio();
       remountStudioEditorIfNeeded();
+      if (options.updateRoute !== false) {
+        updateRouteFromState({ replace: options.replaceRoute });
+      }
     }
   } catch (error) {
     state.studio.loading = false;
     appendStudioTerminal(error.message, "error");
     renderStudio();
+    if (options.updateRoute !== false) {
+      updateRouteFromState({ replace: options.replaceRoute });
+    }
   }
 }
 
@@ -1188,6 +1667,7 @@ async function selectStudioFile(relativePath, options = {}) {
     return;
   }
 
+  ensureStudioFileTab(relativePath);
   state.studio.selectedFile = state.studio.files.find((file) => file.path === relativePath) ?? {
     path: relativePath,
     name: relativePath.split("/").pop() ?? relativePath,
@@ -1200,6 +1680,9 @@ async function selectStudioFile(relativePath, options = {}) {
   state.studio.activeTab = "editor";
   renderStudio();
   remountStudioEditorIfNeeded();
+  if (options.updateRoute !== false) {
+    updateRouteFromState({ replace: options.replaceRoute });
+  }
 
   try {
     const result = await api(
@@ -1213,8 +1696,100 @@ async function selectStudioFile(relativePath, options = {}) {
     remountStudioEditorIfNeeded();
   } catch (error) {
     appendStudioTerminal(error.message, "error");
+    state.studio.fileContent = `Cannot open ${relativePath}.\n\n${error.message}`;
+    state.studio.draftContent = state.studio.fileContent;
+    state.studio.dirty = false;
+    renderStudio();
+    remountStudioEditorIfNeeded();
+  }
+}
+
+function syncSelectedStudioFileOnResume() {
+  if (Date.now() - studioLastExternalSyncAt < 1200) {
+    return;
+  }
+  studioLastExternalSyncAt = Date.now();
+  void syncSelectedStudioFileFromDisk({ reason: "external" });
+}
+
+async function syncSelectedStudioFileFromDisk(options = {}) {
+  if (
+    studioFileSyncInFlight ||
+    state.studio.scope !== "local" ||
+    !state.studio.id ||
+    !state.studio.selectedFile?.path ||
+    state.studio.activeTab !== "editor" ||
+    state.studio.loading ||
+    state.studio.readOnly ||
+    studioAiChangedFile(state.studio.selectedFile.path)
+  ) {
+    return false;
+  }
+
+  const selectedPath = state.studio.selectedFile.path;
+  studioFileSyncInFlight = true;
+  captureStudioEditorValue();
+
+  try {
+    const result = await api(
+      `/api/plugins/local/${encodeURIComponent(state.studio.id)}/files/content?path=${encodeURIComponent(selectedPath)}`
+    );
+    if (state.studio.selectedFile?.path !== selectedPath) {
+      return false;
+    }
+
+    const diskContent = result.content ?? "";
+    if (diskContent === state.studio.fileContent) {
+      return false;
+    }
+
+    if (state.studio.dirty && state.studio.draftContent !== diskContent) {
+      const conflictKey = `${selectedPath}:${diskContent.length}:${diskContent.slice(0, 80)}`;
+      if (studioLastDiskConflictKey !== conflictKey) {
+        studioLastDiskConflictKey = conflictKey;
+        appendStudioTerminal(
+          `${selectedPath} changed on disk. Your unsaved editor changes were kept.`,
+          "warning"
+        );
+        notice(`${selectedPath} changed on disk. Unsaved editor changes were kept.`, "warning");
+      }
+      return false;
+    }
+
+    studioLastDiskConflictKey = "";
+    state.studio.selectedFile =
+      state.studio.files.find((file) => file.path === result.path) ?? state.studio.selectedFile;
+    state.studio.fileContent = diskContent;
+    state.studio.draftContent = diskContent;
+    state.studio.dirty = false;
     renderStudio();
+    remountStudioEditorIfNeeded();
+    updateStudioControls();
+    if (options.reason === "ignore-rule") {
+      appendStudioTerminal(`Reloaded ${selectedPath} after ignore rules changed.`, "success");
+    } else if (options.reason === "external") {
+      appendStudioTerminal(`Reloaded ${selectedPath} from disk.`, "status");
+    }
+    return true;
+  } catch (error) {
+    if (options.reportErrors) {
+      appendStudioTerminal(`Could not refresh ${selectedPath}: ${error.message}`, "error");
+    }
+    return false;
+  } finally {
+    studioFileSyncInFlight = false;
+  }
+}
+
+function ensureStudioFileTab(relativePath) {
+  if (!relativePath) {
+    return;
   }
+  const openFiles = Array.isArray(state.studio.openFiles) ? state.studio.openFiles : [];
+  if (!openFiles.includes(relativePath)) {
+    openFiles.push(relativePath);
+  }
+  state.studio.openFiles = openFiles;
 }
 
 async function saveStudioFile() {
@@ -1238,6 +1813,10 @@ async function saveStudioFile() {
     state.studio.draftContent = content;
     state.studio.dirty = false;
     appendStudioTerminal(`Saved ${state.studio.selectedFile.path}.`, "success");
+    markStudioPackageSizeStale();
+    if (state.studio.selectedFile.path === ".pressshipignore") {
+      await refreshStudioIgnoreState({ files: true, render: false });
+    }
     renderStudio();
     remountStudioEditorIfNeeded();
     updateStudioControls();
@@ -1472,6 +2051,7 @@ async function selectStudioAiChange(filePath) {
   state.studio.activeTab = "editor";
   renderStudio();
   remountStudioEditorIfNeeded();
+  updateRouteFromState();
   updateStudioAiSidebar();
 }
 
@@ -1501,6 +2081,10 @@ async function acceptStudioAiChange(filePath) {
       applyStudioCheckState(result.checkState);
     }
     state.studio.files = result.files ?? state.studio.files;
+    state.studio.directories = result.directories ?? state.studio.directories;
+    if (change.path === ".pressshipignore") {
+      await refreshStudioIgnoreState({ files: true, render: false });
+    }
     removeStudioAiChangedFile(change.path);
     if (state.studio.selectedFile?.path === change.path) {
       if (change.status === "deleted") {
@@ -1571,6 +2155,35 @@ function renderStudio() {
         ? "WordPress.org plugin"
         : "Choose a plugin from WordPress.org or Local Library.";
 
+  if (state.studio.loading && !state.studio.scope && state.studio.id) {
+    const fileLabel = state.studio.selectedFile?.path
+      ? `Restoring ${state.studio.selectedFile.path}.`
+      : "Restoring the workspace.";
+    els.studio.innerHTML = `
+      <div class="studio-root studio-empty-root">
+        <div class="studio-empty-state" aria-label="Opening Studio workspace">
+          <section class="studio-empty-copy">
+            <span class="studio-empty-kicker">
+              <span class="dashicons dashicons-editor-code" aria-hidden="true"></span>
+              Pressship Studio
+            </span>
+            <h1>Opening ${escapeHtml(title)}</h1>
+            <p class="studio-empty-subtitle">${escapeHtml(fileLabel)}</p>
+          </section>
+          <section class="studio-empty-panel" aria-label="Loading workspace">
+            ${loadingShell("Loading Studio workspace...")}
+          </section>
+          <div class="studio-empty-footer">
+            <span class="dashicons dashicons-update" aria-hidden="true"></span>
+            Matching the URL to a local or WordPress.org plugin.
+          </div>
+        </div>
+      </div>
+    `;
+    updateStudioControls();
+    return;
+  }
+
   if (!state.studio.id) {
     const pickerOptions = studioPickerOptions();
     const pickerDisabled = pickerOptions.length ? "" : "disabled";
@@ -1632,63 +2245,76 @@ function renderStudio() {
     return;
   }
 
-  const fileList = state.studio.files.length
-    ? renderStudioFileTree(buildStudioFileTree(state.studio.files))
+  const hasExplorerEntries = state.studio.files.length || state.studio.directories.length;
+  const fileList = hasExplorerEntries
+    ? renderStudioFileTree(buildStudioFileTree(state.studio.files, state.studio.directories))
     : `<p class="studio-muted">No editable text files found.</p>`;
-  const editorTabLabel = state.studio.selectedFile?.path ?? "Editor";
   const playgroundPort = state.studio.playgroundUrl ? new URL(state.studio.playgroundUrl).port : "";
+  const panels = normalizeStudioPanelState(state.studio.panels);
 
   els.studio.innerHTML = `
-    <div class="studio-root${state.studio.terminalOpen ? " has-terminal" : ""}">
+    <div class="studio-root${state.studio.terminalOpen ? " has-terminal" : ""}${panels.files ? " has-files" : " is-files-collapsed"}${panels.sidebar ? " has-secondary-sidebar" : " is-secondary-sidebar-collapsed"}" data-theme="${escapeAttr(studioTheme())}">
       <header class="studio-titlebar">
         <div class="studio-title">
           <strong>${escapeHtml(title)}</strong>
           <span>${escapeHtml(source)}</span>
         </div>
         <div class="studio-title-actions">
-          <button class="studio-icon-button" type="button" data-action="studio-toggle-terminal" aria-pressed="${state.studio.terminalOpen ? "true" : "false"}" title="${state.studio.terminalOpen ? "Hide terminal" : "Show terminal"}">
-            <span class="dashicons dashicons-editor-kitchensink" aria-hidden="true"></span>
-            <span>Terminal</span>
-          </button>
-          <button class="studio-action-button" type="button" data-action="studio-save" id="studio-save-button" disabled>
-            <span class="dashicons dashicons-saved" aria-hidden="true"></span>
-            Save
-          </button>
-          <button class="studio-action-button" type="button" data-action="studio-check" id="studio-check-button" disabled>
-            <span class="dashicons dashicons-yes-alt" aria-hidden="true"></span>
-            Check
-          </button>
-        </div>
-      </header>
-      <div class="studio-main">
-        <aside class="studio-files" aria-label="Plugin files">
-          <div class="studio-file-list">${fileList}</div>
-        </aside>
-        ${renderStudioResizer("files", "h", { label: "files panel" })}
-        <section class="studio-workbench" aria-label="Studio editor">
-          <div class="studio-tabs" aria-label="Studio tabs and Playground controls">
-            <div class="studio-tablist" role="tablist" aria-label="Studio tabs">
-              <button type="button" role="tab" aria-selected="${state.studio.activeTab === "editor" ? "true" : "false"}" class="studio-tab-button studio-editor-tab${state.studio.activeTab === "editor" ? " is-active" : ""}" data-action="studio-tab" data-tab="editor">
-                <span class="dashicons ${studioFileIcon(editorTabLabel)}" aria-hidden="true"></span>
-                <span>${escapeHtml(editorTabLabel)}</span>
-                ${state.studio.dirty ? `<em aria-label="Unsaved changes"></em>` : ""}
-              </button>
-              <button type="button" role="tab" aria-selected="${state.studio.activeTab === "home" ? "true" : "false"}" class="studio-tab-button studio-preview-tab${state.studio.activeTab === "home" ? " is-active" : ""}" data-action="studio-tab" data-tab="home">
-                <span class="dashicons dashicons-admin-home" aria-hidden="true"></span>
-                <span>Home</span>
-                ${playgroundPort ? `<small>${escapeHtml(`:${playgroundPort}`)}</small>` : ""}
-              </button>
-              <button type="button" role="tab" aria-selected="${state.studio.activeTab === "admin" ? "true" : "false"}" class="studio-tab-button studio-preview-tab${state.studio.activeTab === "admin" ? " is-active" : ""}" data-action="studio-tab" data-tab="admin">
-                <span class="dashicons dashicons-admin-site-alt3" aria-hidden="true"></span>
-                <span>WP Admin</span>
-                ${state.studio.playgroundUrl ? `<small>admin/password</small>` : ""}
-              </button>
-            </div>
+          <div class="studio-toolbar-group studio-toolbar-layout" aria-label="Workbench layout">
+            <button class="studio-layout-button${panels.files ? " is-active" : ""}" type="button" data-action="studio-toggle-files" aria-pressed="${panels.files ? "true" : "false"}" aria-label="${panels.files ? "Hide Explorer" : "Show Explorer"}" title="${panels.files ? "Hide Explorer" : "Show Explorer"}">
+              <span class="dashicons dashicons-align-left" aria-hidden="true"></span>
+            </button>
+            <button class="studio-icon-button studio-compact-button" type="button" data-action="studio-toggle-terminal" aria-pressed="${state.studio.terminalOpen ? "true" : "false"}" aria-label="${state.studio.terminalOpen ? "Hide Terminal" : "Show Terminal"}" title="${state.studio.terminalOpen ? "Hide Terminal" : "Show Terminal"}">
+              <span class="dashicons dashicons-editor-kitchensink" aria-hidden="true"></span>
+              <span>Terminal</span>
+            </button>
+            <button class="studio-layout-button${panels.sidebar ? " is-active" : ""}" type="button" data-action="studio-toggle-sidebar" aria-pressed="${panels.sidebar ? "true" : "false"}" aria-label="${panels.sidebar ? "Hide Secondary Side Bar" : "Show Secondary Side Bar"}" title="${panels.sidebar ? "Hide Secondary Side Bar" : "Show Secondary Side Bar"}">
+              <span class="dashicons dashicons-align-right" aria-hidden="true"></span>
+            </button>
+          </div>
+          <div class="studio-toolbar-group studio-toolbar-run" aria-label="Playground">
             ${renderStudioPlayButton()}
-            <span class="studio-preview-state${state.studio.running ? " is-loading" : state.studio.playgroundUrl ? " is-ready" : ""}">
+            <span class="studio-preview-state${state.studio.running ? " is-loading" : state.studio.playgroundUrl ? " is-ready" : ""}" title="${escapeAttr(studioPreviewStateTitle())}">
               <span aria-hidden="true"></span>
-              ${escapeHtml(studioPreviewStateLabel())}
+              <em>${escapeHtml(studioPreviewStateLabel())}</em>
             </span>
+          </div>
+          <div class="studio-toolbar-group studio-toolbar-actions" aria-label="Editor actions">
+            <button class="studio-action-button studio-compact-button" type="button" data-action="studio-save" id="studio-save-button" aria-label="${escapeAttr(`Save ${studioSaveShortcutLabel()}`)}" aria-keyshortcuts="${escapeAttr(studioSaveAriaShortcut())}" title="${escapeAttr(`Save ${studioSaveShortcutLabel()}`)}" disabled>
+              <span class="dashicons dashicons-saved" aria-hidden="true"></span>
+              <span>Save</span>
+            </button>
+            <button class="studio-action-button studio-compact-button" type="button" data-action="studio-check" id="studio-check-button" aria-label="Run Plugin Check" title="Run Plugin Check" disabled>
+              <span class="dashicons dashicons-yes-alt" aria-hidden="true"></span>
+              <span>Check</span>
+            </button>
+            ${renderStudioPackageSizeButton()}
+            ${renderStudioThemeToggle()}
+          </div>
+        </div>
+      </header>
+      <div class="studio-main">
+        ${renderStudioActivityBar(panels)}
+        ${
+          panels.files
+            ? `<aside class="studio-files" aria-label="Explorer">
+                <header class="studio-pane-header">
+                  <strong>Explorer</strong>
+                  <button class="studio-pane-action" type="button" data-action="studio-toggle-files" aria-label="Hide Explorer" title="Hide Explorer">
+                    <span class="dashicons dashicons-no-alt" aria-hidden="true"></span>
+                  </button>
+                </header>
+                <div class="studio-file-list">${fileList}</div>
+              </aside>
+              ${renderStudioResizer("files", "h", { label: "Explorer" })}`
+            : ""
+        }
+        <section class="studio-workbench" aria-label="Studio editor">
+          <div class="studio-tabs" aria-label="Studio tabs and Playground controls">
+            <div class="studio-tablist" role="tablist" aria-label="Studio tabs">
+              ${renderStudioPinnedPreviewTabs(playgroundPort)}
+              ${renderStudioFileTabs()}
+            </div>
             <span class="studio-tab-spacer"></span>
             <span id="studio-editor-status">${escapeHtml(studioEditorStatusLabel())}</span>
           </div>
@@ -1706,23 +2332,202 @@ function renderStudio() {
                   <div id="studio-terminal-output" class="studio-terminal-output">
                     ${renderStudioTerminal()}
                   </div>
-                </section>`
+            </section>`
               : ""
           }
         </section>
-        ${renderStudioResizer("ai", "h", { invert: true, label: "AI panel" })}
-        <aside class="studio-ai" id="studio-ai" aria-label="Studio AI chat">
-          ${renderStudioAiSidebar()}
-        </aside>
+        ${
+          panels.sidebar
+            ? `${renderStudioResizer("ai", "h", { invert: true, label: "Secondary Side Bar" })}
+              <aside class="studio-ai" id="studio-ai" aria-label="Secondary Side Bar">
+                ${renderStudioAiSidebar()}
+              </aside>`
+            : ""
+        }
       </div>
+      ${renderStudioStatusBar()}
       ${renderStudioPlaygroundVersionModal()}
     </div>
   `;
   applyStudioLayout(els.studio.querySelector(".studio-root"));
   bindStudioResizers();
+  scrollActiveStudioFileTabIntoView();
   updateStudioControls();
 }
 
+function renderStudioActivityBar(panels) {
+  const tab = state.studio.sidebarTab === "release" ? "release" : "ai";
+  const activityButton = ({ action, icon, label, active, tab: targetTab }) => `
+    <button class="studio-activity-button${active ? " is-active" : ""}" type="button" data-action="${escapeAttr(action)}"${targetTab ? ` data-tab="${escapeAttr(targetTab)}"` : ""} aria-pressed="${active ? "true" : "false"}" aria-label="${escapeAttr(label)}" title="${escapeAttr(label)}">
+      <span class="dashicons ${escapeAttr(icon)}" aria-hidden="true"></span>
+    </button>
+  `;
+
+  return `
+    <nav class="studio-activitybar" aria-label="Studio workbench views">
+      <div class="studio-activitybar-primary">
+        ${activityButton({
+          action: "studio-toggle-files",
+          icon: "dashicons-open-folder",
+          label: panels.files ? "Hide Explorer" : "Show Explorer",
+          active: panels.files
+        })}
+        ${activityButton({
+          action: "studio-tab",
+          icon: "dashicons-editor-code",
+          label: "Editor",
+          active: state.studio.activeTab === "editor",
+          tab: "editor"
+        })}
+        ${activityButton({
+          action: "studio-tab",
+          icon: "dashicons-admin-home",
+          label: "Playground Home",
+          active: state.studio.activeTab === "home",
+          tab: "home"
+        })}
+      </div>
+      <div class="studio-activitybar-secondary">
+        ${activityButton({
+          action: "studio-open-sidebar-tab",
+          icon: "dashicons-format-chat",
+          label: "AI Helper",
+          active: panels.sidebar && tab === "ai",
+          tab: "ai"
+        })}
+        ${activityButton({
+          action: "studio-open-sidebar-tab",
+          icon: "ps-icon-rocket",
+          label: "Release",
+          active: panels.sidebar && tab === "release",
+          tab: "release"
+        })}
+        ${activityButton({
+          action: "studio-toggle-terminal",
+          icon: "dashicons-editor-kitchensink",
+          label: state.studio.terminalOpen ? "Hide Terminal" : "Show Terminal",
+          active: state.studio.terminalOpen
+        })}
+      </div>
+    </nav>
+  `;
+}
+
+function renderStudioStatusBar() {
+  const plugin = state.studio.plugin;
+  const file = state.studio.selectedFile?.path ?? "No file selected";
+  const check = state.studio.checkSummary
+    ? `${state.studio.checkSummary.error || 0} errors, ${state.studio.checkSummary.warning || 0} warnings`
+    : "Plugin Check idle";
+  const assistant = selectedStudioAiAssistant();
+  return `
+    <footer class="studio-statusbar" aria-label="Studio status">
+      <span><span class="dashicons dashicons-admin-plugins" aria-hidden="true"></span>${escapeHtml(plugin?.slug ?? state.studio.id ?? "Studio")}</span>
+      <span>${escapeHtml(file)}</span>
+      <span>${escapeHtml(check)}</span>
+      <span class="studio-statusbar-spacer"></span>
+      <span>${escapeHtml(assistant === "none" ? "AI disabled" : assistantLabel(assistant))}</span>
+      <span>${escapeHtml(state.studio.readOnly ? "Read-only" : "Writable")}</span>
+    </footer>
+  `;
+}
+
+function renderStudioPinnedPreviewTabs(playgroundPort) {
+  return `
+    <span class="studio-pinned-tabs" aria-label="Pinned preview tabs">
+      <button type="button" role="tab" aria-selected="${state.studio.activeTab === "home" ? "true" : "false"}" class="studio-tab-button studio-tab-pinned studio-preview-tab${state.studio.activeTab === "home" ? " is-active" : ""}" data-action="studio-tab" data-tab="home" title="Home">
+        <span class="dashicons dashicons-admin-home" aria-hidden="true"></span>
+        <span>Home</span>
+        ${playgroundPort ? `<small>${escapeHtml(`:${playgroundPort}`)}</small>` : ""}
+      </button>
+      <button type="button" role="tab" aria-selected="${state.studio.activeTab === "admin" ? "true" : "false"}" class="studio-tab-button studio-tab-pinned studio-preview-tab${state.studio.activeTab === "admin" ? " is-active" : ""}" data-action="studio-tab" data-tab="admin" title="WP Admin">
+        <span class="dashicons dashicons-admin-site-alt3" aria-hidden="true"></span>
+        <span>WP Admin</span>
+        ${state.studio.playgroundUrl ? `<small>admin/password</small>` : ""}
+      </button>
+    </span>
+  `;
+}
+
+function renderStudioFileTabs() {
+  const openFiles = studioOpenFileTabs();
+  if (!openFiles.length) {
+    return `<span class="studio-file-tabs-empty">Open a file from Explorer</span>`;
+  }
+  return `
+    <span class="studio-file-tabs" aria-label="Open files">
+      ${openFiles.map((file) => renderStudioFileTab(file)).join("")}
+    </span>
+  `;
+}
+
+function studioOpenFileTabs() {
+  const knownFiles = new Map(state.studio.files.map((file) => [file.path, file]));
+  const selectedPath = state.studio.selectedFile?.path;
+  const paths = Array.isArray(state.studio.openFiles) ? [...state.studio.openFiles] : [];
+  if (selectedPath && !paths.includes(selectedPath)) {
+    paths.push(selectedPath);
+  }
+  state.studio.openFiles = paths;
+  return paths.map((path) => knownFiles.get(path) ?? {
+    path,
+    name: path.split("/").pop() ?? path,
+    directory: path.includes("/") ? path.split("/").slice(0, -1).join("/") : "",
+    size: 0
+  });
+}
+
+function renderStudioFileTab(file) {
+  const current = state.studio.activeTab === "editor" && file.path === state.studio.selectedFile?.path;
+  const dirty = current && state.studio.dirty;
+  return `
+    <span class="studio-file-tab-wrap">
+      <button type="button" role="tab" aria-selected="${current ? "true" : "false"}" class="studio-tab-button studio-editor-tab${current ? " is-active" : ""}" data-action="studio-file" data-path="${escapeAttr(file.path)}" title="${escapeAttr(file.path)}">
+        <span class="dashicons ${studioFileIcon(file.path)}" aria-hidden="true"></span>
+        <span>${escapeHtml(file.name ?? file.path)}</span>
+        ${dirty ? `<em aria-label="Unsaved changes"></em>` : ""}
+      </button>
+      <button type="button" class="studio-tab-close" data-action="studio-close-file-tab" data-path="${escapeAttr(file.path)}" aria-label="Close ${escapeAttr(file.name ?? file.path)}" title="Close">
+        <span class="dashicons dashicons-no-alt" aria-hidden="true"></span>
+      </button>
+    </span>
+  `;
+}
+
+function scrollActiveStudioFileTabIntoView() {
+  if (state.studio.activeTab !== "editor" || !state.studio.selectedFile?.path) {
+    return;
+  }
+  requestAnimationFrame(() => {
+    const container = document.querySelector(".studio-file-tabs");
+    if (!container) {
+      return;
+    }
+    const selectedPath = state.studio.selectedFile?.path;
+    const activeTab = Array.from(container.querySelectorAll(".studio-tab-button[data-path]")).find(
+      (button) => button.dataset.path === selectedPath
+    );
+    const target = activeTab?.closest(".studio-file-tab-wrap") ?? activeTab;
+    if (!target) {
+      return;
+    }
+
+    const padding = 12;
+    const containerRect = container.getBoundingClientRect();
+    const targetRect = target.getBoundingClientRect();
+    const targetLeft = targetRect.left - containerRect.left + container.scrollLeft;
+    const targetRight = targetLeft + targetRect.width;
+    const visibleLeft = container.scrollLeft;
+    const visibleRight = visibleLeft + container.clientWidth;
+
+    if (targetLeft < visibleLeft + padding) {
+      container.scrollLeft = Math.max(0, targetLeft - padding);
+    } else if (targetRight > visibleRight - padding) {
+      container.scrollLeft = targetRight - container.clientWidth + padding;
+    }
+  });
+}
+
 function renderStudioPlaygroundVersionModal() {
   const modal = state.studio.playgroundVersionModal;
   if (!modal) {
@@ -1879,14 +2684,101 @@ function renderStudioPlayButton() {
   `;
 }
 
+function studioSaveShortcutLabel() {
+  return isMac ? "(⌘S)" : "(Ctrl+S)";
+}
+
+function studioSaveAriaShortcut() {
+  return isMac ? "Meta+S" : "Control+S";
+}
+
+function renderStudioPackageSizeButton() {
+  if (state.studio.scope !== "local") {
+    return "";
+  }
+  const packageSize = state.studio.packageSize ?? createInitialStudioPackageSize();
+  const hasSize = Number.isFinite(packageSize.sizeBytes);
+  const label = packageSize.loading
+    ? "Sizing"
+    : hasSize
+      ? formatStudioBytes(packageSize.sizeBytes)
+      : "Size";
+  const icon = packageSize.loading
+    ? "dashicons-update"
+    : packageSize.error
+      ? "dashicons-warning"
+      : "dashicons-archive";
+  const className = [
+    "studio-action-button",
+    "studio-compact-button",
+    "studio-package-size-button",
+    packageSize.loading ? "is-loading" : "",
+    packageSize.overLimit ? "is-over-limit" : "",
+    packageSize.stale ? "is-stale" : "",
+    packageSize.error ? "has-error" : ""
+  ].filter(Boolean).join(" ");
+
+  return `
+    <button class="${escapeAttr(className)}" type="button" data-action="studio-package-size" id="studio-package-size-button" title="${escapeAttr(studioPackageSizeTitle(packageSize))}" ${packageSize.loading ? "disabled aria-busy=\"true\"" : ""}>
+      <span class="dashicons ${escapeAttr(icon)}" aria-hidden="true"></span>
+      <span>${escapeHtml(label)}</span>
+    </button>
+  `;
+}
+
+function studioPackageSizeTitle(packageSize) {
+  if (packageSize.loading) {
+    return "Calculating package size";
+  }
+  if (packageSize.error) {
+    return `Package size failed: ${packageSize.error}`;
+  }
+  if (!Number.isFinite(packageSize.sizeBytes)) {
+    return "Calculate package size";
+  }
+  const limit = formatStudioBytes(packageSize.maxSizeBytes || 10 * 1024 * 1024);
+  const status = packageSize.overLimit ? `Over the ${limit} WordPress.org limit` : `Under the ${limit} WordPress.org limit`;
+  const stale = packageSize.stale ? " Stale: recalculate after recent file or ignore changes." : "";
+  const largest = (packageSize.largestFiles ?? []).slice(0, 3);
+  const largestText = largest.length
+    ? ` Largest: ${largest.map((file) => `${file.path} (${formatStudioBytes(file.sizeBytes)})`).join(", ")}.`
+    : "";
+  return `${formatStudioBytes(packageSize.sizeBytes)} across ${packageSize.fileCount ?? 0} packaged files. ${status}.${largestText}${stale}`;
+}
+
+function renderStudioThemeToggle() {
+  const theme = studioTheme();
+  const isLight = theme === "light";
+  const nextTheme = isLight ? "dark" : "light";
+  return `
+    <button class="studio-theme-switch" type="button" role="switch" aria-checked="${isLight ? "true" : "false"}" data-action="studio-toggle-theme" title="${escapeAttr(`Switch to ${nextTheme} mode`)}">
+      <span class="dashicons dashicons-admin-appearance" aria-hidden="true"></span>
+      <span class="studio-theme-switch-track" aria-hidden="true">
+        <span></span>
+      </span>
+      <span class="studio-theme-switch-label">${escapeHtml(isLight ? "Light" : "Dark")}</span>
+    </button>
+  `;
+}
+
 function studioPreviewStateLabel() {
+  if (state.studio.running) {
+    return "Starting";
+  }
+  if (state.studio.playgroundUrl) {
+    return "Ready";
+  }
+  return "Idle";
+}
+
+function studioPreviewStateTitle() {
   if (state.studio.running) {
     return "Starting Playground";
   }
   if (state.studio.playgroundUrl) {
     return "Playground ready";
   }
-  return "Not started";
+  return "Playground not started";
 }
 
 function studioEditorStatusLabel() {
@@ -1906,10 +2798,62 @@ function switchStudioTab(tab) {
   if (!["editor", "home", "admin"].includes(tab)) {
     return;
   }
-  captureStudioEditorValue();
+  const discardingDirtyEditor =
+    state.studio.activeTab === "editor" &&
+    tab !== "editor" &&
+    state.studio.dirty;
+  if (discardingDirtyEditor) {
+    if (!confirm("Discard unsaved changes in the current file?")) {
+      return;
+    }
+    state.studio.draftContent = state.studio.fileContent;
+    state.studio.dirty = false;
+  } else {
+    captureStudioEditorValue();
+  }
   state.studio.activeTab = tab;
   renderStudio();
   remountStudioEditorIfNeeded();
+  updateRouteFromState();
+}
+
+async function closeStudioFileTab(relativePath) {
+  if (!relativePath) {
+    return;
+  }
+  const openFiles = Array.isArray(state.studio.openFiles) ? state.studio.openFiles : [];
+  const index = openFiles.indexOf(relativePath);
+  if (index === -1) {
+    return;
+  }
+  const isCurrent = relativePath === state.studio.selectedFile?.path;
+  if (isCurrent && state.studio.dirty && !confirm("Discard unsaved changes in the current file?")) {
+    return;
+  }
+
+  captureStudioEditorValue();
+  const nextOpenFiles = openFiles.filter((path) => path !== relativePath);
+  state.studio.openFiles = nextOpenFiles;
+
+  if (!isCurrent) {
+    renderStudio();
+    remountStudioEditorIfNeeded();
+    return;
+  }
+
+  state.studio.dirty = false;
+  const nextPath = nextOpenFiles[Math.min(index, nextOpenFiles.length - 1)];
+  if (nextPath) {
+    await selectStudioFile(nextPath, { force: true });
+    return;
+  }
+
+  state.studio.selectedFile = null;
+  state.studio.fileContent = "";
+  state.studio.draftContent = "";
+  state.studio.activeTab = "home";
+  renderStudio();
+  updateRouteFromState();
 }
 
 function toggleStudioTerminal() {
@@ -1919,22 +2863,166 @@ function toggleStudioTerminal() {
   remountStudioEditorIfNeeded();
 }
 
-function toggleStudioFolder(folderPath) {
+function toggleStudioPanel(panel) {
+  if (!["files", "sidebar"].includes(panel)) {
+    return;
+  }
+  captureStudioEditorValue();
+  state.studio.panels = normalizeStudioPanelState(state.studio.panels);
+  state.studio.panels[panel] = !state.studio.panels[panel];
+  saveStudioPanelState(state.studio.panels);
+  renderStudio();
+  remountStudioEditorIfNeeded();
+  requestAnimationFrame(() => state.studio.editor?.layout?.());
+}
+
+function openStudioSidebarTab(tab) {
+  captureStudioEditorValue();
+  state.studio.panels = normalizeStudioPanelState(state.studio.panels);
+  state.studio.panels.sidebar = true;
+  saveStudioPanelState(state.studio.panels);
+  setStudioSidebarTab(tab);
+  renderStudio();
+  remountStudioEditorIfNeeded();
+  requestAnimationFrame(() => state.studio.editor?.layout?.());
+}
+
+function toggleStudioTheme() {
+  captureStudioEditorValue();
+  state.studio.theme = studioTheme() === "light" ? "dark" : "light";
+  saveStudioTheme(state.studio.theme);
+  renderStudio();
+  remountStudioEditorIfNeeded();
+  requestAnimationFrame(() => state.studio.editor?.layout?.());
+}
+
+async function toggleStudioFolder(folderPath) {
   if (!folderPath) {
     return;
   }
+  const normalized = String(folderPath ?? "").replace(/\/+$/, "");
   captureStudioEditorValue();
-  if (state.studio.collapsedFolders.has(folderPath)) {
-    state.studio.collapsedFolders.delete(folderPath);
+  const directory = state.studio.directories?.find((entry) => entry.path === normalized);
+  if (directory?.deferred) {
+    const loaded = await loadStudioDirectory(normalized);
+    if (!loaded) {
+      renderStudio();
+      remountStudioEditorIfNeeded();
+      return;
+    }
+    if (studioFolderIsIgnored(normalized)) {
+      state.studio.expandedIgnoredFolders.add(normalized);
+    } else {
+      state.studio.collapsedFolders.delete(normalized);
+    }
+    renderStudio();
+    remountStudioEditorIfNeeded();
+    return;
+  }
+
+  if (studioFolderIsIgnored(normalized)) {
+    if (state.studio.expandedIgnoredFolders.has(normalized)) {
+      state.studio.expandedIgnoredFolders.delete(normalized);
+    } else {
+      state.studio.expandedIgnoredFolders.add(normalized);
+    }
+    renderStudio();
+    remountStudioEditorIfNeeded();
+    return;
+  }
+
+  if (state.studio.collapsedFolders.has(normalized)) {
+    state.studio.collapsedFolders.delete(normalized);
   } else {
-    state.studio.collapsedFolders.add(folderPath);
+    state.studio.collapsedFolders.add(normalized);
   }
   renderStudio();
   remountStudioEditorIfNeeded();
 }
 
-function buildStudioFileTree(files) {
+async function loadStudioDirectory(folderPath) {
+  const normalized = String(folderPath ?? "").replace(/^\.\/+/, "").replace(/\/+$/, "");
+  if (!normalized || state.studio.scope !== "local" || !state.studio.id) {
+    return false;
+  }
+  if (state.studio.loadingFolders.has(normalized)) {
+    return false;
+  }
+
+  state.studio.loadingFolders.add(normalized);
+  renderStudio();
+  remountStudioEditorIfNeeded();
+  try {
+    const result = await api(
+      `/api/plugins/local/${encodeURIComponent(state.studio.id)}/files/directory?path=${encodeURIComponent(normalized)}`
+    );
+    mergeStudioExplorerEntries(result.files ?? [], result.directories ?? []);
+    const directory = state.studio.directories.find((entry) => entry.path === normalized);
+    if (directory) {
+      directory.deferred = false;
+    }
+    return true;
+  } catch (error) {
+    appendStudioTerminal(`Folder load failed for ${normalized}: ${error.message}`, "error");
+    notice(error.message, "error");
+    return false;
+  } finally {
+    state.studio.loadingFolders.delete(normalized);
+  }
+}
+
+function mergeStudioExplorerEntries(files, directories) {
+  state.studio.files = mergeStudioEntriesByPath(state.studio.files, files);
+  state.studio.directories = mergeStudioEntriesByPath(state.studio.directories, directories);
+}
+
+function mergeStudioEntriesByPath(existingEntries = [], incomingEntries = []) {
+  const merged = new Map((existingEntries ?? []).map((entry) => [entry.path, entry]));
+  for (const entry of incomingEntries ?? []) {
+    if (!entry?.path) {
+      continue;
+    }
+    merged.set(entry.path, {
+      ...(merged.get(entry.path) ?? {}),
+      ...entry
+    });
+  }
+  return Array.from(merged.values());
+}
+
+function studioFolderIsIgnored(folderPath) {
+  const normalized = String(folderPath ?? "").replace(/\/+$/, "");
+  if (!normalized) {
+    return false;
+  }
+  const directory = state.studio.directories?.find((entry) => entry.path === normalized);
+  return Boolean(directory?.ignored || studioIgnoredFilesForPrefix(normalized).length);
+}
+
+function buildStudioFileTree(files, directories = []) {
   const root = { type: "folder", name: "", path: "", children: new Map() };
+  for (const directory of directories) {
+    const parts = directory.path.split("/").filter(Boolean);
+    let node = root;
+    let currentPath = "";
+    parts.forEach((part) => {
+      currentPath = currentPath ? `${currentPath}/${part}` : part;
+      if (!node.children.has(part)) {
+        node.children.set(part, {
+          type: "folder",
+          name: part,
+          path: currentPath,
+          children: new Map()
+        });
+      }
+      node = node.children.get(part);
+    });
+    node.deferred = Boolean(directory.deferred);
+    node.ignored = Boolean(directory.ignored);
+    node.ignoredBy = directory.ignoredBy ?? "";
+    node.hardIgnored = Boolean(directory.hardIgnored);
+  }
+
   for (const file of files) {
     const parts = file.path.split("/").filter(Boolean);
     let node = root;
@@ -1978,19 +3066,48 @@ function renderStudioTreeChildren(children, depth) {
 
 function renderStudioTreeNode(node, depth) {
   if (node.type === "folder") {
-    const collapsed = state.studio.collapsedFolders.has(node.path);
+    const deferred = Boolean(node.deferred);
+    const loadingFolder = state.studio.loadingFolders?.has(node.path);
+    const nodeIgnored = Boolean(node.ignored);
     const containsCurrent = Boolean(
       state.studio.selectedFile?.path && state.studio.selectedFile.path.startsWith(`${node.path}/`)
     );
     const containsAiChange = studioAiChangedFilesForPrefix(node.path).length > 0;
+    const ignoredCount = studioIgnoredFilesForPrefix(node.path).length;
+    const ignoredFolder = nodeIgnored || ignoredCount > 0;
+    const collapsed = deferred ||
+      (ignoredFolder && !state.studio.expandedIgnoredFolders.has(node.path)) ||
+      state.studio.collapsedFolders.has(node.path);
+    const ignorePattern = studioFolderIgnorePattern(node.path);
+    const hasExactIgnore = studioHasIgnorePattern(ignorePattern);
+    const busy = state.studio.ignoreBusyPattern === ignorePattern;
+    const ignoredTitle = node.ignoredBy
+      ? `Ignored by ${node.ignoredBy}`
+      : ignoredCount
+        ? `${ignoredCount} ignored file${ignoredCount === 1 ? "" : "s"} inside`
+        : "Ignored";
     return `
-      <div class="studio-tree-folder${containsCurrent ? " has-current" : ""}${containsAiChange ? " has-ai-changes" : ""}" role="treeitem" aria-expanded="${collapsed ? "false" : "true"}">
-        <button type="button" class="studio-tree-row studio-tree-folder-row" data-action="studio-toggle-folder" data-folder="${escapeAttr(node.path)}" style="--depth:${depth}">
-          <span class="dashicons ${collapsed ? "dashicons-arrow-right-alt2" : "dashicons-arrow-down-alt2"} studio-tree-arrow" aria-hidden="true"></span>
-          <span class="dashicons ${collapsed ? "dashicons-category" : "dashicons-open-folder"} studio-tree-icon" aria-hidden="true"></span>
-          <span class="studio-tree-label">${escapeHtml(node.name)}</span>
-          ${containsAiChange ? `<span class="studio-tree-ai-badge" title="AI patches inside this folder">AI</span>` : ""}
-        </button>
+      <div class="studio-tree-folder${containsCurrent ? " has-current" : ""}${containsAiChange ? " has-ai-changes" : ""}${ignoredFolder ? " is-ignored" : ""}" role="treeitem" aria-expanded="${collapsed ? "false" : "true"}">
+        <div class="studio-tree-row studio-tree-folder-row${ignoredFolder ? " has-ignored" : ""}${loadingFolder ? " is-loading" : ""}" style="--depth:${depth}">
+          <button type="button" class="studio-tree-main" data-action="studio-toggle-folder" data-folder="${escapeAttr(node.path)}" ${loadingFolder ? "aria-busy=\"true\"" : ""}>
+            <span class="dashicons ${loadingFolder ? "dashicons-update" : collapsed ? "dashicons-arrow-right-alt2" : "dashicons-arrow-down-alt2"} studio-tree-arrow" aria-hidden="true"></span>
+            <span class="dashicons ${deferred || collapsed ? "dashicons-category" : "dashicons-open-folder"} studio-tree-icon" aria-hidden="true"></span>
+            <span class="studio-tree-label">${escapeHtml(node.name)}</span>
+          </button>
+          <span class="studio-tree-badges">
+            ${containsAiChange ? `<span class="studio-tree-ai-badge" title="AI patches inside this folder">AI</span>` : ""}
+          </span>
+          ${node.hardIgnored || (nodeIgnored && !hasExactIgnore)
+            ? renderStudioReadonlyIgnoreAction(node.ignoredBy ?? ignoredTitle)
+            : renderStudioIgnoreAction({
+                action: hasExactIgnore ? "studio-unignore-rule" : "studio-ignore-folder",
+                label: hasExactIgnore ? "Unignore folder" : "Ignore folder",
+                icon: hasExactIgnore ? "dashicons-hidden" : "dashicons-visibility",
+                path: node.path,
+                pattern: ignorePattern,
+                busy
+              })}
+        </div>
         ${collapsed ? "" : `<div role="group">${renderStudioTreeChildren(node.children, depth + 1)}</div>`}
       </div>
     `;
@@ -1999,6 +3116,12 @@ function renderStudioTreeNode(node, depth) {
   const current = node.path === state.studio.selectedFile?.path;
   const checkCounts = studioCheckCountsForPath(node.path);
   const aiChange = studioAiChangedFile(node.path);
+  const ignored = Boolean(node.file?.ignored);
+  const ignoredBy = node.file?.ignoredBy;
+  const hardIgnored = Boolean(node.file?.hardIgnored);
+  const exactPattern = studioFileIgnorePattern(node.path);
+  const hasExactIgnore = studioHasIgnorePattern(exactPattern);
+  const busy = state.studio.ignoreBusyPattern === exactPattern;
   const checkBadge = checkCounts.total
     ? `<span class="studio-tree-check-badge${checkCounts.error ? " has-errors" : ""}" title="${escapeAttr(formatCheckCounts(checkCounts))}">${escapeHtml(String(checkCounts.total))}</span>`
     : "";
@@ -2006,11 +3129,43 @@ function renderStudioTreeNode(node, depth) {
     ? `<span class="studio-tree-ai-badge" title="${escapeAttr(`AI proposed ${aiChange.status} patch`)}">AI</span>`
     : "";
   return `
-    <button type="button" role="treeitem" class="studio-tree-row studio-tree-file-row${current ? " is-current" : ""}${checkCounts.error ? " has-check-errors" : ""}${aiChange ? " has-ai-changes" : ""}" data-action="studio-file" data-path="${escapeAttr(node.path)}" style="--depth:${depth}">
-      <span class="studio-tree-indent" aria-hidden="true"></span>
-      <span class="dashicons ${studioFileIcon(node.path)} studio-tree-icon" aria-hidden="true"></span>
-      <span class="studio-tree-label">${escapeHtml(node.name)}</span>
+    <div role="treeitem" class="studio-tree-row studio-tree-file-row${current ? " is-current" : ""}${checkCounts.error ? " has-check-errors" : ""}${aiChange ? " has-ai-changes" : ""}${ignored ? " is-ignored" : ""}" style="--depth:${depth}">
+      <button type="button" class="studio-tree-main" data-action="studio-file" data-path="${escapeAttr(node.path)}">
+        <span class="studio-tree-indent" aria-hidden="true"></span>
+        <span class="dashicons ${studioFileIcon(node.path)} studio-tree-icon" aria-hidden="true"></span>
+        <span class="studio-tree-label">${escapeHtml(node.name)}</span>
+      </button>
       <span class="studio-tree-badges">${aiBadge}${checkBadge}</span>
+      ${hardIgnored || (ignored && !hasExactIgnore)
+        ? renderStudioReadonlyIgnoreAction(ignoredBy ?? "Pressship package rules")
+        : renderStudioIgnoreAction({
+            action: hasExactIgnore ? "studio-unignore-rule" : "studio-ignore-file",
+            label: hasExactIgnore ? "Unignore file" : "Ignore file",
+            icon: hasExactIgnore ? "dashicons-hidden" : "dashicons-visibility",
+            path: node.path,
+            pattern: exactPattern,
+            busy
+          })}
+    </div>
+  `;
+}
+
+function renderStudioReadonlyIgnoreAction(reason) {
+  const title = reason ? `Ignored by ${reason}` : "Ignored";
+  return `
+    <span class="studio-tree-action is-readonly" title="${escapeAttr(title)}" aria-label="${escapeAttr(title)}">
+      <span class="dashicons dashicons-hidden" aria-hidden="true"></span>
+    </span>
+  `;
+}
+
+function renderStudioIgnoreAction({ action, label, icon, path, pattern, busy }) {
+  if (!pattern || path === ".pressshipignore" || state.studio.scope !== "local") {
+    return "";
+  }
+  return `
+    <button type="button" class="studio-tree-action${busy ? " is-busy" : ""}" data-action="${escapeAttr(action)}" data-path="${escapeAttr(path ?? "")}" data-pattern="${escapeAttr(pattern)}" title="${escapeAttr(label)}" aria-label="${escapeAttr(label)}" ${busy ? "disabled aria-busy=\"true\"" : ""}>
+      <span class="dashicons ${busy ? "dashicons-update" : icon}" aria-hidden="true"></span>
     </button>
   `;
 }
@@ -2027,13 +3182,19 @@ function renderStudioAiSidebar() {
 
 function renderStudioSidebarTabs(activeTab) {
   return `
+    <header class="studio-secondary-header">
+      <strong>${activeTab === "release" ? "Release" : "AI Helper"}</strong>
+      <button class="studio-pane-action" type="button" data-action="studio-toggle-sidebar" aria-label="Hide Secondary Side Bar" title="Hide Secondary Side Bar">
+        <span class="dashicons dashicons-no-alt" aria-hidden="true"></span>
+      </button>
+    </header>
     <div class="studio-sidebar-tabs ps-segmented" role="tablist" aria-label="Studio sidebar">
       <button class="ps-segmented-option${activeTab === "ai" ? " is-active" : ""}" type="button" role="tab" aria-selected="${activeTab === "ai"}" data-action="studio-sidebar-tab" data-tab="ai">
         <span class="dashicons dashicons-format-chat" aria-hidden="true"></span>
         AI Helper
       </button>
       <button class="ps-segmented-option${activeTab === "release" ? " is-active" : ""}" type="button" role="tab" aria-selected="${activeTab === "release"}" data-action="studio-sidebar-tab" data-tab="release">
-        <span class="dashicons dashicons-update" aria-hidden="true"></span>
+        <span class="dashicons ps-icon-rocket" aria-hidden="true"></span>
         Release
       </button>
     </div>
@@ -2245,7 +3406,7 @@ function renderStudioAiMessages() {
                   <span>${escapeHtml(aiMessageRoleLabel(message))}</span>
                   <time>${escapeHtml(formatTime(message.createdAt))}</time>
                 </header>
-                <p>${escapeHtml(message.text)}</p>
+                <div class="studio-ai-markdown">${renderStudioAiMarkdown(message.text)}</div>
               </div>
             </article>
           `
@@ -2623,69 +3784,479 @@ function appendStudioTerminal(message, tone = "muted") {
   }
 }
 
-function selectedStudioAiAssistant() {
-  return state.settings?.aiAssistant ?? "none";
+function appendStudioCliCommand(command) {
+  if (state.activeView !== "studio" || !command || !Array.isArray(state.studio.terminal)) {
+    return;
+  }
+  state.studio.terminalOpen = true;
+  appendStudioTerminal(`$ ${command}`, "command");
+}
+
+function quoteCliArg(value) {
+  const text = String(value ?? "").trim();
+  if (!text) {
+    return "''";
+  }
+  return /^[A-Za-z0-9_@%+=:,./-]+$/.test(text)
+    ? text
+    : `'${text.replace(/'/g, "'\\''")}'`;
+}
+
+function studioCliCommand(parts) {
+  return [STUDIO_CLI_PREFIX, ...parts].filter(Boolean).join(" ");
+}
+
+function studioOpenCliCommand() {
+  const parts = ["studio"];
+  const host = window.location.hostname;
+  const port = window.location.port;
+  if (host && !["127.0.0.1", "localhost"].includes(host)) {
+    parts.push("--host", quoteCliArg(host));
+  }
+  if (port && port !== "9477") {
+    parts.push("--port", quoteCliArg(port));
+  }
+  return studioCliCommand(parts);
+}
+
+function localPluginForCli(localId = state.studio.id) {
+  return state.local.find((plugin) => plugin.id === localId) ??
+    (state.studio.scope === "local" && state.studio.id === localId ? state.studio.plugin : null);
+}
+
+function localPluginCliTarget(localId = state.studio.id) {
+  const plugin = localPluginForCli(localId);
+  return quoteCliArg(plugin?.path || plugin?.slug || localId || ".");
+}
+
+function studioCliIgnoreFlags(localId = state.studio.id) {
+  if (localId !== state.studio.id) {
+    return [];
+  }
+  return studioIgnorePatterns().flatMap((pattern) => ["--ignore", quoteCliArg(pattern)]);
+}
+
+function studioPublishCliCommand(localId, action, options = {}) {
+  const normalizedAction = ["submit", "release"].includes(action) ? action : "auto";
+  const parts = ["publish", localPluginCliTarget(localId)];
+  if (normalizedAction !== "auto") {
+    parts.push(`--${normalizedAction}`);
+  }
+  if (options.dryRun) {
+    parts.push("--dry-run");
+  }
+  parts.push(...studioCliIgnoreFlags(localId), "--yes");
+  return studioCliCommand(parts);
+}
+
+function studioPlaygroundCliCommand(input) {
+  const target = input.scope === "local" ? localPluginCliTarget(input.id) : quoteCliArg(input.id);
+  const settings = state.settings ?? {};
+  const parts = ["demo", target, "--reset", "--skip-browser"];
+  if (input.wpVersion && input.wpVersion !== "latest") {
+    parts.push("--wp", quoteCliArg(input.wpVersion));
+  }
+  if (settings.playgroundDatabaseMode && settings.playgroundDatabaseMode !== "auto") {
+    parts.push("--database", quoteCliArg(settings.playgroundDatabaseMode));
+  }
+  if (settings.playgroundDatabaseMode === "mysql") {
+    parts.push(
+      "--mysql-host",
+      quoteCliArg(settings.playgroundMysqlHost ?? "127.0.0.1"),
+      "--mysql-port",
+      quoteCliArg(settings.playgroundMysqlPort ?? 3306),
+      "--mysql-user",
+      quoteCliArg(settings.playgroundMysqlUser ?? "root"),
+      "--mysql-database-prefix",
+      quoteCliArg(settings.playgroundMysqlDatabasePrefix ?? "pressship_playground")
+    );
+    if (settings.playgroundMysqlPassword) {
+      parts.push("--mysql-password", quoteCliArg(settings.playgroundMysqlPassword));
+    }
+  }
+  return studioCliCommand(parts);
+}
+
+function studioCliCommandForJob(input) {
+  if (state.activeView !== "studio") {
+    return "";
+  }
+  switch (input?.type) {
+    case "clone": {
+      const parts = ["get", quoteCliArg(input.slug)];
+      if (input.destination) {
+        parts.push(quoteCliArg(input.destination));
+      }
+      return studioCliCommand(parts);
+    }
+    case "play":
+      return studioPlaygroundCliCommand(input);
+    case "check":
+      return studioCliCommand([
+        "verify",
+        localPluginCliTarget(input.localId),
+        "--skip-readme-validator",
+        ...studioCliIgnoreFlags(input.localId)
+      ]);
+    case "dry-run-publish":
+      return studioPublishCliCommand(input.localId, input.action, { dryRun: true });
+    case "confirm-publish": {
+      const dryRun = state.studio.release?.dryRun;
+      if (!dryRun?.approvalId || dryRun.approvalId !== input.approvalId) {
+        return "";
+      }
+      const action = dryRun?.route?.action ?? "auto";
+      return state.studio.id ? studioPublishCliCommand(state.studio.id, action) : "";
+    }
+    default:
+      return "";
+  }
+}
+
+function selectedStudioAiAssistant() {
+  return state.settings?.aiAssistant ?? "none";
+}
+
+function assistantLabel(id) {
+  const provider = aiAssistanceProviders().find((item) => item.id === id);
+  if (provider) {
+    return provider.label;
+  }
+
+  const labels = {
+    none: "AI",
+    claude: "Claude Code",
+    codex: "Codex CLI",
+    copilot: "GitHub Copilot CLI",
+    cursor: "Cursor",
+    gemini: "Gemini CLI",
+    opencode: "OpenCode",
+    "wp-studio": "WP Studio"
+  };
+  return labels[id] ?? capitalize(String(id));
+}
+
+function aiMessageRoleLabel(message) {
+  if (message.role === "user") return "You";
+  if (message.role === "assistant") return assistantLabel(message.assistant ?? state.studio.aiActiveAssistant ?? selectedStudioAiAssistant());
+  return "Studio";
+}
+
+function canRunStudioAi() {
+  return (
+    state.studio.scope === "local" &&
+    Boolean(state.studio.id) &&
+    !state.studio.loading &&
+    !state.studio.aiRunning &&
+    selectedStudioAiAssistant() !== "none"
+  );
+}
+
+function studioAiDisabledReason() {
+  if (state.studio.scope !== "local") {
+    return "Open a local plugin to use AI.";
+  }
+  if (selectedStudioAiAssistant() === "none") {
+    return "Select AI Assistance in Settings.";
+  }
+  if (state.studio.aiRunning) {
+    return "";
+  }
+  return "";
+}
+
+function applyStudioCheckState(checkState) {
+  if (!checkState) {
+    state.studio.checkFindings = [];
+    state.studio.checkSummary = null;
+    state.studio.checkRanAt = null;
+    return;
+  }
+
+  state.studio.checkFindings = checkState.findings ?? [];
+  state.studio.checkSummary = checkState.summary ?? null;
+  state.studio.checkRanAt = checkState.checkedAt ?? null;
+}
+
+function applyStudioIgnoreState(ignoreState) {
+  state.studio.ignoreState = {
+    ...createInitialStudioIgnoreState(),
+    ...(ignoreState ?? {})
+  };
+}
+
+function applyStudioPackageSize(packageSize) {
+  if (packageSize?.status === "calculating") {
+    state.studio.packageSize = {
+      ...(state.studio.packageSize ?? createInitialStudioPackageSize()),
+      loading: true,
+      error: "",
+      stale: false
+    };
+    scheduleStudioPackageSizePoll();
+    return;
+  }
+  if (packageSize?.status === "error") {
+    state.studio.packageSize = {
+      ...(state.studio.packageSize ?? createInitialStudioPackageSize()),
+      loading: false,
+      error: packageSize.error ?? "Package size could not be calculated.",
+      calculatedAt: packageSize.calculatedAt ?? new Date().toISOString(),
+      stale: false
+    };
+    return;
+  }
+
+  state.studio.packageSize = {
+    ...createInitialStudioPackageSize(),
+    ...(packageSize ?? {}),
+    loading: false,
+    error: "",
+    calculatedAt: packageSize?.calculatedAt ?? new Date().toISOString(),
+    stale: false
+  };
+}
+
+function markStudioPackageSizeStale() {
+  const packageSize = state.studio.packageSize;
+  if (!packageSize || !packageSize.calculatedAt) {
+    return;
+  }
+  state.studio.packageSize = {
+    ...packageSize,
+    stale: true
+  };
+}
+
+async function refreshStudioPackageSize(options = {}) {
+  if (state.studio.scope !== "local" || !state.studio.id) {
+    return;
+  }
+  if (state.studio.packageSize?.loading && !options.poll) {
+    return;
+  }
+  if (!options.force && state.studio.packageSize?.calculatedAt) {
+    return;
+  }
+
+  const localId = state.studio.id;
+  if (options.notify) {
+    appendStudioCliCommand(studioCliCommand([
+      "pack",
+      localPluginCliTarget(localId),
+      "--no-verify",
+      ...studioCliIgnoreFlags(localId),
+      "--json"
+    ]));
+  }
+  state.studio.packageSize = {
+    ...(state.studio.packageSize ?? createInitialStudioPackageSize()),
+    loading: true,
+    error: ""
+  };
+  if (options.render !== false) {
+    renderStudio();
+    remountStudioEditorIfNeeded();
+  }
+
+  try {
+    const packageSize = await api(`/api/plugins/local/${encodeURIComponent(localId)}/package-size`);
+    if (state.studio.id !== localId) {
+      return;
+    }
+    applyStudioPackageSize(packageSize);
+    if (options.notify && packageSize.status !== "calculating") {
+      if (packageSize.status === "error") {
+        notice(packageSize.error ?? "Package size could not be calculated.", "error");
+      } else {
+        notice(
+          packageSize.overLimit
+            ? `Package is ${formatStudioBytes(packageSize.sizeBytes)}, over the WordPress.org 10 MB limit.`
+            : `Package is ${formatStudioBytes(packageSize.sizeBytes)}.`,
+          packageSize.overLimit ? "warning" : "success"
+        );
+      }
+    }
+  } catch (error) {
+    if (state.studio.id !== localId) {
+      return;
+    }
+    state.studio.packageSize = {
+      ...(state.studio.packageSize ?? createInitialStudioPackageSize()),
+      loading: false,
+      error: error.message
+    };
+    if (options.notify) {
+      notice(error.message, "error");
+    }
+  } finally {
+    if (state.studio.id === localId && options.render !== false) {
+      renderStudio();
+      remountStudioEditorIfNeeded();
+      updateStudioControls();
+    }
+  }
+}
+
+function scheduleStudioPackageSizePoll() {
+  if (studioPackageSizePollTimer) {
+    return;
+  }
+  studioPackageSizePollTimer = window.setTimeout(() => {
+    studioPackageSizePollTimer = null;
+    void refreshStudioPackageSize({ force: true, render: true, poll: true });
+  }, 1200);
+}
+
+async function refreshStudioIgnoreState(options = {}) {
+  if (state.studio.scope !== "local" || !state.studio.id) {
+    return;
+  }
+
+  const localId = state.studio.id;
+  state.studio.ignoreLoading = true;
+  state.studio.ignoreError = "";
+  if (options.render !== false) {
+    updateStudioSidebar();
+  }
+  try {
+    const requests = [
+      api(`/api/plugins/local/${encodeURIComponent(localId)}/ignore-state`)
+    ];
+    if (options.files) {
+      requests.push(api(`/api/plugins/local/${encodeURIComponent(localId)}/files`));
+    }
+    const [ignoreState, filesResult] = await Promise.all(requests);
+    applyStudioIgnoreState(ignoreState);
+    if (filesResult) {
+        state.studio.files = filesResult.files ?? state.studio.files;
+        state.studio.directories = filesResult.directories ?? state.studio.directories;
+    }
+  } catch (error) {
+    state.studio.ignoreError = error.message;
+  } finally {
+    state.studio.ignoreLoading = false;
+    state.studio.ignoreBusyPattern = "";
+    state.studio.ignoreBusyPath = "";
+    if (options.render !== false) {
+      renderStudio();
+      remountStudioEditorIfNeeded();
+      updateStudioSidebar();
+      updateStudioControls();
+    }
+  }
+}
+
+function studioIgnorePatterns() {
+  return state.studio.ignoreState?.patterns ?? [];
+}
+
+function studioHasIgnorePattern(pattern) {
+  return studioIgnorePatterns().includes(pattern);
+}
+
+function studioFileIgnorePattern(filePath) {
+  return String(filePath ?? "").replace(/^\.\/+/, "");
+}
+
+function studioFolderIgnorePattern(folderPath) {
+  const normalized = String(folderPath ?? "").replace(/^\.\/+/, "").replace(/\/+$/, "");
+  return normalized ? `${normalized}/**` : "";
 }
 
-function assistantLabel(id) {
-  const provider = aiAssistanceProviders().find((item) => item.id === id);
-  if (provider) {
-    return provider.label;
+function studioIgnoredFilesForPrefix(prefix) {
+  const normalized = String(prefix ?? "").replace(/\/+$/, "");
+  if (!normalized) {
+    return [];
   }
 
-  const labels = {
-    none: "AI",
-    claude: "Claude Code",
-    codex: "Codex CLI",
-    copilot: "GitHub Copilot CLI",
-    cursor: "Cursor",
-    gemini: "Gemini CLI",
-    opencode: "OpenCode",
-    "wp-studio": "WP Studio"
+  const files = [];
+  const seen = new Set();
+  const addFile = (file) => {
+    const filePath = String(file?.path ?? "");
+    if (!filePath || seen.has(filePath)) {
+      return;
+    }
+    if (filePath === normalized || filePath.startsWith(`${normalized}/`)) {
+      seen.add(filePath);
+      files.push(file);
+    }
   };
-  return labels[id] ?? capitalize(String(id));
-}
 
-function aiMessageRoleLabel(message) {
-  if (message.role === "user") return "You";
-  if (message.role === "assistant") return assistantLabel(message.assistant ?? state.studio.aiActiveAssistant ?? selectedStudioAiAssistant());
-  return "Studio";
-}
+  for (const file of state.studio.ignoreState?.ignoredFiles ?? []) {
+    addFile(file);
+  }
+  for (const file of state.studio.files ?? []) {
+    if (file?.ignored) {
+      addFile(file);
+    }
+  }
 
-function canRunStudioAi() {
-  return (
-    state.studio.scope === "local" &&
-    Boolean(state.studio.id) &&
-    !state.studio.loading &&
-    !state.studio.aiRunning &&
-    selectedStudioAiAssistant() !== "none"
-  );
+  return files;
 }
 
-function studioAiDisabledReason() {
-  if (state.studio.scope !== "local") {
-    return "Open a local plugin to use AI.";
-  }
-  if (selectedStudioAiAssistant() === "none") {
-    return "Select AI Assistance in Settings.";
+async function addStudioIgnoreRule(pattern, options = {}) {
+  if (!pattern || state.studio.scope !== "local" || !state.studio.id) {
+    return;
   }
-  if (state.studio.aiRunning) {
-    return "";
+
+  state.studio.ignoreBusyPattern = pattern;
+  state.studio.ignoreBusyPath = options.path ?? "";
+  updateStudioSidebar();
+  try {
+    const ignoreState = await api(`/api/plugins/local/${encodeURIComponent(state.studio.id)}/ignore-rules`, {
+      method: "POST",
+      body: { pattern }
+    });
+    applyStudioIgnoreState(ignoreState);
+    markStudioPackageSizeStale();
+    await refreshStudioIgnoreState({ files: true, render: false });
+    if (state.studio.selectedFile?.path === ".pressshipignore") {
+      await syncSelectedStudioFileFromDisk({ reason: "ignore-rule", reportErrors: true });
+    }
+    appendStudioTerminal(`Ignored ${options.label ?? pattern}.`, "success");
+  } catch (error) {
+    appendStudioTerminal(error.message, "error");
+    notice(error.message, "error");
+  } finally {
+    state.studio.ignoreBusyPattern = "";
+    state.studio.ignoreBusyPath = "";
+    renderStudio();
+    remountStudioEditorIfNeeded();
+    updateStudioSidebar();
+    updateStudioControls();
   }
-  return "";
 }
 
-function applyStudioCheckState(checkState) {
-  if (!checkState) {
-    state.studio.checkFindings = [];
-    state.studio.checkSummary = null;
-    state.studio.checkRanAt = null;
+async function removeStudioIgnoreRule(pattern) {
+  if (!pattern || state.studio.scope !== "local" || !state.studio.id) {
     return;
   }
 
-  state.studio.checkFindings = checkState.findings ?? [];
-  state.studio.checkSummary = checkState.summary ?? null;
-  state.studio.checkRanAt = checkState.checkedAt ?? null;
+  state.studio.ignoreBusyPattern = pattern;
+  updateStudioSidebar();
+  try {
+    const ignoreState = await api(`/api/plugins/local/${encodeURIComponent(state.studio.id)}/ignore-rules`, {
+      method: "DELETE",
+      body: { pattern }
+    });
+    applyStudioIgnoreState(ignoreState);
+    markStudioPackageSizeStale();
+    await refreshStudioIgnoreState({ files: true, render: false });
+    if (state.studio.selectedFile?.path === ".pressshipignore") {
+      await syncSelectedStudioFileFromDisk({ reason: "ignore-rule", reportErrors: true });
+    }
+    appendStudioTerminal(`Removed ignore rule ${pattern}.`, "success");
+  } catch (error) {
+    appendStudioTerminal(error.message, "error");
+    notice(error.message, "error");
+  } finally {
+    state.studio.ignoreBusyPattern = "";
+    renderStudio();
+    remountStudioEditorIfNeeded();
+    updateStudioSidebar();
+    updateStudioControls();
+  }
 }
 
 function appendStudioAiMessage(role, text, tone = "muted") {
@@ -2711,7 +4282,7 @@ function appendStudioAiOutput(text, tone = "log") {
   }
   last.text = `${last.text}${output}`;
   last.tone = tone === "error" ? "error" : last.tone === "status" ? "log" : last.tone;
-  updateStudioAiSidebar();
+  updateStudioAiMessageList();
 }
 
 function updateStudioAiSidebar() {
@@ -2723,11 +4294,40 @@ function updateStudioAiSidebar() {
   node.innerHTML = renderStudioAiSidebar();
   const messages = document.getElementById("studio-ai-messages");
   if (messages) {
-    messages.scrollTop = messages.scrollHeight;
+    scrollStudioAiMessagesToBottom(messages);
+  }
+  updateStudioAiControls();
+}
+
+function updateStudioAiMessageList(options = {}) {
+  const messages = document.getElementById("studio-ai-messages");
+  if (!messages) {
+    updateStudioAiSidebar();
+    return;
+  }
+
+  const shouldStick = options.forceScroll || isStudioAiMessagesNearBottom(messages);
+  messages.innerHTML = renderStudioAiMessages();
+  if (shouldStick) {
+    scrollStudioAiMessagesToBottom(messages);
   }
   updateStudioAiControls();
 }
 
+function isStudioAiMessagesNearBottom(messages) {
+  return messages.scrollHeight - messages.scrollTop - messages.clientHeight < 80;
+}
+
+function scrollStudioAiMessagesToBottom(messages) {
+  const previousScrollBehavior = messages.style.scrollBehavior;
+  messages.style.scrollBehavior = "auto";
+  messages.scrollTop = messages.scrollHeight;
+  requestAnimationFrame(() => {
+    messages.scrollTop = messages.scrollHeight;
+    messages.style.scrollBehavior = previousScrollBehavior;
+  });
+}
+
 function updateStudioAiControls() {
   const prompt = document.getElementById("studio-ai-prompt");
   const send = document.getElementById("studio-ai-send-button");
@@ -2994,6 +4594,16 @@ function chooseInitialStudioFile(files, slug) {
   );
 }
 
+function canSaveStudioFile() {
+  return Boolean(
+    state.studio.scope === "local" &&
+      state.studio.id &&
+      !state.studio.readOnly &&
+      state.studio.selectedFile &&
+      state.studio.dirty
+  );
+}
+
 function updateStudioControls() {
   const canRun = Boolean(state.studio.id) && !state.studio.loading && !state.studio.running;
   const canCheck =
@@ -3015,12 +4625,17 @@ function updateStudioControls() {
   }
   if (studioCheck) {
     studioCheck.disabled = !canCheck;
+    studioCheck.setAttribute("aria-label", state.studio.checkSummary ? "Re-run Plugin Check" : "Run Plugin Check");
+    studioCheck.title = state.studio.checkSummary ? "Re-run Plugin Check" : "Run Plugin Check";
     studioCheck.innerHTML = state.studio.checking
-      ? `<span class="dashicons dashicons-update" aria-hidden="true"></span> Checking…`
-      : `<span class="dashicons dashicons-yes-alt" aria-hidden="true"></span> ${state.studio.checkSummary ? "Re-check" : "Check"}`;
+      ? `<span class="dashicons dashicons-update" aria-hidden="true"></span><span>Checking</span>`
+      : `<span class="dashicons dashicons-yes-alt" aria-hidden="true"></span><span>${state.studio.checkSummary ? "Re-check" : "Check"}</span>`;
   }
   if (studioSave) {
-    studioSave.disabled = state.studio.readOnly || !state.studio.selectedFile || !state.studio.dirty;
+    studioSave.disabled = !canSaveStudioFile();
+    studioSave.title = `Save ${studioSaveShortcutLabel()}`;
+    studioSave.setAttribute("aria-label", `Save ${studioSaveShortcutLabel()}`);
+    studioSave.setAttribute("aria-keyshortcuts", studioSaveAriaShortcut());
   }
   updateStudioAiControls();
 }
@@ -3078,7 +4693,7 @@ async function mountStudioEditor(content) {
       );
       state.studio.editorModels = [originalModel, modifiedModel];
       state.studio.editor = monaco.editor.createDiffEditor(container, {
-        theme: "vs-dark",
+        theme: studioMonacoTheme(),
         readOnly: true,
         automaticLayout: true,
         minimap: { enabled: false },
@@ -3101,7 +4716,7 @@ async function mountStudioEditor(content) {
     state.studio.editor = monaco.editor.create(container, {
       value: content,
       language: languageForPath(state.studio.selectedFile?.path ?? ""),
-      theme: "vs-dark",
+      theme: studioMonacoTheme(),
       readOnly: state.studio.readOnly,
       automaticLayout: true,
       minimap: { enabled: false },
@@ -3112,6 +4727,11 @@ async function mountStudioEditor(content) {
       scrollBeyondLastLine: false
     });
     state.studio.editorKind = "monaco";
+    state.studio.editor.addCommand(monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyS, () => {
+      if (canSaveStudioFile()) {
+        void saveStudioFile();
+      }
+    });
     state.studio.editor.onDidChangeModelContent(() => {
       state.studio.draftContent = getStudioEditorValue();
       state.studio.dirty = state.studio.draftContent !== state.studio.fileContent;
@@ -3323,6 +4943,7 @@ function getStudioEditorValue() {
 
 function ensureMonaco() {
   if (window.monaco) {
+    configurePressshipMonaco(window.monaco);
     return Promise.resolve(window.monaco);
   }
   if (monacoPromise) {
@@ -3338,7 +4959,10 @@ function ensureMonaco() {
           vs: "https://cdn.jsdelivr.net/npm/monaco-editor@0.55.1/min/vs"
         }
       });
-      window.require(["vs/editor/editor.main"], () => resolve(window.monaco), reject);
+      window.require(["vs/editor/editor.main"], () => {
+        configurePressshipMonaco(window.monaco);
+        resolve(window.monaco);
+      }, reject);
     };
     script.onerror = () => reject(new Error("Could not load Monaco Editor."));
     document.head.appendChild(script);
@@ -3347,7 +4971,132 @@ function ensureMonaco() {
   return monacoPromise;
 }
 
+function configurePressshipMonaco(monaco) {
+  if (!monaco || monacoConfigured) {
+    return;
+  }
+  monacoConfigured = true;
+  registerWordPressReadmeLanguage(monaco);
+  definePressshipMonacoThemes(monaco);
+}
+
+function registerWordPressReadmeLanguage(monaco) {
+  const languageId = "wordpress-readme";
+  if (!monaco.languages.getLanguages().some((language) => language.id === languageId)) {
+    monaco.languages.register({
+      id: languageId,
+      aliases: ["WordPress Readme", "wordpress-readme"],
+      extensions: [".txt"],
+      filenames: ["readme.txt"]
+    });
+  }
+
+  monaco.languages.setLanguageConfiguration(languageId, {
+    brackets: [
+      ["[", "]"],
+      ["(", ")"],
+      ["`", "`"]
+    ],
+    autoClosingPairs: [
+      { open: "`", close: "`" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" }
+    ],
+    surroundingPairs: [
+      { open: "`", close: "`" },
+      { open: "*", close: "*" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" }
+    ],
+    wordPattern: /(-?\d+(?:\.\d+)*)|([^\s`~!@#$%^&*()=+[{\]}\\|;:'",.<>/?]+)/g
+  });
+
+  monaco.languages.setMonarchTokensProvider(languageId, {
+    defaultToken: "wp-readme.text",
+    tokenizer: {
+      root: [
+        [/^\s*={3}\s*.*?\s*={3}\s*$/, "wp-readme.title"],
+        [/^\s*={2}\s*.*?\s*={2}\s*$/, "wp-readme.section"],
+        [/^\s*=\s*.*?\s*=\s*$/, "wp-readme.subsection"],
+        [/^(\s*)([*+-])(\s+)/, ["wp-readme.whitespace", "wp-readme.listMarker", "wp-readme.whitespace"]],
+        [/^(\s*)(\d+\.)(\s+)/, ["wp-readme.whitespace", "wp-readme.listMarker", "wp-readme.whitespace"]],
+        [/^\s{4,}.*$/, "wp-readme.codeBlock"],
+        [/^\t.*$/, "wp-readme.codeBlock"],
+        [/^(\s*>)(.*)$/, ["wp-readme.quote", "wp-readme.quote"]],
+        [/^([A-Za-z][A-Za-z0-9 /.-]*)(:)(.*)$/, ["wp-readme.field", "wp-readme.delimiter", "wp-readme.fieldValue"]],
+        [/\[[^\]\n]+\]:\s*(?:https?:\/\/|mailto:|#)[^\s]+/, "wp-readme.link"],
+        [/\[[^\]\n]+\]\([^)]+\)/, "wp-readme.link"],
+        [/(?:https?:\/\/|mailto:)[^\s)]+/, "wp-readme.url"],
+        [/\b(?:pressship|npx|wp|svn|npm|composer)\s+[^\n`]+/, "wp-readme.command"],
+        [/`[^`\n]+`/, "wp-readme.inlineCode"],
+        [/\*\*[^*\n][\s\S]*?\*\*/, "wp-readme.strong"],
+        [/\*[^*\s\n][^*\n]*\*/, "wp-readme.emphasis"],
+        [/\[(?:youtube|vimeo|wpvideo|playlist|audio|video)\b[^\]\n]*\]/i, "wp-readme.shortcode"],
+        [/[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/, "wp-readme.url"]
+      ]
+    }
+  });
+}
+
+function definePressshipMonacoThemes(monaco) {
+  monaco.editor.defineTheme("pressship-studio-dark", {
+    base: "vs-dark",
+    inherit: true,
+    rules: [
+      { token: "wp-readme.title", foreground: "f8fafc", fontStyle: "bold" },
+      { token: "wp-readme.section", foreground: "7dd3fc", fontStyle: "bold" },
+      { token: "wp-readme.subsection", foreground: "fbbf24", fontStyle: "bold" },
+      { token: "wp-readme.field", foreground: "f78c6c", fontStyle: "bold" },
+      { token: "wp-readme.fieldValue", foreground: "cbd5e1" },
+      { token: "wp-readme.delimiter", foreground: "94a3b8" },
+      { token: "wp-readme.listMarker", foreground: "a78bfa", fontStyle: "bold" },
+      { token: "wp-readme.inlineCode", foreground: "c4b5fd" },
+      { token: "wp-readme.codeBlock", foreground: "a7f3d0" },
+      { token: "wp-readme.link", foreground: "93c5fd", fontStyle: "underline" },
+      { token: "wp-readme.url", foreground: "67e8f9", fontStyle: "underline" },
+      { token: "wp-readme.command", foreground: "fde68a" },
+      { token: "wp-readme.shortcode", foreground: "f9a8d4" },
+      { token: "wp-readme.quote", foreground: "9ca3af", fontStyle: "italic" },
+      { token: "wp-readme.strong", foreground: "f8fafc", fontStyle: "bold" },
+      { token: "wp-readme.emphasis", foreground: "e5e7eb", fontStyle: "italic" }
+    ],
+    colors: {
+      "editor.background": "#1e1e1e"
+    }
+  });
+
+  monaco.editor.defineTheme("pressship-studio-light", {
+    base: "vs",
+    inherit: true,
+    rules: [
+      { token: "wp-readme.title", foreground: "1d4ed8", fontStyle: "bold" },
+      { token: "wp-readme.section", foreground: "0f766e", fontStyle: "bold" },
+      { token: "wp-readme.subsection", foreground: "b45309", fontStyle: "bold" },
+      { token: "wp-readme.field", foreground: "be123c", fontStyle: "bold" },
+      { token: "wp-readme.fieldValue", foreground: "334155" },
+      { token: "wp-readme.delimiter", foreground: "64748b" },
+      { token: "wp-readme.listMarker", foreground: "7c3aed", fontStyle: "bold" },
+      { token: "wp-readme.inlineCode", foreground: "6d28d9" },
+      { token: "wp-readme.codeBlock", foreground: "047857" },
+      { token: "wp-readme.link", foreground: "0969da", fontStyle: "underline" },
+      { token: "wp-readme.url", foreground: "0284c7", fontStyle: "underline" },
+      { token: "wp-readme.command", foreground: "92400e" },
+      { token: "wp-readme.shortcode", foreground: "be185d" },
+      { token: "wp-readme.quote", foreground: "6b7280", fontStyle: "italic" },
+      { token: "wp-readme.strong", foreground: "111827", fontStyle: "bold" },
+      { token: "wp-readme.emphasis", foreground: "374151", fontStyle: "italic" }
+    ],
+    colors: {
+      "editor.background": "#ffffff"
+    }
+  });
+}
+
 function languageForPath(filePath) {
+  const fileName = String(filePath ?? "").split("/").pop()?.toLowerCase();
+  if (fileName === "readme.txt") {
+    return "wordpress-readme";
+  }
   const ext = filePath.split(".").pop()?.toLowerCase();
   const map = {
     css: "css",
@@ -3900,7 +5649,7 @@ function localCard(plugin, versionState) {
               Details
             </button>
             <button type="button" role="menuitem" data-action="manage-release" data-id="${escapeAttr(plugin.id)}">
-              <span class="dashicons dashicons-update" aria-hidden="true"></span>
+              <span class="dashicons ps-icon-rocket" aria-hidden="true"></span>
               Manage release
             </button>
             <button type="button" role="menuitem" data-action="version-state" data-id="${escapeAttr(plugin.id)}">
@@ -3936,7 +5685,7 @@ function localCard(plugin, versionState) {
           Open in Studio
         </button>
         <button type="button" class="ps-plugin-card-secondary" data-action="manage-release" data-id="${escapeAttr(plugin.id)}" ${missing ? "disabled" : ""}>
-          <span class="dashicons dashicons-update" aria-hidden="true"></span>
+          <span class="dashicons ps-icon-rocket" aria-hidden="true"></span>
           Manage release
         </button>
       </footer>
@@ -3949,6 +5698,12 @@ function localCard(plugin, versionState) {
  * =================================================================== */
 
 async function showDetails(scope, id) {
+  if (state.activeView === "studio") {
+    appendStudioCliCommand(studioCliCommand([
+      "info",
+      scope === "local" ? localPluginCliTarget(id) : quoteCliArg(id)
+    ]));
+  }
   els.detail.classList.add("is-open");
   els.detail.setAttribute("aria-hidden", "false");
   els.detail.innerHTML = `
@@ -4051,6 +5806,7 @@ function closeDetail() {
  * =================================================================== */
 
 async function createJob(body) {
+  appendStudioCliCommand(studioCliCommandForJob(body));
   const job = await api("/api/jobs", { method: "POST", body });
   upsertJob(job);
   subscribeJob(job.id);
@@ -4784,36 +6540,35 @@ function configureAutoRefresh() {
  * View switching with view-transitions
  * =================================================================== */
 
-function showView(view) {
-  if (state.activeView === view) {
-    return;
+function showView(view, options = {}) {
+  const nextView = normalizeViewId(view);
+  if (state.activeView === nextView) {
+    if (options.updateRoute !== false) {
+      updateRouteFromState({ replace: options.replaceRoute });
+    }
+    return Promise.resolve();
   }
   const apply = () => {
-    state.activeView = view;
-    document.body.dataset.activeView = view;
-    document.querySelectorAll(".view").forEach((node) => node.classList.remove("is-active"));
-    document.getElementById(`view-${view}`)?.classList.add("is-active");
-    document
-      .querySelectorAll("#adminmenu li")
-      .forEach((node) => node.classList.remove("wp-has-current-submenu"));
-    document
-      .querySelector(`#adminmenu li[data-view="${view}"]`)
-      ?.classList.add("wp-has-current-submenu");
+    applyActiveViewShell(nextView);
     closeDetail();
-    if (view === "release") {
+    if (nextView === "release") {
       if (!state.releaseBoard.loading && !state.releaseBoard.plugins.length) {
         void loadReleaseBoard();
       } else {
         renderReleaseBoard();
       }
     }
+    if (options.updateRoute !== false) {
+      updateRouteFromState({ replace: options.replaceRoute });
+    }
   };
 
   if (typeof document.startViewTransition === "function") {
-    document.startViewTransition(apply);
-  } else {
-    apply();
+    const transition = document.startViewTransition(apply);
+    return transition.updateCallbackDone?.catch(() => {}) ?? Promise.resolve();
   }
+  apply();
+  return Promise.resolve();
 }
 
 /* ===================================================================
@@ -4854,7 +6609,7 @@ function commandItems() {
       id: "view:release",
       title: "Go to Release Management",
       subtitle: "Release status for every local plugin",
-      icon: "dashicons-update",
+      icon: "ps-icon-rocket",
       run: () => showView("release")
     },
     {
@@ -4914,7 +6669,7 @@ function commandItems() {
       id: `release:${plugin.id}`,
       title: `Manage release • ${plugin.name}`,
       subtitle: plugin.slug,
-      icon: "dashicons-update",
+      icon: "ps-icon-rocket",
       run: () => {
         void openStudio("local", plugin.id, { sidebarTab: "release" });
       }
@@ -5215,6 +6970,16 @@ function renderStudioAiMarkdown(value) {
   }
 }
 
+function refreshStudioAiMarkdownIfReady() {
+  try {
+    if ((state.studio.aiMessages ?? []).some((message) => message.role === "assistant")) {
+      updateStudioAiMessageList();
+    }
+  } catch {
+    // The markdown parser can finish loading before Studio state exists.
+  }
+}
+
 function basicMarkdownToHtml(value) {
   const lines = String(value ?? "").replace(/\r\n?/g, "\n").split("\n");
   const blocks = [];
@@ -5460,6 +7225,22 @@ function isSafeMarkdownHref(value) {
   }
 }
 
+function formatStudioBytes(bytes) {
+  const value = Number(bytes);
+  if (!Number.isFinite(value) || value < 0) {
+    return "0 B";
+  }
+  const units = ["B", "KB", "MB", "GB"];
+  let size = value;
+  let unitIndex = 0;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex += 1;
+  }
+  const precision = unitIndex === 0 || size >= 10 ? 0 : 1;
+  return `${size.toFixed(precision)} ${units[unitIndex]}`;
+}
+
 function escapeHtml(value) {
   return String(value)
     .replaceAll("&", "&amp;")
@@ -5572,7 +7353,7 @@ function renderReleaseBoard() {
     els.release.innerHTML = emptyState({
       title: "No local plugins to release.",
       message: "Add a plugin folder to your Local Library, then come back here.",
-      icon: "dashicons-update"
+      icon: "ps-icon-rocket"
     });
     return;
   }
@@ -5581,7 +7362,7 @@ function renderReleaseBoard() {
   els.release.innerHTML = `
     <div class="ps-card-toolbar" role="region" aria-label="Release board summary">
       <span class="ps-card-toolbar-count">
-        <span class="dashicons dashicons-update" aria-hidden="true"></span>
+        <span class="dashicons ps-icon-rocket" aria-hidden="true"></span>
         ${escapeHtml(
           `${state.releaseBoard.plugins.length} plugin${state.releaseBoard.plugins.length === 1 ? "" : "s"} tracked`
         )}
@@ -5624,7 +7405,7 @@ function releaseBoardCard(entry) {
         : ""}
       <footer class="ps-release-board-card-footer">
         <button type="button" class="button button-primary" data-action="manage-release" data-id="${escapeAttr(entry.id)}" ${entry.exists === false ? "disabled" : ""}>
-          <span class="dashicons dashicons-update" aria-hidden="true"></span>
+          <span class="dashicons ps-icon-rocket" aria-hidden="true"></span>
           Manage release
         </button>
         <button type="button" class="ps-plugin-card-secondary" data-action="version-state" data-id="${escapeAttr(entry.id)}" ${entry.exists === false ? "disabled" : ""}>
@@ -5649,15 +7430,15 @@ function studioPluginKey() {
 
 function setStudioSidebarTab(tab) {
   const next = tab === "release" ? "release" : "ai";
-  if (state.studio.sidebarTab === next) {
-    return;
-  }
   state.studio.sidebarTab = next;
   saveStudioSidebarTab(studioPluginKey(), next);
   updateStudioSidebar();
   if (next === "release" && state.studio.scope === "local" && !state.studio.release.tags) {
     void loadStudioReleaseTags();
   }
+  if (next === "release" && state.studio.scope === "local") {
+    void refreshStudioIgnoreState({ files: true });
+  }
 }
 
 function updateStudioSidebar() {
@@ -5682,7 +7463,7 @@ function renderStudioReleasePane() {
     return `
       <div class="studio-release-pane">
         <div class="studio-release-empty">
-          <span class="dashicons dashicons-update" aria-hidden="true"></span>
+          <span class="dashicons ps-icon-rocket" aria-hidden="true"></span>
           <strong>Release management is local-only</strong>
           <p>Open a local plugin to manage its release lifecycle.</p>
         </div>
@@ -5693,7 +7474,7 @@ function renderStudioReleasePane() {
     return `
       <div class="studio-release-pane">
         <div class="studio-release-empty">
-          <span class="dashicons dashicons-update" aria-hidden="true"></span>
+          <span class="dashicons ps-icon-rocket" aria-hidden="true"></span>
           <strong>Open a plugin to start</strong>
         </div>
       </div>
@@ -5715,8 +7496,9 @@ function renderStudioReleasePane() {
       </header>
       <ol class="ps-release-funnel">
         ${renderStudioReleaseStepVersion(versionState, release)}
-        ${renderStudioReleaseStepTags(release)}
+        ${renderStudioReleaseStepTags(versionState, release)}
         ${renderStudioReleaseStepValidate(versionState, release)}
+        ${renderStudioReleaseStepIgnored()}
         ${renderStudioReleaseStepPublish(versionState, release)}
       </ol>
     </div>
@@ -5739,6 +7521,16 @@ function renderStudioReleaseStepShell(number, title, summary, body) {
   `;
 }
 
+function toggleStudioReleaseIgnored() {
+  state.studio.release = {
+    ...state.studio.release,
+    ignoredCollapsed: !(state.studio.release?.ignoredCollapsed ?? true)
+  };
+  renderStudio();
+  remountStudioEditorIfNeeded();
+  updateStudioControls();
+}
+
 function renderStudioReleaseStepVersion(versionState, release) {
   const localVersion = versionState?.localVersion ?? "—";
   const stable = versionState?.readmeStableTag ?? "—";
@@ -5793,7 +7585,11 @@ function renderStudioReleaseStepVersion(versionState, release) {
   return renderStudioReleaseStepShell(1, "Version state", summary, body);
 }
 
-function renderStudioReleaseStepTags(release) {
+function releaseTagDraftValue(versionState, release) {
+  return release.newTagDraft || versionState?.localVersion || "";
+}
+
+function renderStudioReleaseStepTags(versionState, release) {
   let body;
   if (release.tagsLoading && !release.tags) {
     body = loadingShell("Reading SVN tags…");
@@ -5814,22 +7610,31 @@ function renderStudioReleaseStepTags(release) {
     const tagRows = (list.tags ?? [])
       .map((tag) => renderStudioReleaseTagRow(tag))
       .join("");
+    const newTagValue = releaseTagDraftValue(versionState, release);
+    const currentVersionTag = versionState?.localVersion
+      ? (list.tags ?? []).find((tag) => tag.name === versionState.localVersion)
+      : null;
+    const newTagControl = currentVersionTag
+      ? currentVersionTag.isUncommitted
+        ? `<p class="ps-release-tag-ready"><span class="dashicons dashicons-yes-alt" aria-hidden="true"></span>${escapeHtml(`Tag ${versionState.localVersion} is ready. Run a dry-run release next.`)}</p>`
+        : `<p class="ps-release-tag-ready is-blocked"><span class="dashicons dashicons-warning" aria-hidden="true"></span>${escapeHtml(`Tag ${versionState.localVersion} already exists on WordPress.org SVN. Bump the version before creating a new tag.`)}</p>`
+      : `<div class="ps-release-step-newtag">
+          <label>
+            <span>Create tag from current version</span>
+            <input type="text" id="studio-release-new-tag" value="${escapeAttr(newTagValue)}" placeholder="1.2.3" />
+          </label>
+          <button class="button button-secondary" type="button" data-action="studio-release-create">
+            <span class="dashicons dashicons-plus-alt2" aria-hidden="true"></span>
+            Create tag
+          </button>
+        </div>`;
     body = `
       <ul class="ps-release-tag-list">
         ${trunkRow}
         ${tagRows || `<li class="ps-release-tag-empty">No tags yet.</li>`}
       </ul>
       ${renderStudioReleaseSwitchConflict(release)}
-      <div class="ps-release-step-newtag">
-        <label>
-          <span>Create tag from current version</span>
-          <input type="text" id="studio-release-new-tag" value="${escapeAttr(release.newTagDraft ?? "")}" placeholder="1.2.3" />
-        </label>
-        <button class="button button-secondary" type="button" data-action="studio-release-create">
-          <span class="dashicons dashicons-plus-alt2" aria-hidden="true"></span>
-          Create tag
-        </button>
-      </div>
+      ${newTagControl}
       ${release.newTagError ? `<p class="ps-release-inline-error"><span class="dashicons dashicons-warning" aria-hidden="true"></span>${escapeHtml(release.newTagError)}</p>` : ""}
     `;
   }
@@ -5881,9 +7686,11 @@ function renderStudioReleaseTagRow(tag) {
   const switchingLabel = release.switchingResolution === "override" || release.switchingResolution === "revert"
     ? "Resolving"
     : "Switching";
-  const switchButton = tag.isCurrent
-    ? ""
-    : `<button class="button button-small" type="button" data-action="studio-release-switch" data-tag="${escapeAttr(tag.name)}" ${anySwitching ? "disabled aria-disabled=\"true\"" : ""}>${switching ? `<span class="dashicons dashicons-update" aria-hidden="true"></span>${switchingLabel}` : "Switch"}</button>`;
+  const switchButton = tag.isUncommitted
+    ? `<span class="ps-release-tag-local-note" title="This tag exists locally and will be published by the release step.">Ready for release</span>`
+    : tag.isCurrent
+      ? ""
+      : `<button class="button button-small" type="button" data-action="studio-release-switch" data-tag="${escapeAttr(tag.name)}" ${anySwitching ? "disabled aria-disabled=\"true\"" : ""}>${switching ? `<span class="dashicons dashicons-update" aria-hidden="true"></span>${switchingLabel}` : "Switch"}</button>`;
   const confirmKey = `delete-tag:${tag.name}`;
   const pendingConfirm = state.studio.pendingConfirms?.get(confirmKey);
   const deleteButton = tag.isUncommitted
@@ -5939,6 +7746,183 @@ function renderStudioReleaseStepValidate(versionState, release) {
   return renderStudioReleaseStepShell(3, "Validate", summaryLine, body);
 }
 
+function renderStudioReleaseStepIgnored() {
+  const ignoreState = state.studio.ignoreState ?? createInitialStudioIgnoreState();
+  const patterns = ignoreState.patterns ?? [];
+  const ignoredFiles = ignoreState.ignoredFiles ?? [];
+  const collapsed = state.studio.release?.ignoredCollapsed ?? true;
+  const summary = patterns.length
+    ? `${patterns.length} pattern${patterns.length === 1 ? "" : "s"} · ${ignoredFiles.length} file${ignoredFiles.length === 1 ? "" : "s"}`
+    : "No project ignore rules yet.";
+
+  let body;
+  if (state.studio.ignoreLoading) {
+    body = loadingShell("Reading ignored files…");
+  } else if (state.studio.ignoreError) {
+    body = `<p class="ps-release-step-error">${escapeHtml(state.studio.ignoreError)}</p>`;
+  } else if (!patterns.length) {
+    body = `<p class="ps-release-step-muted">No project ignore rules yet.</p>`;
+  } else {
+    body = `
+      <ul class="ps-release-ignore-patterns">
+        ${patterns.map((pattern) => renderStudioIgnorePatternRow(pattern)).join("")}
+      </ul>
+      ${ignoredFiles.length
+        ? `<ul class="ps-release-ignored-files">
+            ${ignoredFiles.slice(0, 8).map((file) => `
+              <li>
+                <span class="dashicons ${studioFileIcon(file.path)}" aria-hidden="true"></span>
+                <span title="${escapeAttr(file.path)}">${escapeHtml(file.path)}</span>
+                <small>${escapeHtml(file.ignoredBy ?? "")}</small>
+              </li>
+            `).join("")}
+          </ul>
+          ${ignoredFiles.length > 8 ? `<p class="ps-release-step-muted">${escapeHtml(`${ignoredFiles.length - 8} more ignored file${ignoredFiles.length - 8 === 1 ? "" : "s"}.`)}</p>` : ""}`
+        : `<p class="ps-release-step-muted">The patterns do not match any visible project files.</p>`}
+    `;
+  }
+
+  return `
+    <li class="ps-release-step ps-release-step-collapsible${collapsed ? " is-collapsed" : ""}">
+      <span class="ps-release-step-connector" aria-hidden="true"></span>
+      <header class="ps-release-step-header">
+        <button class="ps-release-step-toggle" type="button" data-action="studio-release-toggle-ignored" aria-expanded="${collapsed ? "false" : "true"}">
+          <span class="ps-release-step-marker">4</span>
+          <span class="ps-release-step-heading">
+            <strong>Ignored files</strong>
+            <small>${escapeHtml(summary)}</small>
+          </span>
+          <span class="dashicons ${collapsed ? "dashicons-arrow-right-alt2" : "dashicons-arrow-down-alt2"} ps-release-step-toggle-icon" aria-hidden="true"></span>
+        </button>
+      </header>
+      ${collapsed ? "" : `<div class="ps-release-step-body">${body}</div>`}
+    </li>
+  `;
+}
+
+function renderStudioIgnorePatternRow(pattern) {
+  const busy = state.studio.ignoreBusyPattern === pattern;
+  return `
+    <li>
+      <code>${escapeHtml(pattern)}</code>
+      <button class="button button-small ps-release-ignore-remove" type="button" data-action="studio-unignore-rule" data-pattern="${escapeAttr(pattern)}" title="${escapeAttr(`Remove ${pattern}`)}" aria-label="${escapeAttr(`Remove ${pattern}`)}" ${busy ? "disabled aria-busy=\"true\"" : ""}>
+        <span class="dashicons ${busy ? "dashicons-update" : "dashicons-no-alt"}" aria-hidden="true"></span>
+      </button>
+    </li>
+  `;
+}
+
+function studioPublishRouteDetails(action) {
+  switch (action) {
+    case "submit":
+      return {
+        label: "Submit new plugin",
+        shortLabel: "submit",
+        icon: "dashicons-upload",
+        description: "Use this for a first WordPress.org review. Pressship builds a package and uploads it to the plugin submission flow after confirmation.",
+        dryRunLabel: "Dry-run submit",
+        confirmLabel: "Confirm submit",
+        resultLabel: "WordPress.org submission"
+      };
+    case "release":
+      return {
+        label: "Release update",
+        shortLabel: "release",
+        icon: "ps-icon-rocket",
+        description: "Use this for an approved plugin that already has an SVN repository. Pressship validates the package and publishes the current version after confirmation.",
+        dryRunLabel: "Dry-run release",
+        confirmLabel: "Confirm release",
+        resultLabel: "SVN release"
+      };
+    default:
+      return {
+        label: "Auto decide",
+        shortLabel: "auto",
+        icon: "dashicons-controls-play",
+        description: "Best default. Pressship checks WordPress.org and SVN, then chooses submit for first-time review or release for an existing plugin.",
+        dryRunLabel: "Dry-run auto",
+        confirmLabel: "Confirm publish",
+        resultLabel: "publish route"
+      };
+  }
+}
+
+function renderStudioReleasePublishOption(action, options = {}) {
+  const details = studioPublishRouteDetails(action);
+  const active = options.activeAction === action;
+  const chosen = options.detectedRoute === action;
+  const isDefault = options.defaultAction === action;
+  const recommended = action === "auto";
+  const disabled = options.running ? "disabled aria-disabled=\"true\"" : "";
+  const badges = [
+    recommended ? "Recommended" : "",
+    isDefault ? "Default" : "",
+    chosen ? "Selected" : ""
+  ].filter(Boolean);
+
+  return `
+    <button class="ps-release-publish-option${active ? " is-active" : ""}${chosen ? " is-selected" : ""}" type="button" data-action="dry-run-publish" data-id="${escapeAttr(state.studio.id)}" data-publish-action="${escapeAttr(action)}" ${disabled}>
+      <span class="ps-release-option-icon dashicons ${escapeAttr(details.icon)}" aria-hidden="true"></span>
+      <span class="ps-release-option-content">
+        <span class="ps-release-option-title">
+          <strong>${escapeHtml(details.label)}</strong>
+          ${badges.map((badge) => `<em>${escapeHtml(badge)}</em>`).join("")}
+        </span>
+        <span class="ps-release-option-copy">${escapeHtml(details.description)}</span>
+      </span>
+      <span class="ps-release-option-action">${escapeHtml(details.dryRunLabel)}</span>
+    </button>
+  `;
+}
+
+function renderStudioReleasePublishSummary(dryRun, pendingConfirm, running) {
+  if (running) {
+    return `
+      <div class="ps-release-publish-summary is-running" role="status">
+        <span class="dashicons dashicons-update" aria-hidden="true"></span>
+        <p>
+          <strong>Previewing publish route</strong>
+          <small>Validating the package and checking which path is safe to confirm.</small>
+        </p>
+      </div>
+    `;
+  }
+
+  if (!dryRun) {
+    return `
+      <p class="ps-release-step-muted">
+        Pick a dry-run path above. A dry-run validates the package and shows exactly what will happen; nothing is uploaded or committed until you confirm.
+      </p>
+    `;
+  }
+
+  const routeAction = dryRun.route?.action ?? "publish";
+  const details = studioPublishRouteDetails(routeAction);
+  const packageSummary = dryRun.package?.fileCount
+    ? `${dryRun.package.fileCount} packaged files`
+    : dryRun.package?.topLevelFolder
+      ? `Package folder: ${dryRun.package.topLevelFolder}`
+      : "";
+
+  return `
+    <div class="ps-release-publish-summary">
+      <div class="ps-release-publish-result">
+        <span class="dashicons ${escapeAttr(details.icon)}" aria-hidden="true"></span>
+        <p>
+          <strong>${escapeHtml(details.label)}</strong>
+          <small>${escapeHtml(dryRun.route?.reason ?? `Ready to preview ${details.resultLabel}.`)}</small>
+          ${packageSummary ? `<small>${escapeHtml(packageSummary)}</small>` : ""}
+        </p>
+      </div>
+      ${dryRun.canConfirm && dryRun.approvalId
+        ? `<button class="button button-primary ps-release-confirm-button${pendingConfirm ? " is-confirming" : ""}" type="button" data-action="studio-release-publish" data-approval-id="${escapeAttr(dryRun.approvalId)}" data-action-label="${escapeAttr(routeAction)}">
+            ${pendingConfirm ? "Click again to confirm" : escapeHtml(details.confirmLabel)}
+          </button>`
+        : `<p class="ps-release-step-muted">Dry-run did not pass. Fix validation or version findings before publishing.</p>`}
+    </div>
+  `;
+}
+
 function renderStudioReleaseStepPublish(versionState, release) {
   const defaultAction = state.settings?.defaultPublishAction ?? "auto";
   const dryRun = release.dryRun;
@@ -5946,44 +7930,28 @@ function renderStudioReleaseStepPublish(versionState, release) {
   const publishConfirmKey = "publish";
   const pendingConfirm = state.studio.pendingConfirms?.get(publishConfirmKey);
   const detectedRoute = dryRun?.route?.action;
+  const activeAction = detectedRoute ?? defaultAction;
 
   const body = `
+    <div class="ps-release-publish-guide">
+      <strong>Dry-run first, confirm second.</strong>
+      <span>Choose the route you want to preview. The dry-run is safe; the later confirm button performs the upload or SVN publish.</span>
+    </div>
     <div class="ps-release-publish-options">
-      <button class="button${detectedRoute === "submit" ? " button-primary" : ""}" type="button" data-action="dry-run-publish" data-id="${escapeAttr(state.studio.id)}" data-publish-action="submit" ${running ? "disabled" : ""}>
-        <span class="dashicons dashicons-upload" aria-hidden="true"></span>
-        Dry-run submit
-      </button>
-      <button class="button${detectedRoute === "release" ? " button-primary" : ""}" type="button" data-action="dry-run-publish" data-id="${escapeAttr(state.studio.id)}" data-publish-action="release" ${running ? "disabled" : ""}>
-        <span class="dashicons dashicons-update" aria-hidden="true"></span>
-        Dry-run release
-      </button>
-      <button class="button${defaultAction === "auto" ? " button-primary" : ""}" type="button" data-action="dry-run-publish" data-id="${escapeAttr(state.studio.id)}" data-publish-action="auto" ${running ? "disabled" : ""}>
-        <span class="dashicons dashicons-controls-play" aria-hidden="true"></span>
-        Auto dry-run
-      </button>
+      ${renderStudioReleasePublishOption("auto", { activeAction, defaultAction, detectedRoute, running })}
+      ${renderStudioReleasePublishOption("submit", { activeAction, defaultAction, detectedRoute, running })}
+      ${renderStudioReleasePublishOption("release", { activeAction, defaultAction, detectedRoute, running })}
     </div>
-    ${dryRun
-      ? `<div class="ps-release-publish-summary">
-          <p>
-            <strong>${escapeHtml(dryRun.route?.action ?? "publish")}</strong>
-            <small>${escapeHtml(dryRun.route?.reason ?? "")}</small>
-          </p>
-          ${dryRun.canConfirm && dryRun.approvalId
-            ? `<button class="button button-primary ps-release-confirm-button${pendingConfirm ? " is-confirming" : ""}" type="button" data-action="studio-release-publish" data-approval-id="${escapeAttr(dryRun.approvalId)}" data-action-label="${escapeAttr(dryRun.route?.action ?? "publish")}">
-                ${pendingConfirm ? "Click again to confirm" : `Confirm ${escapeHtml(dryRun.route?.action ?? "publish")}`}
-              </button>`
-            : `<p class="ps-release-step-muted">Dry-run did not pass — fix validation findings before publishing.</p>`}
-        </div>`
-      : `<p class="ps-release-step-muted">Run a dry-run to preview the publish plan.</p>`}
+    ${renderStudioReleasePublishSummary(dryRun, pendingConfirm, running)}
   `;
 
   const summary = dryRun
-    ? `Detected route: ${escapeHtml(dryRun.route?.action ?? "publish")}`
+    ? `Detected route: ${escapeHtml(studioPublishRouteDetails(dryRun.route?.action).shortLabel)}`
     : versionState?.releaseBlocked
       ? "Blocked — fix version state before publishing"
       : "";
 
-  return renderStudioReleaseStepShell(4, "Submit / Release", summary, body);
+  return renderStudioReleaseStepShell(5, "Submit / Release", summary, body);
 }
 
 /* ===================================================================
@@ -6020,16 +7988,19 @@ async function refreshStudioAfterReleaseSwitch(result = {}) {
   const localId = state.studio.id;
   const selectedPath = state.studio.selectedFile?.path;
   try {
-    const [detail, filesResult, checkState, versionState] = await Promise.all([
+    const [detail, filesResult, checkState, versionState, ignoreState] = await Promise.all([
       api(`/api/plugins/local/${encodeURIComponent(localId)}`),
       api(`/api/plugins/local/${encodeURIComponent(localId)}/files`),
       api(`/api/plugins/local/${encodeURIComponent(localId)}/check-state`).catch(() => ({ state: null })),
-      api(`/api/plugins/local/${encodeURIComponent(localId)}/version-state`).catch(() => null)
+      api(`/api/plugins/local/${encodeURIComponent(localId)}/version-state`).catch(() => null),
+      api(`/api/plugins/local/${encodeURIComponent(localId)}/ignore-state`).catch(() => createInitialStudioIgnoreState())
     ]);
 
     applyStudioPluginDetail("local", localId, detail);
     state.studio.files = filesResult.files ?? [];
+    state.studio.directories = filesResult.directories ?? [];
     applyStudioCheckState(checkState.state);
+    applyStudioIgnoreState(ignoreState);
     if (versionState) {
       state.versionStates.set(localId, versionState);
       renderLocal();
@@ -6060,10 +8031,54 @@ async function refreshStudioAfterReleaseSwitch(result = {}) {
   }
 }
 
+async function refreshStudioAfterVersionChange(localId) {
+  if (!localId || state.studio.id !== localId || state.studio.scope !== "local") {
+    return;
+  }
+
+  const selectedPath = state.studio.selectedFile?.path;
+  try {
+    const [detail, filesResult, checkState, versionState, ignoreState] = await Promise.all([
+      api(`/api/plugins/local/${encodeURIComponent(localId)}`),
+      api(`/api/plugins/local/${encodeURIComponent(localId)}/files`),
+      api(`/api/plugins/local/${encodeURIComponent(localId)}/check-state`).catch(() => ({ state: null })),
+      api(`/api/plugins/local/${encodeURIComponent(localId)}/version-state`).catch(() => null),
+      api(`/api/plugins/local/${encodeURIComponent(localId)}/ignore-state`).catch(() => createInitialStudioIgnoreState())
+    ]);
+
+    applyStudioPluginDetail("local", localId, detail);
+    state.studio.files = filesResult.files ?? [];
+    state.studio.directories = filesResult.directories ?? [];
+    applyStudioCheckState(checkState.state);
+    applyStudioIgnoreState(ignoreState);
+    if (versionState) {
+      state.versionStates.set(localId, versionState);
+      if (!state.studio.release.newTagDraft || state.studio.release.newTagDraft === versionState.latestSvnTag) {
+        state.studio.release.newTagDraft = versionState.localVersion ?? "";
+      }
+    }
+
+    const selectedStillExists = selectedPath && state.studio.files.some((file) => file.path === selectedPath);
+    if (selectedStillExists) {
+      await selectStudioFile(selectedPath, { force: true });
+    } else {
+      renderStudio();
+      remountStudioEditorIfNeeded();
+    }
+    updateStudioSidebar();
+    updateStudioControls();
+  } catch (error) {
+    appendStudioTerminal(`Studio reload after version change failed: ${error.message}`, "error");
+    renderStudio();
+    updateStudioSidebar();
+  }
+}
+
 async function createStudioReleaseTag() {
   if (!state.studio.id) return;
   const input = document.getElementById("studio-release-new-tag");
-  const name = (input?.value ?? state.studio.release.newTagDraft ?? "").trim();
+  const versionState = state.versionStates.get(state.studio.id);
+  const name = (input?.value ?? releaseTagDraftValue(versionState, state.studio.release)).trim();
   if (!name) {
     state.studio.release.newTagError = "Enter a tag name first.";
     updateStudioSidebar();
@@ -6134,6 +8149,7 @@ async function switchStudioReleaseTag(tag, resolution) {
 
 async function bumpStudioReleaseVersion(localId, bump) {
   if (!localId || !["patch", "minor", "major"].includes(bump)) return;
+  appendStudioCliCommand(studioCliCommand(["version", bump, localPluginCliTarget(localId)]));
   if (state.studio.id !== localId) {
     // Outside the funnel (e.g. invoked from a command palette). Run without
     // the inline busy state — the global notice is enough feedback.
@@ -6174,7 +8190,7 @@ async function bumpStudioReleaseVersion(localId, bump) {
     }, 1500);
     await loadLocal();
     if (state.studio.id === localId) {
-      await refreshStudioVersionState();
+      await refreshStudioAfterVersionChange(localId);
     }
   } catch (error) {
     state.studio.release.bumpInFlight = null;
@@ -6218,7 +8234,7 @@ async function setStudioCustomReleaseVersion(localId) {
     }, 1500);
     await loadLocal();
     if (state.studio.id === localId) {
-      await refreshStudioVersionState();
+      await refreshStudioAfterVersionChange(localId);
     }
   } catch (error) {
     state.studio.release.bumpInFlight = null;
@@ -6231,6 +8247,9 @@ function applyStudioVersionChangeResult(localId, result) {
   if (result && typeof result === "object") {
     const { checkState, ...versionState } = result;
     state.versionStates.set(localId, versionState);
+    if (state.studio.id === localId && versionState.localVersion) {
+      state.studio.release.newTagDraft = versionState.localVersion;
+    }
   }
   if (state.studio.id === localId && result && Object.prototype.hasOwnProperty.call(result, "checkState")) {
     applyStudioCheckState(result.checkState);
@@ -6246,6 +8265,9 @@ async function refreshStudioVersionState() {
       `/api/plugins/local/${encodeURIComponent(state.studio.id)}/version-state`
     );
     state.versionStates.set(state.studio.id, versionState);
+    if (!state.studio.release.newTagDraft && versionState.localVersion) {
+      state.studio.release.newTagDraft = versionState.localVersion;
+    }
     updateStudioSidebar();
   } catch (error) {
     // ignore — sidebar will keep stale data and notice was already shown