@firstpick/pi-package-webui 0.3.4 → 0.3.6

package/public/app.js

@@ -15,6 +15,12 @@ const elements = {
   serverOfflinePanel: $("#serverOfflinePanel"),
   serverRestartPanel: $("#serverRestartPanel"),
   serverRestartMessage: $("#serverRestartMessage"),
+  updateNotification: $("#updateNotification"),
+  updateNotificationTitle: $("#updateNotificationTitle"),
+  updateNotificationMessage: $("#updateNotificationMessage"),
+  updateNotificationDetail: $("#updateNotificationDetail"),
+  updateNotificationUpdateButton: $("#updateNotificationUpdateButton"),
+  updateNotificationDismissButton: $("#updateNotificationDismissButton"),
   serverOfflineCommand: $("#serverOfflineCommand"),
   serverOfflineSlashCommand: $("#serverOfflineSlashCommand"),
   copyServerCommandButton: $("#copyServerCommandButton"),
@@ -31,6 +37,16 @@ const elements = {
   composerActionsButton: $("#composerActionsButton"),
   composerActionsPanel: $("#composerActionsPanel"),
   promptInput: $("#promptInput"),
+  busyPromptBehaviorTag: $("#busyPromptBehaviorTag"),
+  busyPromptBehaviorMenu: $("#busyPromptBehaviorMenu"),
+  sessionSkillTags: $("#sessionSkillTags"),
+  skillEditorDialog: $("#skillEditorDialog"),
+  skillEditorTitle: $("#skillEditorTitle"),
+  skillEditorMeta: $("#skillEditorMeta"),
+  skillEditorText: $("#skillEditorText"),
+  skillEditorStatus: $("#skillEditorStatus"),
+  skillEditorCancelButton: $("#skillEditorCancelButton"),
+  skillEditorSaveButton: $("#skillEditorSaveButton"),
   sendButton: $("#sendButton"),
   commandSuggest: $("#commandSuggest"),
   attachmentTray: $("#attachmentTray"),
@@ -174,6 +190,7 @@ let activeTabGeneration = 0;
 let tabDrafts = new Map();
 let tabAttachments = new Map();
 let activeTextAttachmentEditor = null;
+let activeSkillEditor = null;
 let tabActivities = new Map();
 let tabSeenCompletionSerials = new Map();
 let streamBubble = null;
@@ -213,6 +230,8 @@ let openTerminalTabGroupKey = null;
 let newTabMenuOpen = false;
 let nativeCommandMenuOpen = false;
 let appRunnerMenuOpen = false;
+let busyPromptBehaviorMenuOpen = false;
+const skillUsageByTab = new Map();
 let appRunnerCustomDraft = { id: "", label: "", command: "./", path: "", args: "" };
 let appRunnerFileBrowserState = { open: false, loading: false, path: "", data: null, error: "" };
 let optionsMenuOpen = false;
@@ -238,6 +257,10 @@ let refreshCodexUsageTimer = null;
 let codexUsageRenderTimer = null;
 let backendOffline = false;
 let serverRestartInProgress = false;
+let updateRequestInProgress = false;
+let latestUpdateStatus = null;
+let updateStatusRefreshTimer = null;
+let updateNotificationHideTimer = null;
 let backendOfflineNoticeShown = false;
 let latestMessages = [];
 let promptHistoryByTab = new Map();
@@ -298,7 +321,10 @@ const SIDE_PANEL_SECTION_STORAGE_KEY = "pi-webui-side-panel-sections-collapsed";
 const TAB_STORAGE_KEY = "pi-webui-active-tab";
 const PATH_FAST_PICKS_STORAGE_KEY = "pi-webui-path-fast-picks";
 const AGENT_DONE_NOTIFICATIONS_STORAGE_KEY = "pi-webui-agent-done-notifications";
+const UPDATE_NOTIFICATION_DISMISS_STORAGE_KEY = "pi-webui-update-notification-dismissed";
 const THINKING_VISIBILITY_STORAGE_KEY = "pi-webui-thinking-visible";
+const BUSY_PROMPT_BEHAVIOR_STORAGE_KEY = "pi-webui-busy-prompt-behavior";
+const SKILL_USAGE_STORAGE_KEY = "pi-webui-skill-usage-v1";
 const TERMINAL_TABS_LAYOUT_STORAGE_KEY = "pi-webui-terminal-tabs-layout";
 const TOOL_OUTPUT_EXPANDED_STORAGE_KEY = "pi-webui-tool-output-expanded";
 const THEME_STORAGE_KEY = "pi-webui-theme";
@@ -331,6 +357,10 @@ const BACKGROUND_IMAGE_MIME_TYPES = new Set(["image/png", "image/jpeg", "image/w
 const DEFAULT_THEME_NAME = "catppuccin-mocha";
 const TERMINAL_TABS_LAYOUTS = new Set(["top", "left"]);
 const TERMINAL_TABS_LAYOUT_LABELS = { top: "Top bar", left: "Left sidebar" };
+const BUSY_PROMPT_BEHAVIOR_VALUES = new Set(["followUp", "steer"]);
+const BUSY_PROMPT_BEHAVIOR_LABELS = { followUp: "Follow-up", steer: "Steer" };
+const SKILL_TAG_MAX_VISIBLE = 6;
+const SKILL_USAGE_LIMIT_PER_TAB = 32;
 const MOBILE_VIEW_QUERY = "(max-width: 720px), (max-device-width: 720px), (pointer: coarse) and (hover: none)";
 const SIDE_PANEL_OVERLAY_QUERY = "(max-width: 1050px), (max-device-width: 720px), (pointer: coarse) and (hover: none)";
 const CHAT_BOTTOM_THRESHOLD_PX = 96;
@@ -341,6 +371,8 @@ const CHAT_PROGRAMMATIC_SCROLL_GRACE_MS = 500;
 const CHAT_USER_SCROLL_INTENT_MS = 700;
 const CODEX_USAGE_REFRESH_MS = 5 * 60 * 1000;
 const CODEX_USAGE_RENDER_TICK_MS = 30 * 1000;
+const UPDATE_STATUS_REFRESH_MS = 6 * 60 * 60 * 1000;
+const UPDATE_STATUS_INITIAL_DELAY_MS = 1800;
 const RUN_INDICATOR_TICK_MS = 1000;
 const RUN_INDICATOR_START_GRACE_MS = 2500;
 const RUN_INDICATOR_STATE_RECHECK_MS = 5000;
@@ -905,6 +937,454 @@ function restoreThinkingVisibilitySetting() {
   renderThinkingVisibilityToggle();
 }
 
+function normalizeBusyPromptBehavior(value) {
+  const normalized = String(value || "").trim();
+  if (normalized === "follow-up" || normalized.toLowerCase() === "followup") return "followUp";
+  return BUSY_PROMPT_BEHAVIOR_VALUES.has(normalized) ? normalized : "followUp";
+}
+
+function readStoredBusyPromptBehavior() {
+  try {
+    return normalizeBusyPromptBehavior(localStorage.getItem(BUSY_PROMPT_BEHAVIOR_STORAGE_KEY));
+  } catch {
+    return "followUp";
+  }
+}
+
+function persistBusyPromptBehavior(behavior) {
+  try {
+    localStorage.setItem(BUSY_PROMPT_BEHAVIOR_STORAGE_KEY, normalizeBusyPromptBehavior(behavior));
+  } catch {
+    // Ignore storage failures; the setting should still work for this page load.
+  }
+}
+
+function busyPromptBehaviorMenuItems() {
+  return Array.from(elements.busyPromptBehaviorMenu?.querySelectorAll("[data-busy-prompt-behavior]") || []);
+}
+
+function renderBusyPromptBehaviorMenu() {
+  const behavior = normalizeBusyPromptBehavior(busyPromptBehavior);
+  for (const item of busyPromptBehaviorMenuItems()) {
+    const checked = normalizeBusyPromptBehavior(item.dataset.busyPromptBehavior) === behavior;
+    item.setAttribute("aria-checked", checked ? "true" : "false");
+    item.classList.toggle("active", checked);
+  }
+}
+
+function normalizeSkillName(value) {
+  const raw = String(value || "").trim().replace(/^\/?skill:/i, "");
+  if (!raw) return "";
+  const match = raw.match(/^[a-z0-9][a-z0-9._-]{0,63}$/i);
+  return match ? match[0].toLowerCase() : "";
+}
+
+function skillUsageMapForTab(tabId = activeTabId, { create = true } = {}) {
+  if (!tabId) return null;
+  let map = skillUsageByTab.get(tabId);
+  if (!map && create) {
+    map = new Map();
+    skillUsageByTab.set(tabId, map);
+  }
+  return map || null;
+}
+
+function clearSkillUsageForTab(tabId = activeTabId) {
+  if (!tabId) return;
+  skillUsageByTab.delete(tabId);
+  persistSkillUsage();
+  if (tabId === activeTabId) renderSessionSkillTags(tabId);
+}
+
+function sortedSkillUsageEntries(tabId = activeTabId) {
+  const map = skillUsageMapForTab(tabId, { create: false });
+  if (!map) return [];
+  return [...map.values()].sort((a, b) => b.lastSeenAt - a.lastSeenAt || a.name.localeCompare(b.name));
+}
+
+function serializeSkillUsageEntry(entry) {
+  const name = normalizeSkillName(entry?.name || "");
+  if (!name) return null;
+  const kinds = entry?.kinds instanceof Set ? [...entry.kinds] : Array.isArray(entry?.kinds) ? entry.kinds : [];
+  const paths = entry?.paths instanceof Set ? [...entry.paths] : Array.isArray(entry?.paths) ? entry.paths : [];
+  const sources = entry?.sources instanceof Set ? [...entry.sources] : Array.isArray(entry?.sources) ? entry.sources : [];
+  const path = entry?.path || paths[paths.length - 1] || "";
+  return {
+    name,
+    firstSeenAt: Number.isFinite(entry?.firstSeenAt) ? entry.firstSeenAt : Date.now(),
+    lastSeenAt: Number.isFinite(entry?.lastSeenAt) ? entry.lastSeenAt : Date.now(),
+    kinds: kinds.includes("read") ? kinds : [...kinds, "read"],
+    sources: sources.slice(-12),
+    path,
+    paths: [...new Set([path, ...paths].filter(Boolean))].slice(-8),
+  };
+}
+
+function persistSkillUsage() {
+  try {
+    const storedTabs = {};
+    for (const [tabId, map] of skillUsageByTab.entries()) {
+      const entries = [...map.values()]
+        .filter((entry) => entry?.kinds?.has("read"))
+        .map(serializeSkillUsageEntry)
+        .filter(Boolean)
+        .slice(0, SKILL_USAGE_LIMIT_PER_TAB);
+      if (entries.length) storedTabs[tabId] = entries;
+    }
+    localStorage.setItem(SKILL_USAGE_STORAGE_KEY, JSON.stringify({ version: 1, tabs: storedTabs }));
+  } catch {
+    // Ignore storage failures; tags still work for the current page lifetime.
+  }
+}
+
+function restoreStoredSkillUsage() {
+  try {
+    const parsed = JSON.parse(localStorage.getItem(SKILL_USAGE_STORAGE_KEY) || "{}");
+    const storedTabs = parsed?.tabs && typeof parsed.tabs === "object" ? parsed.tabs : {};
+    for (const [tabId, entries] of Object.entries(storedTabs)) {
+      if (!tabId || !Array.isArray(entries)) continue;
+      const map = skillUsageMapForTab(tabId);
+      if (!map) continue;
+      for (const stored of entries.slice(0, SKILL_USAGE_LIMIT_PER_TAB)) {
+        const name = normalizeSkillName(stored?.name || "");
+        if (!name) continue;
+        const kinds = new Set(Array.isArray(stored?.kinds) ? stored.kinds : ["read"]);
+        if (!kinds.has("read")) continue;
+        const paths = new Set(Array.isArray(stored?.paths) ? stored.paths.filter(Boolean) : []);
+        if (stored?.path) paths.add(stored.path);
+        map.set(name, {
+          name,
+          firstSeenAt: Number.isFinite(stored?.firstSeenAt) ? stored.firstSeenAt : Date.now(),
+          lastSeenAt: Number.isFinite(stored?.lastSeenAt) ? stored.lastSeenAt : Date.now(),
+          kinds,
+          sources: new Set(Array.isArray(stored?.sources) ? stored.sources : ["stored"]),
+          path: stored?.path || [...paths].at(-1) || "",
+          paths,
+        });
+      }
+    }
+  } catch {
+    // Ignore corrupt stored tag data.
+  }
+}
+
+function pruneSkillUsageForKnownTabs(tabIds) {
+  let changed = false;
+  for (const tabId of skillUsageByTab.keys()) {
+    if (tabIds.has(tabId)) continue;
+    skillUsageByTab.delete(tabId);
+    changed = true;
+  }
+  if (changed) persistSkillUsage();
+}
+
+function skillInfoFromPath(pathText) {
+  const normalized = String(pathText || "").trim().replace(/\\/g, "/");
+  const match = normalized.match(/\/skills\/([^/]+)\/SKILL\.md$/i);
+  const name = normalizeSkillName(match?.[1] || "");
+  return name ? { name, path: normalized } : null;
+}
+
+function skillNameFromPath(pathText) {
+  return skillInfoFromPath(pathText)?.name || "";
+}
+
+function skillNamesFromSlashCommands(text) {
+  const names = new Set();
+  for (const match of String(text || "").matchAll(/\/skill:([a-z0-9][a-z0-9._-]{0,63})/gi)) {
+    const normalized = normalizeSkillName(match[1]);
+    if (normalized) names.add(normalized);
+  }
+  return [...names];
+}
+
+function skillKindsLabel(entry) {
+  return entry?.kinds?.has("read") ? "context read" : "tracked";
+}
+
+function renderSessionSkillTags(tabId = activeTabId) {
+  const container = elements.sessionSkillTags;
+  if (!container) return;
+  const entries = sortedSkillUsageEntries(tabId).filter((entry) => entry.kinds.has("read"));
+  container.replaceChildren();
+  if (!entries.length) {
+    container.hidden = true;
+    return;
+  }
+  const visible = entries.slice(0, SKILL_TAG_MAX_VISIBLE);
+  for (const entry of visible) {
+    const classes = ["composer-skill-tag", "read"];
+    const tag = make("button", classes.join(" "), entry.name);
+    tag.type = "button";
+    tag.dataset.skillName = entry.name;
+    tag.dataset.skillPath = skillPathForEntry(entry);
+    tag.title = `Open and edit skill ${entry.name} (${skillKindsLabel(entry)}) tracked in this tab/session.`;
+    tag.setAttribute("aria-label", `Open skill ${entry.name}`);
+    tag.addEventListener("click", () => openSkillEditor(entry));
+    container.append(tag);
+  }
+  if (entries.length > visible.length) {
+    const overflow = make("span", "composer-skill-tag overflow", `+${entries.length - visible.length}`);
+    overflow.title = `${entries.length - visible.length} more tracked skill${entries.length - visible.length === 1 ? "" : "s"}.`;
+    container.append(overflow);
+  }
+  container.hidden = false;
+}
+
+function trackSkillUsage(tabId, skillName, kind = "used", source = "", details = {}) {
+  const name = normalizeSkillName(skillName);
+  if (!tabId || !name) return;
+  const map = skillUsageMapForTab(tabId);
+  if (!map) return;
+  const now = Date.now();
+  const entry = map.get(name) || { name, firstSeenAt: now, lastSeenAt: now, kinds: new Set(), sources: new Set(), paths: new Set() };
+  entry.lastSeenAt = now;
+  if (["used", "loaded", "read"].includes(kind)) entry.kinds.add(kind);
+  else entry.kinds.add("used");
+  if (source) entry.sources.add(source);
+  if (details?.path) {
+    entry.path = details.path;
+    entry.paths ||= new Set();
+    entry.paths.add(details.path);
+  }
+  map.set(name, entry);
+  if (map.size > SKILL_USAGE_LIMIT_PER_TAB) {
+    const keep = [...map.values()].sort((a, b) => b.lastSeenAt - a.lastSeenAt).slice(0, SKILL_USAGE_LIMIT_PER_TAB);
+    map.clear();
+    for (const item of keep) map.set(item.name, item);
+  }
+  persistSkillUsage();
+  if (tabId === activeTabId) renderSessionSkillTags(tabId);
+}
+
+function trackSkillsFromText(tabId, text, { kind = "used", source = "" } = {}) {
+  // Intentionally do not tag /skill:name mentions. A skill tag means the
+  // agent read that skill's full SKILL.md context, not only its command/name.
+}
+
+function trackSkillsFromValue(tabId, value, { keyHint = "", kind = "used", source = "", depth = 0 } = {}) {
+  if (!tabId || value === undefined || value === null || depth > 5) return;
+  if (Array.isArray(value)) {
+    for (const item of value) trackSkillsFromValue(tabId, item, { keyHint, kind, source, depth: depth + 1 });
+    return;
+  }
+  if (typeof value === "string") {
+    const skillInfo = skillInfoFromPath(value);
+    if (skillInfo) trackSkillUsage(tabId, skillInfo.name, "read", source, { path: skillInfo.path });
+    return;
+  }
+  if (typeof value !== "object") return;
+  for (const [key, nested] of Object.entries(value)) {
+    const hint = String(key || "").toLowerCase();
+    trackSkillsFromValue(tabId, nested, { keyHint: hint, kind, source, depth: depth + 1 });
+  }
+}
+
+function trackSkillsFromToolInvocation(tabId, toolName, args, { sourcePrefix = "tool" } = {}) {
+  if (!tabId) return;
+  const name = String(toolName || "").trim();
+  if (name.toLowerCase() !== "read") return;
+  const source = `${sourcePrefix}:${name}`;
+  trackSkillsFromValue(tabId, args, { kind: "read", source });
+}
+
+function trackSkillsFromMessage(tabId, message) {
+  if (!tabId || !message) return;
+  const role = String(message.role || "");
+  if (role === "toolExecution" || role === "toolCall") {
+    trackSkillsFromToolInvocation(tabId, message.toolName || message.name, message.arguments ?? message.args ?? {}, { sourcePrefix: `message:${role}` });
+    return;
+  }
+  if (role === "user" || role === "assistant" || role === "assistantEvent" || role === "native") {
+    trackSkillsFromText(tabId, textFromContent(message.content), { kind: "used", source: `message:${role}` });
+    return;
+  }
+  if (role === "bashExecution") {
+    trackSkillsFromText(tabId, `${message.command || ""}\n${message.output || ""}`, { kind: "used", source: "message:bash" });
+  }
+}
+
+function trackSkillsFromMessages(messages = latestMessages, tabId = activeTabId) {
+  for (const message of messages || []) trackSkillsFromMessage(tabId, message);
+}
+
+function trackSkillsFromEvent(event) {
+  const tabId = event?.tabId || activeTabId;
+  if (!tabId || !event) return;
+  if (["tool_execution_start", "tool_execution_update", "tool_execution_end"].includes(event.type)) {
+    trackSkillsFromToolInvocation(tabId, event.toolName, event.args, { sourcePrefix: `event:${event.type}` });
+    return;
+  }
+  if (event.type === "message_update") {
+    const update = event.assistantMessageEvent || {};
+    if (update.type === "toolcall_start") {
+      trackSkillsFromToolInvocation(tabId, update.name || update.toolName || update.toolCall?.name, update.arguments || update.args || update.toolCall?.arguments || {}, { sourcePrefix: "event:message_update" });
+    }
+    return;
+  }
+  if (event.type === "response" && event.command === "new_session") {
+    clearSkillUsageForTab(tabId);
+  }
+}
+
+function skillPathForEntry(entry) {
+  if (entry?.path) return entry.path;
+  if (entry?.paths instanceof Set && entry.paths.size) {
+    const paths = [...entry.paths];
+    return paths[paths.length - 1] || "";
+  }
+  return "";
+}
+
+function skillEditorApiPath({ name = "", path = "" } = {}) {
+  const params = new URLSearchParams();
+  if (name) params.set("name", name);
+  if (path) params.set("path", path);
+  const query = params.toString();
+  return query ? `/api/skill-file?${query}` : "/api/skill-file";
+}
+
+function setSkillEditorStatus(message = "", level = "muted") {
+  const status = elements.skillEditorStatus;
+  if (!status) return;
+  status.textContent = message;
+  status.className = `skill-editor-status ${level || "muted"}`;
+  status.hidden = !message;
+}
+
+function closeSkillEditor() {
+  if (elements.skillEditorDialog?.open) elements.skillEditorDialog.close();
+  else activeSkillEditor = null;
+}
+
+function updateSkillEditorMeta(data = activeSkillEditor || {}) {
+  if (!elements.skillEditorMeta) return;
+  const parts = [data.name ? `Skill: ${data.name}` : "Skill", data.path || "path unavailable"].filter(Boolean);
+  elements.skillEditorMeta.textContent = parts.join(" · ");
+}
+
+async function openSkillEditor(entry) {
+  const name = normalizeSkillName(entry?.name || "");
+  const path = skillPathForEntry(entry);
+  if (!name || !elements.skillEditorDialog || !elements.skillEditorText) return;
+  const tabId = activeTabId;
+  activeSkillEditor = { name, path, tabId, mtimeMs: null };
+  if (elements.skillEditorTitle) elements.skillEditorTitle.textContent = `Edit skill: ${name}`;
+  if (elements.skillEditorText) elements.skillEditorText.value = "";
+  if (elements.skillEditorSaveButton) elements.skillEditorSaveButton.disabled = true;
+  updateSkillEditorMeta(activeSkillEditor);
+  setSkillEditorStatus("Loading skill context…", "muted");
+  if (!elements.skillEditorDialog.open) elements.skillEditorDialog.showModal();
+
+  try {
+    const response = await api(skillEditorApiPath({ name, path }), { tabId });
+    if (activeSkillEditor?.tabId !== tabId || activeSkillEditor?.name !== name) return;
+    const data = response.data || {};
+    activeSkillEditor = { name: normalizeSkillName(data.name || name), path: data.path || path, tabId, mtimeMs: data.mtimeMs };
+    if (elements.skillEditorTitle) elements.skillEditorTitle.textContent = `Edit skill: ${activeSkillEditor.name}`;
+    if (elements.skillEditorText) elements.skillEditorText.value = data.content || "";
+    if (elements.skillEditorSaveButton) elements.skillEditorSaveButton.disabled = false;
+    updateSkillEditorMeta(activeSkillEditor);
+    setSkillEditorStatus("Edit this SKILL.md, then save. Reload the tab if title/description metadata should refresh immediately.", "muted");
+    queueMicrotask(() => elements.skillEditorText?.focus());
+  } catch (error) {
+    if (elements.skillEditorSaveButton) elements.skillEditorSaveButton.disabled = true;
+    setSkillEditorStatus(`Failed to open skill: ${error.message || String(error)}`, "error");
+  }
+}
+
+async function saveSkillEditor() {
+  if (!activeSkillEditor || !elements.skillEditorText || !elements.skillEditorSaveButton) return;
+  const editor = activeSkillEditor;
+  const previousLabel = elements.skillEditorSaveButton.textContent;
+  elements.skillEditorSaveButton.disabled = true;
+  elements.skillEditorSaveButton.textContent = "Saving…";
+  setSkillEditorStatus("Saving skill…", "muted");
+  try {
+    const response = await api("/api/skill-file", {
+      method: "POST",
+      tabId: editor.tabId,
+      body: {
+        name: editor.name,
+        path: editor.path,
+        mtimeMs: editor.mtimeMs,
+        content: elements.skillEditorText.value,
+      },
+    });
+    const data = response.data || {};
+    const savedName = normalizeSkillName(data.name || editor.name);
+    activeSkillEditor = { name: savedName, path: data.path || editor.path, tabId: editor.tabId, mtimeMs: data.mtimeMs };
+    const map = skillUsageMapForTab(editor.tabId, { create: false });
+    if (map && savedName !== editor.name) map.delete(editor.name);
+    trackSkillUsage(editor.tabId, savedName, "read", "skill-editor", { path: activeSkillEditor.path });
+    if (elements.skillEditorTitle) elements.skillEditorTitle.textContent = `Edit skill: ${savedName}`;
+    updateSkillEditorMeta(activeSkillEditor);
+    setSkillEditorStatus("Saved SKILL.md. Reload/restart affected tabs before relying on updated skill metadata or newly loaded instructions.", "ok");
+  } catch (error) {
+    setSkillEditorStatus(`Failed to save skill: ${error.message || String(error)}`, "error");
+  } finally {
+    elements.skillEditorSaveButton.textContent = previousLabel || "Save skill";
+    elements.skillEditorSaveButton.disabled = false;
+  }
+}
+
+function renderBusyPromptBehaviorTag() {
+  const tag = elements.busyPromptBehaviorTag;
+  if (!tag) return;
+  const behavior = normalizeBusyPromptBehavior(busyPromptBehavior);
+  const label = BUSY_PROMPT_BEHAVIOR_LABELS[behavior] || BUSY_PROMPT_BEHAVIOR_LABELS.followUp;
+  tag.textContent = label;
+  tag.classList.toggle("follow-up", behavior === "followUp");
+  tag.classList.toggle("steer", behavior === "steer");
+  tag.title = behavior === "steer"
+    ? "While Pi is running, normal prompt submit steers the active run. Click to change."
+    : "While Pi is running, normal prompt submit queues a follow-up. Click to change.";
+  tag.setAttribute("aria-label", tag.title);
+  renderBusyPromptBehaviorMenu();
+  renderSessionSkillTags(activeTabId);
+}
+
+function setBusyPromptBehaviorMenuOpen(open, { focusCurrent = false } = {}) {
+  busyPromptBehaviorMenuOpen = !!open;
+  elements.busyPromptBehaviorTag?.setAttribute("aria-expanded", busyPromptBehaviorMenuOpen ? "true" : "false");
+  elements.busyPromptBehaviorTag?.classList.toggle("menu-open", busyPromptBehaviorMenuOpen);
+  if (elements.busyPromptBehaviorMenu) elements.busyPromptBehaviorMenu.hidden = !busyPromptBehaviorMenuOpen;
+  if (!busyPromptBehaviorMenuOpen) return;
+  renderBusyPromptBehaviorMenu();
+  if (focusCurrent) {
+    requestAnimationFrame(() => {
+      const current = busyPromptBehaviorMenuItems().find((item) => item.getAttribute("aria-checked") === "true") || busyPromptBehaviorMenuItems()[0];
+      current?.focus({ preventScroll: true });
+    });
+  }
+}
+
+function focusBusyPromptBehaviorMenuItem(direction = 1) {
+  const items = busyPromptBehaviorMenuItems();
+  if (!items.length) return;
+  const currentIndex = Math.max(0, items.indexOf(document.activeElement));
+  const nextIndex = (currentIndex + direction + items.length) % items.length;
+  items[nextIndex].focus({ preventScroll: true });
+}
+
+function chooseBusyPromptBehaviorFromMenu(value) {
+  setBusyPromptBehavior(value);
+  setBusyPromptBehaviorMenuOpen(false);
+  focusPromptInput({ defer: true });
+}
+
+function setBusyPromptBehavior(value, { persist = true } = {}) {
+  const next = normalizeBusyPromptBehavior(value);
+  busyPromptBehavior = next;
+  webuiSettings = { ...webuiSettings, busyPromptBehavior: next };
+  if (persist) persistBusyPromptBehavior(next);
+  renderBusyPromptBehaviorTag();
+}
+
+function restoreBusyPromptBehaviorSetting() {
+  setBusyPromptBehavior(readStoredBusyPromptBehavior(), { persist: false });
+}
+
 function clampAutocompleteMaxVisible(value) {
   const number = Number(value);
   if (!Number.isFinite(number)) return 12;
@@ -917,6 +1397,7 @@ function applyNativeSettingsForBrowser(settings = {}, { syncThinkingVisibility =
   if (settings.autocompleteMaxVisible !== undefined) autocompleteMaxVisible = clampAutocompleteMaxVisible(settings.autocompleteMaxVisible);
   if (SETTINGS_DOUBLE_ESCAPE_OPTIONS.some((option) => option.value === settings.doubleEscapeAction)) doubleEscapeAction = settings.doubleEscapeAction;
   if (SETTINGS_TREE_FILTER_OPTIONS.includes(settings.treeFilterMode)) treeFilterMode = settings.treeFilterMode;
+  if (BUSY_PROMPT_BEHAVIOR_VALUES.has(settings.busyPromptBehavior)) setBusyPromptBehavior(settings.busyPromptBehavior);
   if (syncThinkingVisibility && typeof settings.hideThinkingBlock === "boolean") setThinkingOutputVisible(!settings.hideThinkingBlock);
 }
 
@@ -936,6 +1417,7 @@ function setComposerActionsOpen(open) {
     setNativeCommandMenuOpen(false);
     setAppRunnerMenuOpen(false);
     setOptionsMenuOpen(false);
+    setBusyPromptBehaviorMenuOpen(false);
   }
 }
 
@@ -993,6 +1475,7 @@ function updateComposerModeButtons() {
   elements.abortButton.textContent = abortRequestInFlight ? "Aborting…" : "Abort";
   elements.abortButton.title = abortAvailable ? "Abort the active Pi run (Esc or hold)" : "Abort is available while Pi is running";
   elements.abortButton.setAttribute("aria-label", elements.abortButton.title);
+  renderBusyPromptBehaviorTag();
   document.body.classList.toggle("pi-run-active", runActive || abortAvailable);
 }
 
@@ -1228,6 +1711,7 @@ function setServerRestartOverlay(active, message = "Waiting for the server to co
   document.body.classList.toggle("server-restarting", serverRestartInProgress);
   if (elements.serverRestartPanel) elements.serverRestartPanel.hidden = !serverRestartInProgress;
   if (elements.serverRestartMessage) elements.serverRestartMessage.textContent = message;
+  if (serverRestartInProgress) hideUpdateNotification();
   if (serverRestartInProgress && elements.serverOfflinePanel) elements.serverOfflinePanel.hidden = true;
 }
 
@@ -1238,6 +1722,7 @@ function setBackendOffline(offline, error) {
   if (elements.serverOfflinePanel) elements.serverOfflinePanel.hidden = !showOfflinePanel;
   renderServerOfflinePanel();
   if (backendOffline) {
+    hideUpdateNotification();
     if (!serverRestartInProgress && !backendOfflineNoticeShown) {
       backendOfflineNoticeShown = true;
       addEvent(`Pi Web UI server is offline${error?.message ? `: ${error.message}` : ""}`, "warn");
@@ -1480,6 +1965,169 @@ async function refreshWebuiVersion() {
   setWebuiDevServer(isWebuiDevMetadata(health));
 }
 
+function packageUpdateText(label, status = {}) {
+  const current = formatWebuiVersion(status.currentVersion || "");
+  const latest = formatWebuiVersion(status.latestVersion || "");
+  if (current && latest) return `${label} ${current} → ${latest}`;
+  if (latest) return `${label} ${latest}`;
+  return label;
+}
+
+function updateNotificationItems(status = latestUpdateStatus) {
+  const items = [];
+  if (status?.pi?.updateAvailable) items.push(packageUpdateText("Pi", status.pi));
+  if (status?.webui?.updateAvailable) items.push(packageUpdateText("Web UI", status.webui));
+  return items;
+}
+
+function updateNotificationDismissKey(status = latestUpdateStatus) {
+  const parts = [status?.pi?.latestVersion, status?.webui?.latestVersion]
+    .map((value) => String(value || "").trim())
+    .filter(Boolean);
+  return parts.length ? parts.join("|") : "";
+}
+
+function storedDismissedUpdateKey() {
+  try {
+    return localStorage.getItem(UPDATE_NOTIFICATION_DISMISS_STORAGE_KEY) || "";
+  } catch {
+    return "";
+  }
+}
+
+function rememberDismissedUpdateKey(key) {
+  if (!key) return;
+  try {
+    localStorage.setItem(UPDATE_NOTIFICATION_DISMISS_STORAGE_KEY, key);
+  } catch {
+    // Ignore private-mode storage failures.
+  }
+}
+
+function hideUpdateNotification({ remember = false } = {}) {
+  const panel = elements.updateNotification;
+  if (!panel) return;
+  clearTimeout(updateNotificationHideTimer);
+  if (remember) rememberDismissedUpdateKey(updateNotificationDismissKey());
+  panel.classList.remove("show");
+  updateNotificationHideTimer = setTimeout(() => {
+    panel.hidden = true;
+  }, 360);
+}
+
+function renderUpdateNotification(status = latestUpdateStatus, { force = false } = {}) {
+  const panel = elements.updateNotification;
+  if (!panel) return;
+  latestUpdateStatus = status || latestUpdateStatus;
+  const items = updateNotificationItems(latestUpdateStatus);
+  const dismissKey = updateNotificationDismissKey(latestUpdateStatus);
+  const shouldShow = !!latestUpdateStatus?.updateAvailable && items.length > 0 && !updateRequestInProgress;
+  if (!shouldShow || (!force && dismissKey && storedDismissedUpdateKey() === dismissKey)) {
+    hideUpdateNotification();
+    return;
+  }
+
+  const canRunUpdate = latestUpdateStatus.canRunUpdate !== false;
+  if (elements.updateNotificationTitle) elements.updateNotificationTitle.textContent = items.length === 1 ? `${items[0]} available` : "Pi updates available";
+  if (elements.updateNotificationMessage) {
+    elements.updateNotificationMessage.textContent = canRunUpdate
+      ? "Run pi update now, then restart this Web UI server automatically."
+      : "Updates are available. Direct Web UI updates are only enabled from localhost on the host machine.";
+  }
+  const details = [
+    items.join(" · "),
+    latestUpdateStatus.webuiDev && latestUpdateStatus.webui?.updateAvailable ? "The current Web UI is a dev checkout; pi update updates installed Pi packages, not this checkout." : "",
+    latestUpdateStatus.packages?.note || "",
+  ].filter(Boolean).join(" ");
+  if (elements.updateNotificationDetail) elements.updateNotificationDetail.textContent = details;
+  if (elements.updateNotificationUpdateButton) {
+    elements.updateNotificationUpdateButton.hidden = !canRunUpdate;
+    elements.updateNotificationUpdateButton.disabled = updateRequestInProgress || latestUpdateStatus.updateInProgress;
+    elements.updateNotificationUpdateButton.textContent = latestUpdateStatus.updateInProgress ? "Updating…" : "Update & restart";
+  }
+  clearTimeout(updateNotificationHideTimer);
+  panel.hidden = false;
+  requestAnimationFrame(() => panel.classList.add("show"));
+}
+
+async function refreshUpdateStatus({ force = false, notify = true } = {}) {
+  const path = force ? "/api/update-status?refresh=1" : "/api/update-status";
+  const response = await api(path, { scoped: false });
+  latestUpdateStatus = response.data || null;
+  if (notify) renderUpdateNotification(latestUpdateStatus);
+  return latestUpdateStatus;
+}
+
+function scheduleUpdateStatusRefresh() {
+  clearTimeout(updateStatusRefreshTimer);
+  updateStatusRefreshTimer = setTimeout(() => {
+    updateStatusRefreshTimer = null;
+    refreshUpdateStatus({ force: true }).catch((error) => addEvent(`Pi update check failed: ${error.message || String(error)}`, "warn"));
+    scheduleUpdateStatusRefresh();
+  }, UPDATE_STATUS_REFRESH_MS);
+}
+
+function initializeUpdateNotifications() {
+  setTimeout(() => {
+    refreshUpdateStatus().catch((error) => addEvent(`Pi update check failed: ${error.message || String(error)}`, "warn"));
+    scheduleUpdateStatusRefresh();
+  }, UPDATE_STATUS_INITIAL_DELAY_MS);
+}
+
+function piUpdateConfirmationText() {
+  const items = updateNotificationItems();
+  const workingWarning = hasWorkingTab() ? "\n\nOne or more Pi tabs look busy or blocked. Finish or abort in-flight work before updating if you need to preserve it." : "";
+  const versionText = items.length ? `\n\nDetected update: ${items.join(" · ")}.` : "";
+  return `Run pi update now?${versionText}\n\nThis will run \"pi update\" on the Web UI host. After it finishes, Pi Web UI will restart itself. Browser clients will briefly disconnect, and managed Pi tabs/RPC processes will be restarted from saved session state when possible.${workingWarning}`;
+}
+
+async function runPiUpdateAndRestart() {
+  if (updateRequestInProgress) return;
+  if (latestUpdateStatus?.canRunUpdate === false) {
+    addEvent("Pi update can only be started from localhost on the Web UI host", "warn");
+    renderUpdateNotification(latestUpdateStatus, { force: true });
+    return;
+  }
+  if (!confirm(piUpdateConfirmationText())) return;
+
+  updateRequestInProgress = true;
+  hideUpdateNotification();
+  setServerActionBusy("Updating…");
+  setServerActionStatus("Running pi update. The server will restart after the update completes…", "warn");
+  setServerRestartOverlay(true, "Running pi update. The server will restart after the update completes…");
+  try {
+    await api("/api/update", { method: "POST", scoped: false });
+    addEvent("Pi update completed; Pi Web UI server restart requested", "warn");
+  } catch (error) {
+    if (!error?.backendOffline) {
+      updateRequestInProgress = false;
+      setServerRestartOverlay(false);
+      resetServerActionControls();
+      const message = error.message || String(error);
+      setServerActionStatus(message, "error");
+      addEvent(message, "error");
+      renderUpdateNotification(latestUpdateStatus, { force: true });
+      return;
+    }
+    addEvent("Pi Web UI server connection dropped during update restart request", "warn");
+  }
+
+  setBackendOffline(true, new Error("update requested from side panel"));
+  const restarted = await waitForServerRestart();
+  updateRequestInProgress = false;
+  resetServerActionControls();
+  if (restarted) {
+    hideUpdateNotification({ remember: true });
+    setServerActionStatus("Updated, restarted, and reconnected.", "success");
+    refreshUpdateStatus({ force: true, notify: false }).catch(() => {});
+  } else {
+    setServerRestartOverlay(false);
+    setBackendOffline(true, new Error("update restart reconnect timed out"));
+    setServerActionStatus("Update completed, but the server did not reconnect automatically.", "error");
+    addEvent("Pi Web UI server did not come back online after update request", "error");
+  }
+}
+
 function formatBytes(bytes) {
   const value = Number(bytes) || 0;
   if (value < 1024) return `${value} B`;
@@ -2717,9 +3365,11 @@ function syncTabMetadata(nextTabs = []) {
       tabActivities.delete(tabId);
       tabSeenCompletionSerials.delete(tabId);
       actionFeedbackByTab.delete(tabId);
+      skillUsageByTab.delete(tabId);
       clearGitWorkflowForTab(tabId);
     }
   }
+  pruneSkillUsageForKnownTabs(liveIds);
 }
 
 function applyTabMetadata(tab) {
@@ -2926,7 +3576,7 @@ function restoreActiveDraft() {
 
 function focusPromptInput({ defer = false } = {}) {
   const focus = () => {
-    if (!elements.promptInput || elements.dialog.open || elements.pathPickerDialog.open || elements.nativeCommandDialog.open || elements.appRunnerInfoDialog?.open || elements.promptListDialog?.open || elements.attachmentTextDialog?.open || document.visibilityState === "hidden") return;
+    if (!elements.promptInput || elements.dialog.open || elements.pathPickerDialog.open || elements.nativeCommandDialog.open || elements.appRunnerInfoDialog?.open || elements.promptListDialog?.open || elements.attachmentTextDialog?.open || elements.skillEditorDialog?.open || document.visibilityState === "hidden") return;
     try {
       elements.promptInput.focus({ preventScroll: true });
     } catch {
@@ -3281,6 +3931,7 @@ async function refreshTabs({ selectStored = false } = {}) {
     setActiveTabId((requested && tabs.some((tab) => tab.id === requested) ? requested : stored && tabs.some((tab) => tab.id === stored) ? stored : tabs[0]?.id) || null, { remember: true });
   }
   rememberServerStartCwd(tabs.find((tab) => tab.id === activeTabId)?.cwd || tabs[0]?.cwd);
+  renderSessionSkillTags(activeTabId);
   renderTabs();
   return tabs;
 }
@@ -10205,7 +10856,7 @@ async function openNativeSettingsDialog() {
       if (controls.steering.select.value !== (state.steeringMode || "one-at-a-time")) requests.push(nativeCommandApi("/api/steering-mode", { method: "POST", body: { mode: controls.steering.select.value } }));
       if (controls.followUp.select.value !== (state.followUpMode || "one-at-a-time")) requests.push(nativeCommandApi("/api/follow-up-mode", { method: "POST", body: { mode: controls.followUp.select.value } }));
       if (controls.autoCompact.input.checked !== (state.autoCompactionEnabled !== false)) requests.push(nativeCommandApi("/api/auto-compaction", { method: "POST", body: { enabled: controls.autoCompact.input.checked } }));
-      busyPromptBehavior = controls.busyBehavior.select.value;
+      setBusyPromptBehavior(controls.busyBehavior.select.value);
       if (controls.thinkingOutput.input.checked !== thinkingOutputVisible) setThinkingOutputVisible(controls.thinkingOutput.input.checked);
       if (controls.doneNotifications.input.checked !== agentDoneNotificationsEnabled) await setAgentDoneNotificationsEnabled(controls.doneNotifications.input.checked);
       await Promise.all(requests);
@@ -10678,6 +11329,7 @@ function renderMessages(messages) {
   cleanupLiveToolRunsForMessages(latestMessages);
   syncLastUserPromptFromMessages(latestMessages);
   syncPromptHistoryFromMessages(latestMessages);
+  trackSkillsFromMessages(latestMessages, activeTabId);
   renderAllMessages();
   renderFooter();
   renderFeedbackTray();
@@ -11610,9 +12262,11 @@ function updateServerActionButton() {
   const button = elements.runServerActionButton;
   if (!button) return;
   button.disabled = !action;
-  button.textContent = action === "restart" ? "Restart" : action === "stop" ? "Stop" : "Run";
+  button.textContent = action === "restart" ? "Restart" : action === "update" ? "Update" : action === "stop" ? "Stop" : "Run";
   button.classList.toggle("danger", action === "stop");
-  if (action) setServerActionStatus(action === "restart" ? "Ready to restart the Web UI server." : "Ready to stop the Web UI server.", "info");
+  if (action === "restart") setServerActionStatus("Ready to restart the Web UI server.", "info");
+  else if (action === "update") setServerActionStatus("Ready to run pi update, then restart the Web UI server.", "info");
+  else if (action === "stop") setServerActionStatus("Ready to stop the Web UI server.", "info");
   else setServerActionStatus();
 }
 
@@ -11718,6 +12372,7 @@ async function stopServer() {
 async function runSelectedServerAction() {
   const action = elements.serverActionSelect?.value || "";
   if (action === "restart") await restartServer();
+  else if (action === "update") await runPiUpdateAndRestart();
   else if (action === "stop") await stopServer();
 }
 
@@ -11927,7 +12582,7 @@ async function sendPrompt(kind = "prompt", explicitMessage, { targetTabId = acti
   }
 
   const targetWasStreaming = !!currentState?.isStreaming;
-  const busyBehavior = busyPromptBehavior || "followUp";
+  const busyBehavior = normalizeBusyPromptBehavior(busyPromptBehavior);
   const startsRun = kind === "prompt" && !targetWasStreaming;
   autoFollowChat = true;
   updateJumpToLatestButton();
@@ -12188,6 +12843,7 @@ function handleInactiveTabEvent(event) {
 
 function handleEvent(event) {
   ingestEventTabActivity(event);
+  trackSkillsFromEvent(event);
   if (!eventTargetsActiveTab(event)) {
     handleInactiveTabEvent(event);
     return;
@@ -12485,6 +13141,20 @@ elements.attachmentTextDialog?.addEventListener("keydown", (event) => {
   if (!elements.attachmentTextSaveButton?.disabled) saveTextAttachmentEdit();
 });
 elements.attachmentTextDialog?.querySelector("form")?.addEventListener("submit", (event) => event.preventDefault());
+elements.skillEditorCancelButton?.addEventListener("click", closeSkillEditor);
+elements.skillEditorSaveButton?.addEventListener("click", saveSkillEditor);
+elements.skillEditorText?.addEventListener("input", () => setSkillEditorStatus("Unsaved skill edits.", "warn"));
+elements.skillEditorDialog?.addEventListener("close", () => {
+  activeSkillEditor = null;
+  if (elements.skillEditorText) elements.skillEditorText.value = "";
+  setSkillEditorStatus("");
+});
+elements.skillEditorDialog?.addEventListener("keydown", (event) => {
+  if (!(event.ctrlKey || event.metaKey) || event.altKey || event.shiftKey || event.key.toLowerCase() !== "s") return;
+  event.preventDefault();
+  if (!elements.skillEditorSaveButton?.disabled) saveSkillEditor();
+});
+elements.skillEditorDialog?.querySelector("form")?.addEventListener("submit", (event) => event.preventDefault());
 elements.sendFeedbackButton.addEventListener("click", () => submitQueuedActionFeedback());
 elements.composer.addEventListener("submit", (event) => {
   event.preventDefault();
@@ -12493,6 +13163,56 @@ elements.composer.addEventListener("submit", (event) => {
 elements.composerActionsButton.addEventListener("click", () => {
   setComposerActionsOpen(!document.body.classList.contains("composer-actions-open"));
 });
+elements.busyPromptBehaviorTag?.addEventListener("click", (event) => {
+  event.preventDefault();
+  const nextOpen = !busyPromptBehaviorMenuOpen;
+  setPublishMenuOpen(false);
+  setNativeCommandMenuOpen(false);
+  setAppRunnerMenuOpen(false);
+  setOptionsMenuOpen(false);
+  setComposerActionsOpen(false);
+  setBusyPromptBehaviorMenuOpen(nextOpen);
+});
+elements.busyPromptBehaviorTag?.addEventListener("keydown", (event) => {
+  if (!["ArrowDown", "ArrowUp", "Enter", " "].includes(event.key)) return;
+  event.preventDefault();
+  const focusPrevious = event.key === "ArrowUp";
+  setBusyPromptBehaviorMenuOpen(true);
+  requestAnimationFrame(() => {
+    const items = busyPromptBehaviorMenuItems();
+    if (!items.length) return;
+    const currentIndex = Math.max(0, items.findIndex((item) => item.getAttribute("aria-checked") === "true"));
+    const targetIndex = focusPrevious ? (currentIndex - 1 + items.length) % items.length : currentIndex;
+    items[targetIndex]?.focus({ preventScroll: true });
+  });
+});
+elements.busyPromptBehaviorMenu?.addEventListener("click", (event) => {
+  const item = event.target?.closest?.("[data-busy-prompt-behavior]");
+  if (!item) return;
+  chooseBusyPromptBehaviorFromMenu(item.dataset.busyPromptBehavior);
+});
+elements.busyPromptBehaviorMenu?.addEventListener("keydown", (event) => {
+  if (event.key === "Escape") {
+    event.preventDefault();
+    setBusyPromptBehaviorMenuOpen(false);
+    elements.busyPromptBehaviorTag?.focus({ preventScroll: true });
+    return;
+  }
+  if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+    event.preventDefault();
+    focusBusyPromptBehaviorMenuItem(event.key === "ArrowDown" ? 1 : -1);
+    return;
+  }
+  if (event.key === "Home" || event.key === "End") {
+    event.preventDefault();
+    const items = busyPromptBehaviorMenuItems();
+    items[event.key === "Home" ? 0 : items.length - 1]?.focus({ preventScroll: true });
+    return;
+  }
+  if (event.key === "Tab") {
+    setBusyPromptBehaviorMenuOpen(false);
+  }
+});
 elements.steerButton.addEventListener("click", () => sendPromptFromModeButton("steer", elements.steerButton));
 elements.followUpButton.addEventListener("click", () => sendPromptFromModeButton("follow-up", elements.followUpButton));
 elements.terminalTabsToggleButton.addEventListener("click", () => {
@@ -12866,6 +13586,8 @@ if (elements.backgroundClearButton) {
 elements.openNetworkButton.addEventListener("click", openToNetwork);
 elements.serverActionSelect.addEventListener("change", updateServerActionButton);
 elements.runServerActionButton.addEventListener("click", () => runSelectedServerAction().catch((error) => addEvent(error.message || String(error), "error")));
+elements.updateNotificationUpdateButton?.addEventListener("click", () => runPiUpdateAndRestart().catch((error) => addEvent(error.message || String(error), "error")));
+elements.updateNotificationDismissButton?.addEventListener("click", () => hideUpdateNotification({ remember: true }));
 updateServerActionButton();
 elements.agentDoneNotificationsToggle.addEventListener("change", () => {
   setAgentDoneNotificationsEnabled(elements.agentDoneNotificationsToggle.checked, {
@@ -12929,6 +13651,9 @@ document.addEventListener("pointerdown", (event) => {
   if (optionsMenuOpen && !event.target?.closest?.(".composer-options-menu")) {
     setOptionsMenuOpen(false);
   }
+  if (busyPromptBehaviorMenuOpen && !event.target?.closest?.(".composer-context-tags, .composer-busy-mode-menu")) {
+    setBusyPromptBehaviorMenuOpen(false);
+  }
   if (document.body.classList.contains("mobile-tabs-expanded") && !elements.tabBar.contains(event.target) && !elements.terminalTabsToggleButton.contains(event.target)) {
     setNewTabMenuOpen(false);
     setMobileTabsExpanded(false);
@@ -13029,6 +13754,11 @@ window.addEventListener("keydown", (event) => {
     setOptionsMenuOpen(false);
     return;
   }
+  if (busyPromptBehaviorMenuOpen) {
+    setBusyPromptBehaviorMenuOpen(false);
+    elements.busyPromptBehaviorTag?.focus({ preventScroll: true });
+    return;
+  }
   if (newTabMenuOpen) {
     setNewTabMenuOpen(false);
     return;
@@ -13181,6 +13911,8 @@ elements.promptInput.addEventListener("blur", () => {
 
 resizePromptInput();
 focusPromptInput({ defer: true });
+restoreStoredSkillUsage();
+restoreBusyPromptBehaviorSetting();
 updateComposerModeButtons();
 updateOptionalFeatureAvailability();
 renderAppRunnerControls();
@@ -13203,6 +13935,7 @@ restoreSidePanelSectionState();
 bindSidePanelSectionToggles();
 restoreSidePanelState();
 initializeCodexUsage();
+initializeUpdateNotifications();
 bindMobileViewChanges();
 bindSidePanelOverlayViewChanges();
 registerPwaServiceWorker();