@firstpick/pi-package-webui 0.1.8 → 0.2.0

package/public/app.js

@@ -60,9 +60,12 @@ const elements = {
   backgroundStatus: $("#backgroundStatus"),
   networkStatus: $("#networkStatus"),
   openNetworkButton: $("#openNetworkButton"),
+  stopServerButton: $("#stopServerButton"),
   agentDoneNotificationsToggle: $("#agentDoneNotificationsToggle"),
   agentDoneNotificationsStatus: $("#agentDoneNotificationsStatus"),
   optionalFeaturesBox: $("#optionalFeaturesBox"),
+  codexUsageBox: $("#codexUsageBox"),
+  refreshCodexUsageButton: $("#refreshCodexUsageButton"),
   toggleSidePanelButton: $("#toggleSidePanelButton"),
   sidePanelExpandButton: $("#sidePanelExpandButton"),
   sidePanelBackdrop: $("#sidePanelBackdrop"),
@@ -125,6 +128,7 @@ let refreshMessagesTimer = null;
 let refreshStateTimer = null;
 let refreshFooterTimer = null;
 let refreshTabsTimer = null;
+let foregroundReconcileTimer = null;
 let eventSource = null;
 let activeDialog = null;
 let nativeCommandTabId = null;
@@ -146,9 +150,16 @@ let pathSuggestAbortController = null;
 let latestStats = null;
 let latestWorkspace = null;
 let latestNetwork = null;
+let latestCodexUsage = null;
+let codexUsageError = null;
+let codexUsageLoading = false;
+let refreshCodexUsageTimer = null;
+let codexUsageRenderTimer = null;
 let backendOffline = false;
 let backendOfflineNoticeShown = false;
 let latestMessages = [];
+let promptHistoryByTab = new Map();
+let promptHistoryNavigation = null;
 let transientMessages = [];
 let actionEntrySeenKeysByTab = new Map();
 let actionEntryAnimationPrimedTabs = new Set();
@@ -160,6 +171,7 @@ let blockedTabNotificationPermissionRequested = false;
 let blockedTabNotificationFallbackNoted = false;
 let agentDoneNotificationsEnabled = false;
 let thinkingOutputVisible = true;
+let toolOutputGloballyExpanded = false;
 let agentDoneNotificationPermissionRequested = false;
 let agentDoneNotificationFallbackNoted = false;
 let agentDoneNotificationKeys = new Set();
@@ -185,6 +197,9 @@ let currentRunStartedAt = null;
 let currentRunStreamChars = 0;
 let latestTokPerSecond = null;
 let abortRequestInFlight = false;
+let userBashByTab = new Map();
+let userBashQueuesByTab = new Map();
+let latestQueuedMessagesByTab = new Map();
 let abortLongPressTimer = null;
 let abortLongPressHandled = false;
 const dialogQueue = [];
@@ -194,6 +209,7 @@ 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 THINKING_VISIBILITY_STORAGE_KEY = "pi-webui-thinking-visible";
+const TOOL_OUTPUT_EXPANDED_STORAGE_KEY = "pi-webui-tool-output-expanded";
 const THEME_STORAGE_KEY = "pi-webui-theme";
 const CUSTOM_BACKGROUND_STORAGE_KEY = "pi-webui-custom-background";
 const CUSTOM_BACKGROUNDS_STORAGE_KEY = "pi-webui-custom-backgrounds";
@@ -205,6 +221,8 @@ const DEFAULT_WEBUI_PORT = "31415";
 const CUSTOM_BACKGROUND_MAX_FILE_BYTES = 24 * 1024 * 1024;
 const OPTIONAL_FEATURES_STORAGE_KEY = "pi-webui-optional-features-disabled";
 const LAST_USER_PROMPT_STORAGE_KEY = "pi-webui-last-user-prompts";
+const PROMPT_HISTORY_STORAGE_KEY = "pi-webui-prompt-history";
+const PROMPT_HISTORY_LIMIT_PER_TAB = 50;
 const ATTACHMENT_MAX_FILES = 12;
 const ATTACHMENT_MAX_FILE_BYTES = 64 * 1024 * 1024;
 const ATTACHMENT_MAX_TOTAL_BYTES = 64 * 1024 * 1024;
@@ -220,6 +238,8 @@ const STICKY_USER_PROMPT_TOP_GAP_PX = 12;
 const CHAT_FOLLOW_SETTLE_DELAY_MS = 80;
 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 RUN_INDICATOR_TICK_MS = 1000;
 const RUN_INDICATOR_START_GRACE_MS = 2500;
 const RUN_INDICATOR_STATE_RECHECK_MS = 5000;
@@ -228,10 +248,12 @@ const STREAM_OUTPUT_HIDE_DELAY_MS = 300;
 const STREAM_OUTPUT_TOOLCALL_GUARD_MS = 220;
 const STREAM_OUTPUT_MIN_VISIBLE_MS = 900;
 const TOOL_LIVE_UPDATE_THROTTLE_MS = 80;
+const UNEXPOSED_THINKING_TEXT = "No thinking content was exposed by the provider.";
 const TODO_PROGRESS_LINE_REGEX = /^\s*(?:(?:[-*]|\d+[.)])\s*)?\[(?: |x|X|-)\]\s+.+$/;
 const TODO_PROGRESS_PARTIAL_LINE_REGEX = /^\s*(?:(?:[-*]|\d+[.)])\s*)?\[(?: |x|X|-)?\]?\s*.*$/;
 const CHAT_SCROLL_KEYS = new Set(["ArrowDown", "ArrowUp", "End", "Home", "PageDown", "PageUp", " "]);
 const TAB_ACTIVITY_IDLE_RECONCILE_GRACE_MS = 1200;
+const FOREGROUND_RECONCILE_DELAY_MS = 120;
 const TAB_GROUP_STATUS_PRIORITY = ["blocked", "done", "idle", "working"];
 const EXTENSION_UI_BLOCKING_METHODS = new Set(["select", "confirm", "input", "editor"]);
 const BLOCKED_TAB_NOTIFICATION_TAG_PREFIX = "pi-webui-blocked-tab";
@@ -240,6 +262,7 @@ const BLOCKED_TAB_NOTIFICATION_ICON = "/icon-192.png";
 const mobileViewMedia = window.matchMedia?.(MOBILE_VIEW_QUERY) || null;
 const statusEntries = new Map();
 const widgets = new Map();
+const todoProgressWidgetExpandedByTab = new Map();
 const liveToolRuns = new Map();
 const liveToolCards = new Map();
 const liveToolRenderQueue = new Map();
@@ -351,6 +374,10 @@ function bindGitWorkflowToActiveTab() {
   return gitWorkflow;
 }
 
+function gitWorkflowActionTabId() {
+  return activeTabId;
+}
+
 function resetGitWorkflowForTab(tabId = activeTabId) {
   if (!tabId) return;
   gitWorkflowsByTab.set(tabId, createGitWorkflowState());
@@ -425,10 +452,12 @@ function sidePanelSectionRecords() {
 
 function readStoredSidePanelSectionCollapsedIds() {
   try {
-    const parsed = JSON.parse(localStorage.getItem(SIDE_PANEL_SECTION_STORAGE_KEY) || "[]");
+    const stored = localStorage.getItem(SIDE_PANEL_SECTION_STORAGE_KEY);
+    if (stored === null) return null;
+    const parsed = JSON.parse(stored);
     return new Set(Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : []);
   } catch {
-    return new Set();
+    return null;
   }
 }
 
@@ -453,17 +482,32 @@ function setSidePanelSectionCollapsed(record, collapsed, { persist = true } = {}
   if (persist) persistSidePanelSectionState();
 }
 
+function setOnlySidePanelSectionExpanded(targetRecord, { persist = true } = {}) {
+  const targetId = targetRecord?.id || null;
+  for (const record of sidePanelSectionRecords()) {
+    setSidePanelSectionCollapsed(record, record.id !== targetId, { persist: false });
+  }
+  if (persist) persistSidePanelSectionState();
+}
+
 function restoreSidePanelSectionState() {
+  const records = sidePanelSectionRecords();
   const collapsedIds = readStoredSidePanelSectionCollapsedIds();
-  for (const record of sidePanelSectionRecords()) {
-    setSidePanelSectionCollapsed(record, collapsedIds.has(record.id), { persist: false });
+  const expandedRecords = collapsedIds ? records.filter(({ id }) => !collapsedIds.has(id)) : [];
+  const expandedId = expandedRecords.length === 1 ? expandedRecords[0].id : null;
+  for (const record of records) {
+    setSidePanelSectionCollapsed(record, record.id !== expandedId, { persist: false });
   }
 }
 
 function bindSidePanelSectionToggles() {
   for (const record of sidePanelSectionRecords()) {
     record.button.addEventListener("click", () => {
-      setSidePanelSectionCollapsed(record, !record.section.classList.contains("collapsed"));
+      if (record.section.classList.contains("collapsed")) {
+        setOnlySidePanelSectionExpanded(record);
+      } else {
+        setSidePanelSectionCollapsed(record, true);
+      }
     });
   }
 }
@@ -551,6 +595,22 @@ function persistThinkingOutputVisible(visible) {
   }
 }
 
+function readStoredToolOutputExpanded() {
+  try {
+    return localStorage.getItem(TOOL_OUTPUT_EXPANDED_STORAGE_KEY) === "1";
+  } catch {
+    return false;
+  }
+}
+
+function persistToolOutputExpanded(expanded) {
+  try {
+    localStorage.setItem(TOOL_OUTPUT_EXPANDED_STORAGE_KEY, expanded ? "1" : "0");
+  } catch {
+    // Ignore storage failures; this can remain a page-local preference.
+  }
+}
+
 function thinkingVisibilityStatusText() {
   return thinkingOutputVisible ? "Visible" : "Hidden from transcript";
 }
@@ -578,6 +638,24 @@ function setThinkingOutputVisible(visible, { announce = false } = {}) {
   if (announce) addEvent(thinkingOutputVisible ? "thinking output shown" : "thinking output hidden", thinkingOutputVisible ? "info" : "warn");
 }
 
+function applyToolOutputExpansionToDom(expanded = toolOutputGloballyExpanded) {
+  for (const details of elements.chat.querySelectorAll(".tool-output-details, .tool-raw-details, .message.toolResult .message-collapse, .message.toolExecution details, .message.bashExecution .message-collapse")) {
+    details.open = !!expanded;
+  }
+}
+
+function setToolOutputGloballyExpanded(expanded, { announce = false, rerender = false } = {}) {
+  toolOutputGloballyExpanded = !!expanded;
+  persistToolOutputExpanded(toolOutputGloballyExpanded);
+  if (rerender) renderAllMessages({ preserveScroll: true });
+  else applyToolOutputExpansionToDom();
+  if (announce) addEvent(toolOutputGloballyExpanded ? "tool and bash output expanded" : "tool and bash output collapsed", "info");
+}
+
+function restoreToolOutputExpansionSetting() {
+  toolOutputGloballyExpanded = readStoredToolOutputExpanded();
+}
+
 function restoreThinkingVisibilitySetting() {
   thinkingOutputVisible = readStoredThinkingOutputVisible();
   renderThinkingVisibilityToggle();
@@ -590,12 +668,34 @@ function setComposerActionsOpen(open) {
   if (!shouldOpen) setPublishMenuOpen(false);
 }
 
+function isUserBashActive(tabId = activeTabId) {
+  return !!tabId && userBashByTab.has(tabId);
+}
+
+function userBashQueueForTab(tabId) {
+  if (!tabId) return [];
+  let queue = userBashQueuesByTab.get(tabId);
+  if (!queue) {
+    queue = [];
+    userBashQueuesByTab.set(tabId, queue);
+  }
+  return queue;
+}
+
+function queuedUserBashCount(tabId = activeTabId) {
+  return tabId ? userBashQueueForTab(tabId).length : 0;
+}
+
+function isUserBashRunningOrQueued(tabId = activeTabId) {
+  return isUserBashActive(tabId) || queuedUserBashCount(tabId) > 0;
+}
+
 function isRunActive() {
-  return !!currentState?.isStreaming || (runIndicatorLocallyActive && !currentState?.isCompacting);
+  return !!currentState?.isStreaming || isUserBashRunningOrQueued() || (runIndicatorLocallyActive && !currentState?.isCompacting);
 }
 
 function isAbortAvailable() {
-  return runIndicatorIsActive();
+  return runIndicatorIsActive() || isUserBashActive();
 }
 
 function resizePromptInput() {
@@ -832,6 +932,20 @@ async function copyText(text) {
   if (!copied) throw new Error("Clipboard copy failed");
 }
 
+function triggerNativeDownload(download) {
+  const url = String(download?.url || "").trim();
+  if (!url) return false;
+  const anchor = document.createElement("a");
+  anchor.href = new URL(url, window.location.href).href;
+  anchor.download = String(download.fileName || "");
+  anchor.rel = "noopener";
+  anchor.hidden = true;
+  document.body.append(anchor);
+  anchor.click();
+  anchor.remove();
+  return true;
+}
+
 async function copyServerStartCommand() {
   const command = serverStartCommandText();
   try {
@@ -2155,6 +2269,7 @@ function saveActiveDraft() {
 }
 
 function restoreActiveDraft() {
+  resetPromptHistoryNavigation();
   elements.promptInput.value = activeTabId ? tabDrafts.get(activeTabId) || "" : "";
   resizePromptInput();
   renderCommandSuggestions();
@@ -2234,8 +2349,12 @@ function resetActiveTabUi() {
   resetChatOutput();
   elements.stateDetails.replaceChildren();
   elements.eventLog.replaceChildren();
-  elements.queueBox.textContent = "No queued messages.";
-  elements.queueBox.classList.add("muted");
+  const queuedSnapshot = activeTabId ? latestQueuedMessagesByTab.get(activeTabId) : null;
+  if (queuedSnapshot) renderQueue({ tabId: activeTabId, ...queuedSnapshot });
+  else {
+    elements.queueBox.textContent = "No queued messages.";
+    elements.queueBox.classList.add("muted");
+  }
   elements.commandsBox.textContent = "Loading…";
   elements.commandsBox.classList.add("muted");
   elements.sessionLine.textContent = activeTab() ? "Connecting…" : "No terminal tabs.";
@@ -3584,6 +3703,197 @@ function scheduleRefreshFooter(delay = 300, tabContext = activeTabContext()) {
   }, delay);
 }
 
+function formatCodexPlanType(value) {
+  const text = String(value || "").trim();
+  if (!text) return "unknown plan";
+  return text.replace(/[_-]+/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase());
+}
+
+function formatCodexPercent(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? `${Math.max(0, Math.min(100, Math.round(number)))}%` : "—";
+}
+
+function codexWindowDurationMinutes(window) {
+  const minutes = Number(window?.windowDurationMins);
+  if (Number.isFinite(minutes) && minutes > 0) return minutes;
+  const seconds = Number(window?.windowDurationSeconds);
+  return Number.isFinite(seconds) && seconds > 0 ? seconds / 60 : null;
+}
+
+function formatCodexWindowDuration(window) {
+  const minutes = codexWindowDurationMinutes(window);
+  if (!minutes) return "window";
+  if (minutes >= 280 && minutes <= 320) return "5h window";
+  if (minutes >= 9500 && minutes <= 10550) return "weekly window";
+  if (minutes >= 60 * 24) {
+    const days = minutes / (60 * 24);
+    return `${days >= 10 ? Math.round(days) : Number(days.toFixed(1))}d window`;
+  }
+  if (minutes >= 60) {
+    const hours = minutes / 60;
+    return `${Number.isInteger(hours) ? hours : Number(hours.toFixed(1))}h window`;
+  }
+  return `${Math.round(minutes)}m window`;
+}
+
+function formatDurationParts(milliseconds) {
+  if (!Number.isFinite(Number(milliseconds))) return "now";
+  const totalMinutes = Math.max(0, Math.ceil(Number(milliseconds) / 60000));
+  if (totalMinutes <= 1) return "<1m";
+  if (totalMinutes < 60) return `${totalMinutes}m`;
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  if (hours < 48) return minutes ? `${hours}h ${minutes}m` : `${hours}h`;
+  const days = Math.floor(hours / 24);
+  const remHours = hours % 24;
+  return remHours ? `${days}d ${remHours}h` : `${days}d`;
+}
+
+function codexWindowResetDate(window) {
+  const resetAt = window?.resetsAt ? new Date(window.resetsAt) : null;
+  if (resetAt && Number.isFinite(resetAt.getTime())) return resetAt;
+  const resetAfterSeconds = Number(window?.resetAfterSeconds);
+  if (Number.isFinite(resetAfterSeconds) && resetAfterSeconds >= 0) return new Date(Date.now() + resetAfterSeconds * 1000);
+  return null;
+}
+
+function formatCodexReset(window) {
+  const resetDate = codexWindowResetDate(window);
+  if (!resetDate) return "reset unknown";
+  const diff = resetDate.getTime() - Date.now();
+  if (diff <= 0) return "resetting now";
+  return `resets in ${formatDurationParts(diff)}`;
+}
+
+function codexSnapshotName(snapshot) {
+  return snapshot?.limitName || snapshot?.limitId || "codex";
+}
+
+function codexUsageBuckets(data) {
+  const buckets = [];
+  const selected = data?.selected || data?.rateLimits || null;
+  const snapshots = Array.isArray(data?.snapshots) ? data.snapshots : selected ? [selected] : [];
+  const selectedKey = selected?.limitId || selected?.limitName || "codex";
+  const pushWindow = (snapshot, kind, window, { prefix } = {}) => {
+    if (!window) return;
+    const durationLabel = formatCodexWindowDuration(window);
+    const baseLabel = kind === "secondary" && durationLabel === "window" ? "secondary window" : durationLabel;
+    buckets.push({
+      key: `${snapshot?.limitId || snapshot?.limitName || buckets.length}-${kind}`,
+      label: prefix ? `${prefix} · ${baseLabel}` : baseLabel,
+      window,
+    });
+  };
+
+  if (selected) {
+    pushWindow(selected, "primary", selected.primary);
+    pushWindow(selected, "secondary", selected.secondary);
+  }
+  for (const snapshot of snapshots) {
+    const key = snapshot?.limitId || snapshot?.limitName;
+    if (!snapshot || snapshot === selected || key === selectedKey) continue;
+    const name = codexSnapshotName(snapshot);
+    pushWindow(snapshot, "primary", snapshot.primary, { prefix: name });
+    pushWindow(snapshot, "secondary", snapshot.secondary, { prefix: name });
+  }
+  return buckets.slice(0, 6);
+}
+
+function renderCodexUsage() {
+  const box = elements.codexUsageBox;
+  if (!box) return;
+  if (elements.refreshCodexUsageButton) {
+    elements.refreshCodexUsageButton.disabled = codexUsageLoading;
+    elements.refreshCodexUsageButton.textContent = codexUsageLoading ? "Refreshing…" : "Refresh usage";
+  }
+
+  box.replaceChildren();
+  box.classList.toggle("muted", !latestCodexUsage);
+
+  if (!latestCodexUsage && codexUsageLoading) {
+    box.textContent = "Checking Codex usage…";
+    return;
+  }
+  if (!latestCodexUsage && codexUsageError) {
+    const title = make("div", "codex-usage-unavailable", "Usage unavailable");
+    const detail = make("div", "codex-usage-detail", codexUsageError.message || String(codexUsageError));
+    box.append(title, detail);
+    return;
+  }
+  if (!latestCodexUsage) {
+    box.textContent = "Codex usage has not loaded yet.";
+    return;
+  }
+
+  const header = make("div", "codex-usage-summary");
+  header.append(
+    make("span", "codex-usage-plan", formatCodexPlanType(latestCodexUsage.planType)),
+    make("span", "codex-usage-fetched", latestCodexUsage.fetchedAt ? `updated ${formatDurationParts(Date.now() - new Date(latestCodexUsage.fetchedAt).getTime())} ago` : "updated now"),
+  );
+  box.append(header);
+
+  const buckets = codexUsageBuckets(latestCodexUsage);
+  if (buckets.length === 0) {
+    box.append(make("div", "codex-usage-detail", "No Codex rate-limit windows were returned."));
+  } else {
+    for (const bucket of buckets) {
+      const usedPercent = Number(bucket.window?.usedPercent);
+      const fillPercent = Number.isFinite(usedPercent) ? Math.max(0, Math.min(100, usedPercent)) : 0;
+      const item = make("div", "codex-usage-bucket");
+      const row = make("div", "codex-usage-row");
+      row.append(
+        make("span", "codex-usage-label", bucket.label),
+        make("strong", "codex-usage-percent", formatCodexPercent(bucket.window?.usedPercent)),
+      );
+      const meter = make("div", "codex-usage-meter");
+      const fill = make("span", "codex-usage-meter-fill");
+      fill.style.width = `${fillPercent}%`;
+      meter.append(fill);
+      item.append(row, meter, make("div", "codex-usage-reset", formatCodexReset(bucket.window)));
+      box.append(item);
+    }
+  }
+
+  if (latestCodexUsage.rateLimitReachedType) {
+    box.append(make("div", "codex-usage-warning", `Limit status: ${latestCodexUsage.rateLimitReachedType}`));
+  }
+  if (codexUsageError) {
+    box.append(make("div", "codex-usage-detail", `Latest refresh failed: ${codexUsageError.message || codexUsageError}`));
+  }
+}
+
+async function refreshCodexUsage({ forceAuthRefresh = false } = {}) {
+  if (codexUsageLoading) return;
+  codexUsageLoading = true;
+  renderCodexUsage();
+  try {
+    const suffix = forceAuthRefresh ? "?refresh=1" : "";
+    const response = await api(`/api/codex-usage${suffix}`, { scoped: false });
+    latestCodexUsage = response.data || null;
+    codexUsageError = null;
+  } catch (error) {
+    codexUsageError = error;
+  } finally {
+    codexUsageLoading = false;
+    renderCodexUsage();
+  }
+}
+
+function scheduleRefreshCodexUsage(delay = CODEX_USAGE_REFRESH_MS) {
+  clearTimeout(refreshCodexUsageTimer);
+  refreshCodexUsageTimer = setTimeout(() => {
+    refreshCodexUsage().finally(() => scheduleRefreshCodexUsage());
+  }, delay);
+}
+
+function initializeCodexUsage() {
+  renderCodexUsage();
+  refreshCodexUsage().finally(() => scheduleRefreshCodexUsage());
+  clearInterval(codexUsageRenderTimer);
+  codexUsageRenderTimer = setInterval(renderCodexUsage, CODEX_USAGE_RENDER_TICK_MS);
+}
+
 function renderStatus() {
   const state = currentState;
   updateComposerModeButtons();
@@ -3760,12 +4070,19 @@ function renderTodoProgressWidget(_key, lines) {
   const todo = parseTodoProgressWidget(lines);
   if (!todo) return null;
 
-  const node = make("section", "widget todo-widget");
+  const tabId = activeTabId || "default";
+  const node = make("details", "widget todo-widget");
+  node.open = todoProgressWidgetExpandedByTab.get(tabId) === true;
   node.setAttribute("aria-label", "Todo progress");
+  node.addEventListener("toggle", () => {
+    todoProgressWidgetExpandedByTab.set(tabId, node.open);
+  });
 
   const percent = todo.total > 0 ? Math.max(0, Math.min(100, (todo.done / todo.total) * 100)) : 0;
+  const summary = make("summary", "todo-widget-summary");
   const header = make("div", "todo-widget-header");
   header.append(
+    make("span", "todo-widget-toggle", "›"),
     make("span", "todo-widget-title", "Todo progress"),
     make("span", "todo-widget-count", `${todo.done}/${todo.total}`),
     make("span", "todo-widget-meta", todo.partial ? `${todo.partial} partial` : "active"),
@@ -3775,7 +4092,9 @@ function renderTodoProgressWidget(_key, lines) {
   const fill = make("span", "todo-widget-progress-fill");
   fill.style.width = `${percent}%`;
   progress.append(fill);
+  summary.append(header, progress);
 
+  const body = make("div", "todo-widget-body");
   const list = make("ol", "todo-widget-list");
   for (const item of todo.items) {
     const row = make("li", `todo-widget-item ${item.status}`);
@@ -3785,9 +4104,11 @@ function renderTodoProgressWidget(_key, lines) {
     );
     list.append(row);
   }
+  if (todo.items.length) body.append(list);
+  if (todo.footer) body.append(make("div", "todo-widget-footer", todo.footer));
 
-  node.append(header, progress, list);
-  if (todo.footer) node.append(make("div", "todo-widget-footer", todo.footer));
+  node.append(summary);
+  if (body.children.length) node.append(body);
   return node;
 }
 
@@ -3849,6 +4170,17 @@ function releaseNpmActionButton(label, command, className = "") {
   return button;
 }
 
+function releaseNpmStreamHeader(label, lineCount, { live = false } = {}) {
+  const header = make("div", "release-npm-stream-header");
+  const safeLineCount = Math.max(0, Number(lineCount) || 0);
+  header.append(
+    make("span", `release-npm-stream-dot${live ? " live" : ""}`),
+    make("span", "release-npm-stream-title", label),
+    make("span", "release-npm-stream-count", `${safeLineCount} line${safeLineCount === 1 ? "" : "s"}`),
+  );
+  return header;
+}
+
 function renderReleaseNpmOutputWidget() {
   if (!isOptionalFeatureEnabled("releaseNpm")) return null;
   const outputLines = getWidgetLines("release-npm:output");
@@ -3874,15 +4206,17 @@ function renderReleaseNpmOutputWidget() {
   );
   header.append(titleWrap, meta, actions);
 
+  const streamLines = outputLines.length ? outputLines : ["Waiting for release output..."];
+  const streamHeader = releaseNpmStreamHeader("Live output stream", outputLines.length, { live: true });
   const terminal = make("div", "release-npm-terminal");
   terminal.setAttribute("role", "log");
   terminal.setAttribute("aria-live", "polite");
-  for (const line of (outputLines.length ? outputLines : ["Waiting for release output..."])) {
+  for (const line of streamLines) {
     appendReleaseNpmTerminalLine(terminal, line);
   }
 
   const controls = make("div", "release-npm-controls", details.controls || "Controls: /release-toggle expands/collapses · /release-abort stops subprocess");
-  node.append(header, terminal, controls);
+  node.append(header, streamHeader, terminal, controls);
   requestAnimationFrame(() => { terminal.scrollTop = terminal.scrollHeight; });
   return node;
 }
@@ -3906,11 +4240,13 @@ function renderReleaseNpmLogWidget() {
   actions.append(releaseNpmActionButton("Close log", "/release-npm-logs close"));
   header.append(titleWrap, meta, actions);
 
+  const logLines = lines.slice(2).filter((line, index) => index > 0 || stripAnsi(line).trim());
+  const streamHeader = releaseNpmStreamHeader("Saved output stream", logLines.length);
   const terminal = make("div", "release-npm-terminal");
-  for (const line of lines.slice(2).filter((line, index) => index > 0 || stripAnsi(line).trim())) {
+  for (const line of logLines) {
     appendReleaseNpmTerminalLine(terminal, line);
   }
-  node.append(header, terminal);
+  node.append(header, streamHeader, terminal);
   requestAnimationFrame(() => { terminal.scrollTop = terminal.scrollHeight; });
   return node;
 }
@@ -3940,15 +4276,17 @@ function renderReleaseAurOutputWidget() {
   );
   header.append(titleWrap, meta, actions);
 
+  const streamLines = outputLines.length ? outputLines : ["Waiting for release-aur output..."];
+  const streamHeader = releaseNpmStreamHeader("Live AUR output stream", outputLines.length, { live: true });
   const terminal = make("div", "release-npm-terminal");
   terminal.setAttribute("role", "log");
   terminal.setAttribute("aria-live", "polite");
-  for (const line of (outputLines.length ? outputLines : ["Waiting for release-aur output..."])) {
+  for (const line of streamLines) {
     appendReleaseNpmTerminalLine(terminal, line);
   }
 
   const controls = make("div", "release-npm-controls", details.controls || "Controls: /release-aur toggle expands/collapses · /release-aur abort stops subprocess");
-  node.append(header, terminal, controls);
+  node.append(header, streamHeader, terminal, controls);
   requestAnimationFrame(() => { terminal.scrollTop = terminal.scrollHeight; });
   return node;
 }
@@ -3972,11 +4310,13 @@ function renderReleaseAurLogWidget() {
   actions.append(releaseNpmActionButton("Close log", "/release-aur logs close"));
   header.append(titleWrap, meta, actions);
 
+  const logLines = lines.slice(2).filter((line, index) => index > 0 || stripAnsi(line).trim());
+  const streamHeader = releaseNpmStreamHeader("Saved AUR output stream", logLines.length);
   const terminal = make("div", "release-npm-terminal");
-  for (const line of lines.slice(2).filter((line, index) => index > 0 || stripAnsi(line).trim())) {
+  for (const line of logLines) {
     appendReleaseNpmTerminalLine(terminal, line);
   }
-  node.append(header, terminal);
+  node.append(header, streamHeader, terminal);
   requestAnimationFrame(() => { terminal.scrollTop = terminal.scrollHeight; });
   return node;
 }
@@ -4112,24 +4452,24 @@ function renderGitWorkflow() {
   elements.gitWorkflowCancelButton.disabled = false;
 
   if (gitWorkflow.step === "add") {
-    addGitWorkflowAction("Run git add .", runGitAdd, "primary", false);
+    addGitWorkflowAction("Run git add .", () => runGitAdd(), "primary", false);
   } else if (gitWorkflow.step === "generate") {
-    addGitWorkflowAction("Run /git-staged-msg", runGitMessagePrompt, "primary", false);
+    addGitWorkflowAction("Run /git-staged-msg", () => runGitMessagePrompt(), "primary", false);
     addGitWorkflowAction("Preview current message files", () => loadGitWorkflowMessage({ requireFresh: false }), "", false);
   } else if (gitWorkflow.step === "generating") {
     addGitWorkflowAction("Refresh message preview", () => loadGitWorkflowMessage({ requireFresh: true }), "", false);
   } else if (gitWorkflow.step === "message") {
     addGitWorkflowAction("Commit short", () => commitGitWorkflow("short"), "primary", false);
     addGitWorkflowAction("Commit long", () => commitGitWorkflow("long"), "primary", false);
-    addGitWorkflowAction("Regenerate", runGitMessagePrompt, "", false);
+    addGitWorkflowAction("Regenerate", () => runGitMessagePrompt(), "", false);
   } else if (gitWorkflow.step === "push") {
-    addGitWorkflowAction("Run git push", pushGitWorkflow, "primary", false);
+    addGitWorkflowAction("Run git push", () => pushGitWorkflow(), "primary", false);
   } else if (gitWorkflow.step === "done") {
     addGitWorkflowAction("Close", () => setGitWorkflow({ active: false }), "primary", false);
-    addGitWorkflowAction("Start another", startGitWorkflow, "", false);
+    addGitWorkflowAction("Start another", () => startGitWorkflow(), "", false);
   } else if (["cancelled", "error"].includes(gitWorkflow.step)) {
     addGitWorkflowAction("Close", () => setGitWorkflow({ active: false }), "primary", false);
-    addGitWorkflowAction("Restart", startGitWorkflow, "", false);
+    addGitWorkflowAction("Restart", () => startGitWorkflow(), "", false);
   }
 }
 
@@ -4157,8 +4497,7 @@ function failGitWorkflow(error, step, { tabId = activeTabId } = {}) {
   }, { tabId });
 }
 
-function startGitWorkflow() {
-  const tabId = activeTabId;
+function startGitWorkflow(tabId = activeTabId) {
   if (!tabId) return;
   if (!isOptionalFeatureEnabled("gitWorkflow")) {
     const tabContext = activeTabContext(tabId);
@@ -4182,8 +4521,7 @@ function startGitWorkflow() {
   }, { tabId });
 }
 
-async function cancelGitWorkflow() {
-  const tabId = activeTabId;
+async function cancelGitWorkflow(tabId = gitWorkflowActionTabId()) {
   const tabContext = activeTabContext(tabId);
   const workflow = gitWorkflowForTab(tabId, { create: false });
   if (!workflow?.active) return;
@@ -4198,8 +4536,7 @@ async function cancelGitWorkflow() {
   if (shouldAbortPi && isCurrentTabContext(tabContext)) scheduleAbortStateChecks();
 }
 
-async function runGitAdd() {
-  const tabId = activeTabId;
+async function runGitAdd(tabId = gitWorkflowActionTabId()) {
   const tabContext = activeTabContext(tabId);
   const workflow = gitWorkflowForTab(tabId, { create: false });
   if (!workflow) return;
@@ -4215,10 +4552,11 @@ async function runGitAdd() {
   }
 }
 
-async function runGitMessagePrompt() {
-  const tabId = activeTabId;
+async function runGitMessagePrompt(tabId = gitWorkflowActionTabId()) {
   const tabContext = activeTabContext(tabId);
-  if (currentState?.isStreaming) {
+  const targetTab = tabs.find((tab) => tab.id === tabId);
+  const targetBusy = tabId === activeTabId ? !!currentState?.isStreaming : activityForTab(targetTab).isWorking;
+  if (targetBusy) {
     failGitWorkflow(new Error("Pi is currently running. Wait for it to finish or abort before generating a staged commit message."), "generate", { tabId });
     return;
   }
@@ -4241,7 +4579,8 @@ async function runGitMessagePrompt() {
     if (isCurrentTabContext(tabContext)) scheduleRefreshState(120, tabContext);
     setTimeout(() => {
       const currentWorkflow = gitWorkflowForTab(tabId, { create: false });
-      if (isCurrentTabContext(tabContext) && isCurrentGitWorkflowRun(runId, tabId) && currentWorkflow?.step === "generating" && !currentState?.isStreaming) {
+      const targetStillBusy = tabId === activeTabId && currentState?.isStreaming;
+      if (isCurrentGitWorkflowRun(runId, tabId) && currentWorkflow?.step === "generating" && !targetStillBusy) {
         loadGitWorkflowMessage({ requireFresh: true, retries: 1, runId, tabId });
       }
     }, 2500);
@@ -4283,8 +4622,7 @@ async function loadGitWorkflowMessage({ requireFresh = false, retries = 0, runId
   }
 }
 
-async function commitGitWorkflow(variant) {
-  const tabId = activeTabId;
+async function commitGitWorkflow(variant, tabId = gitWorkflowActionTabId()) {
   const tabContext = activeTabContext(tabId);
   const workflow = gitWorkflowForTab(tabId, { create: false });
   if (!workflow) return;
@@ -4300,8 +4638,7 @@ async function commitGitWorkflow(variant) {
   }
 }
 
-async function pushGitWorkflow() {
-  const tabId = activeTabId;
+async function pushGitWorkflow(tabId = gitWorkflowActionTabId()) {
   const tabContext = activeTabContext(tabId);
   const workflow = gitWorkflowForTab(tabId, { create: false });
   if (!workflow) return;
@@ -4321,19 +4658,31 @@ function resumeGitWorkflowForActiveTab(tabContext = activeTabContext()) {
   if (!isCurrentTabContext(tabContext)) return;
   bindGitWorkflowToActiveTab();
   renderGitWorkflow();
-  if (gitWorkflow.active && gitWorkflow.step === "generating" && !currentState?.isStreaming) {
+  const workflowTabId = gitWorkflowActionTabId();
+  if (workflowTabId === tabContext.tabId && gitWorkflow.active && gitWorkflow.step === "generating" && !currentState?.isStreaming) {
     const retryDelayMs = Math.max(0, 2500 - (Date.now() - (gitWorkflow.messageRequestedAt || 0)));
     if (retryDelayMs > 0) {
       setTimeout(() => resumeGitWorkflowForActiveTab(tabContext), retryDelayMs);
       return;
     }
-    loadGitWorkflowMessage({ requireFresh: true, retries: 3, runId: gitWorkflow.runId, tabId: tabContext.tabId });
+    loadGitWorkflowMessage({ requireFresh: true, retries: 3, runId: gitWorkflow.runId, tabId: workflowTabId });
   }
 }
 
+function normalizeQueuedMessages(event) {
+  const normalize = (items) => (Array.isArray(items) ? items.map((item) => String(item || "")).filter((item) => item.trim()) : []);
+  return {
+    steering: normalize(event?.steering),
+    followUp: normalize(event?.followUp),
+  };
+}
+
 function renderQueue(event) {
-  const steering = event?.steering || [];
-  const followUp = event?.followUp || [];
+  const snapshot = normalizeQueuedMessages(event);
+  const tabId = event?.tabId || activeTabId;
+  if (tabId) latestQueuedMessagesByTab.set(tabId, snapshot);
+  const steering = snapshot.steering;
+  const followUp = snapshot.followUp;
   if (steering.length === 0 && followUp.length === 0) {
     elements.queueBox.textContent = "No queued messages.";
     elements.queueBox.classList.add("muted");
@@ -4343,9 +4692,32 @@ function renderQueue(event) {
   const lines = [];
   if (steering.length) lines.push(`Steering (${steering.length}):`, ...steering.map((item) => `• ${item}`));
   if (followUp.length) lines.push(`Follow-up (${followUp.length}):`, ...followUp.map((item) => `• ${item}`));
+  lines.push("↳ Alt+Up restores the latest observed queue snapshot to the composer (RPC queue clearing is pending upstream support).");
   elements.queueBox.textContent = lines.join("\n");
 }
 
+function queuedMessagesForComposer(tabId = activeTabId) {
+  const snapshot = latestQueuedMessagesByTab.get(tabId) || { steering: [], followUp: [] };
+  return [...(snapshot.steering || []), ...(snapshot.followUp || [])].map((item) => String(item || "").trim()).filter(Boolean);
+}
+
+function restoreQueuedMessagesToComposerFromShortcut() {
+  const queued = queuedMessagesForComposer();
+  if (queued.length === 0) {
+    addEvent("no queued messages to restore", "warn");
+    return false;
+  }
+  const queuedText = queued.join("\n\n");
+  const currentText = elements.promptInput.value || "";
+  elements.promptInput.value = [queuedText, currentText].filter((item) => item.trim()).join("\n\n");
+  resizePromptInput();
+  renderCommandSuggestions();
+  saveActiveDraft();
+  focusPromptInput({ defer: true });
+  addEvent(`restored ${queued.length} queued message${queued.length === 1 ? "" : "s"} to composer; Pi's RPC queue is still pending upstream clear support`, "warn");
+  return true;
+}
+
 function appendText(parent, text, className = "text-block") {
   const block = make("pre", className);
   block.textContent = text || "";
@@ -4907,11 +5279,12 @@ function renderContent(parent, content, { markdown = false } = {}) {
       if (markdown) appendMarkdown(parent, stripTodoProgressLines(text));
       else appendText(parent, text);
     } else if (part.type === "thinking") {
-      if (!thinkingOutputVisible) continue;
+      const thinking = visibleThinkingText(assistantThinkingText(part));
+      if (!thinkingOutputVisible || !thinking) continue;
       const details = make("details", "thinking-block");
       details.open = true;
       details.append(make("summary", undefined, "thinking"));
-      appendText(details, part.thinking || "No thinking content was exposed by the provider.", "thinking-text");
+      appendText(details, thinking, "thinking-text");
       parent.append(details);
     } else if (part.type === "toolCall") {
       const details = make("details");
@@ -4947,6 +5320,13 @@ function assistantThinkingText(part) {
   return typeof part.content === "string" ? part.content : "";
 }
 
+function visibleThinkingText(text) {
+  const value = String(text || "");
+  const trimmed = value.trim();
+  if (!trimmed || trimmed === UNEXPOSED_THINKING_TEXT) return "";
+  return value;
+}
+
 function isAssistantToolCallPart(part) {
   return !!(part && typeof part === "object" && (part.type === "toolCall" || part.toolCall));
 }
@@ -5008,8 +5388,8 @@ function assistantDisplayMessages(message) {
     const part = content[index];
     const isThinkingPart = part && typeof part === "object" && (part.type === "thinking" || typeof part.thinking === "string");
     if (isThinkingPart) {
-      const thinking = assistantThinkingText(part) || "No thinking content was exposed by the provider.";
-      displayMessages.push({ ...base, role: "thinking", title: "thinking", content: thinking, thinking });
+      const thinking = visibleThinkingText(assistantThinkingText(part));
+      if (thinking) displayMessages.push({ ...base, role: "thinking", title: "thinking", content: thinking, thinking });
       continue;
     }
     if (isAssistantToolCallPart(part)) {
@@ -5051,6 +5431,136 @@ function stickyUserPromptPreview(message) {
   return stickyUserPromptPreviewText(messageUserPromptText(message));
 }
 
+function promptHistoryText(value) {
+  return stripAnsi(String(value ?? "")).replace(/\r\n?/g, "\n").trim();
+}
+
+function promptHistoryMessageText(message) {
+  if (message?.role !== "user") return "";
+  const text = promptHistoryText(textFromContent(message.content));
+  return text.startsWith("/") ? "" : text;
+}
+
+function promptHistoryForTab(tabId = activeTabId) {
+  if (!tabId) return [];
+  return promptHistoryByTab.get(tabId) || [];
+}
+
+function promptHistoryWithEntry(history, text) {
+  const prompt = promptHistoryText(text);
+  if (!prompt) return history || [];
+  return [...(history || []).filter((entry) => entry !== prompt), prompt].slice(-PROMPT_HISTORY_LIMIT_PER_TAB);
+}
+
+function promptHistoryEqual(left = [], right = []) {
+  return left.length === right.length && left.every((entry, index) => entry === right[index]);
+}
+
+function setPromptHistoryForTab(tabId, history, { persist = true } = {}) {
+  if (!tabId) return;
+  const entries = (history || []).map(promptHistoryText).filter(Boolean).slice(-PROMPT_HISTORY_LIMIT_PER_TAB);
+  if (entries.length) promptHistoryByTab.set(tabId, entries);
+  else promptHistoryByTab.delete(tabId);
+  if (persist) persistPromptHistoryCache();
+}
+
+function loadPromptHistoryCache() {
+  try {
+    const raw = JSON.parse(localStorage.getItem(PROMPT_HISTORY_STORAGE_KEY) || "{}");
+    promptHistoryByTab = new Map(Object.entries(raw)
+      .map(([tabId, entries]) => [tabId, Array.isArray(entries) ? entries.map(promptHistoryText).filter(Boolean).slice(-PROMPT_HISTORY_LIMIT_PER_TAB) : []])
+      .filter(([, entries]) => entries.length));
+  } catch {
+    promptHistoryByTab = new Map();
+  }
+}
+
+function persistPromptHistoryCache() {
+  try {
+    const entries = [...promptHistoryByTab.entries()]
+      .filter(([tabId, history]) => tabId && Array.isArray(history) && history.length)
+      .slice(-24)
+      .map(([tabId, history]) => [tabId, history.slice(-PROMPT_HISTORY_LIMIT_PER_TAB)]);
+    localStorage.setItem(PROMPT_HISTORY_STORAGE_KEY, JSON.stringify(Object.fromEntries(entries)));
+  } catch {
+    // Ignore storage failures; in-memory prompt history still works for this page load.
+  }
+}
+
+function rememberPromptHistory(text, { tabId = activeTabId } = {}) {
+  if (!tabId) return;
+  setPromptHistoryForTab(tabId, promptHistoryWithEntry(promptHistoryForTab(tabId), text));
+}
+
+function syncPromptHistoryFromMessages(messages = latestMessages) {
+  if (!activeTabId) return;
+  const prompts = (messages || []).map(promptHistoryMessageText).filter(Boolean);
+  if (!prompts.length) return;
+  const currentHistory = promptHistoryForTab(activeTabId);
+  let nextHistory = currentHistory;
+  for (const prompt of prompts) nextHistory = promptHistoryWithEntry(nextHistory, prompt);
+  if (!promptHistoryEqual(currentHistory, nextHistory)) setPromptHistoryForTab(activeTabId, nextHistory);
+}
+
+function resetPromptHistoryNavigation() {
+  promptHistoryNavigation = null;
+}
+
+function activePromptHistoryNavigation(history = promptHistoryForTab()) {
+  if (!promptHistoryNavigation || promptHistoryNavigation.tabId !== activeTabId) return null;
+  const index = promptHistoryNavigation.index;
+  if (!Number.isInteger(index) || index < 0 || index >= history.length || elements.promptInput.value !== history[index]) {
+    resetPromptHistoryNavigation();
+    return null;
+  }
+  return promptHistoryNavigation;
+}
+
+function applyPromptHistoryValue(value) {
+  const input = elements.promptInput;
+  input.value = value || "";
+  resizePromptInput();
+  try {
+    input.setSelectionRange(input.value.length, input.value.length);
+  } catch {
+    // Some input implementations can reject selection updates; history recall still worked.
+  }
+  hideCommandSuggestions();
+}
+
+function recallPreviousPromptFromHistory() {
+  if (!activeTabId) return false;
+  const history = promptHistoryForTab(activeTabId);
+  if (!history.length) return false;
+  const navigation = activePromptHistoryNavigation(history);
+  if (!navigation && elements.promptInput.value.trim()) return false;
+  const index = navigation ? Math.max(0, navigation.index - 1) : history.length - 1;
+  promptHistoryNavigation = {
+    tabId: activeTabId,
+    index,
+    draft: navigation ? navigation.draft : elements.promptInput.value || "",
+  };
+  applyPromptHistoryValue(history[index]);
+  return true;
+}
+
+function recallNextPromptFromHistory() {
+  if (!activeTabId) return false;
+  const history = promptHistoryForTab(activeTabId);
+  const navigation = activePromptHistoryNavigation(history);
+  if (!navigation) return false;
+  if (navigation.index >= history.length - 1) {
+    const draft = navigation.draft || "";
+    resetPromptHistoryNavigation();
+    applyPromptHistoryValue(draft);
+    return true;
+  }
+  const index = navigation.index + 1;
+  promptHistoryNavigation = { ...navigation, index };
+  applyPromptHistoryValue(history[index]);
+  return true;
+}
+
 function loadLastUserPromptCache() {
   try {
     const raw = JSON.parse(localStorage.getItem(LAST_USER_PROMPT_STORAGE_KEY) || "{}");
@@ -5126,8 +5636,18 @@ function stickyUserPromptViewportGap() {
 
 function resetChatOutput() {
   liveToolCards.clear();
-  elements.chat.replaceChildren();
-  if (elements.stickyUserPromptButton) elements.chat.append(elements.stickyUserPromptButton);
+  const preservedNodes = [];
+  if (elements.stickyUserPromptButton) preservedNodes.push(elements.stickyUserPromptButton);
+  if (runIndicatorBubble?.parentElement === elements.chat) preservedNodes.push(runIndicatorBubble);
+  elements.chat.replaceChildren(...preservedNodes);
+}
+
+function appendChatMessageBubble(bubble) {
+  if (runIndicatorBubble?.parentElement === elements.chat && bubble !== runIndicatorBubble) {
+    elements.chat.insertBefore(bubble, runIndicatorBubble);
+  } else {
+    elements.chat.append(bubble);
+  }
 }
 
 function userPromptTargets() {
@@ -5339,7 +5859,7 @@ function appendToolOutput(parent, text, { label = "output", previewLines = 10, p
   const lines = clean.split(/\r?\n/);
   if (lines.length > previewLines) {
     const details = make("details", "tool-output-details");
-    details.open = open;
+    details.open = open || toolOutputGloballyExpanded;
     details.append(make("summary", "tool-output-summary", `${label} (${lines.length} lines; expand)`));
     appendText(details, clean, "code-block tool-output-code");
     parent.append(details);
@@ -5449,6 +5969,37 @@ function appendToolRawDetails(parent, tool) {
   parent.append(details);
 }
 
+function toolRenderSignatureReplacer() {
+  const seen = new WeakSet();
+  return (key, value) => {
+    if (typeof value === "bigint") return `${value}n`;
+    if (typeof value === "string" && value.length > 8000) return `${value.slice(0, 4000)}…${value.slice(-4000)} (${value.length} chars)`;
+    if (value && typeof value === "object") {
+      if (seen.has(value)) return "[Circular]";
+      seen.add(value);
+    }
+    return toolRawDetailsReplacer(key, value);
+  };
+}
+
+function toolExecutionRenderSignature(message) {
+  const tool = normalizeToolExecution(message);
+  try {
+    return JSON.stringify({
+      name: tool.name,
+      args: tool.args,
+      result: tool.result,
+      details: tool.details,
+      isPartial: tool.isPartial,
+      isError: tool.isError,
+      startedAt: tool.startedAt,
+      endedAt: tool.endedAt,
+    }, toolRenderSignatureReplacer());
+  } catch {
+    return `${message?.toolName || message?.name || "tool"}|${message?.toolCallId || ""}|${message?.isPartial ? "partial" : "final"}|${message?.isError ? "error" : "ok"}`;
+  }
+}
+
 function renderBashToolExecution(parent, tool) {
   const command = toolArgText(tool.args, "command", "");
   const timeout = toolArgValue(tool.args, "timeout");
@@ -5550,9 +6101,15 @@ function liveToolRunMessage(run) {
 
 function applyToolExecutionBubbleState(bubble, message) {
   const status = toolExecutionStatus(message);
-  bubble.classList.remove("tool-pending", "tool-running", "tool-success", "tool-error", "error");
-  bubble.classList.add(`tool-${status}`);
-  if (message.isError || status === "error") bubble.classList.add("error");
+  const nextClass = `tool-${status}`;
+  if (bubble.dataset.toolStatus !== status || !bubble.classList.contains(nextClass)) {
+    for (const className of ["tool-pending", "tool-running", "tool-success", "tool-error"]) {
+      if (className !== nextClass) bubble.classList.remove(className);
+    }
+    bubble.classList.add(nextClass);
+    bubble.dataset.toolStatus = status;
+  }
+  bubble.classList.toggle("error", !!(message.isError || status === "error"));
   if (message.toolCallId) {
     const id = String(message.toolCallId);
     bubble.dataset.toolCallId = id;
@@ -5615,7 +6172,7 @@ function reuseToolExecutionBubble(reusableToolCards, message, { streaming = fals
     bubble.removeAttribute("data-user-prompt");
   }
   if (!streaming && !transient) renderActionFeedbackControls(bubble, message, messageIndex);
-  elements.chat.append(bubble);
+  appendChatMessageBubble(bubble);
   return { bubble, body };
 }
 
@@ -5629,10 +6186,13 @@ function updateLiveToolCard(bubble, message) {
   if (role) role.textContent = messageTitle(message);
   const timestamp = header?.querySelector(".muted");
   if (timestamp) timestamp.textContent = formatDate(message.timestamp);
+  const nextRenderSignature = toolExecutionRenderSignature(message);
+  if (bubble._toolRenderSignature === nextRenderSignature && body.childElementCount > 0) return true;
   const detailsOpenState = captureToolDetailsOpenState(body);
   body.replaceChildren();
   renderToolExecution(body, message);
   restoreToolDetailsOpenState(body, detailsOpenState);
+  bubble._toolRenderSignature = nextRenderSignature;
   return true;
 }
 
@@ -5779,9 +6339,10 @@ function appendMessage(message, { streaming = false, messageIndex = -1, transien
     if (message.isError) bubble.classList.add("error");
   } else if (message.role === "toolExecution") {
     renderToolExecution(body, message);
+    bubble._toolRenderSignature = toolExecutionRenderSignature(message);
   } else if (message.role === "thinking") {
-    const thinkingText = message.thinking || textFromContent(message.content);
-    if (thinkingOutputVisible && (thinkingText || !streaming)) appendText(body, thinkingText || "No thinking content was exposed by the provider.", "thinking-text");
+    const thinkingText = visibleThinkingText(message.thinking || textFromContent(message.content));
+    if (thinkingOutputVisible && thinkingText) appendText(body, thinkingText, "thinking-text");
   } else if (message.role === "toolCall") {
     appendText(body, JSON.stringify(message.arguments ?? message.content ?? {}, null, 2), "code-block");
   } else if (message.role === "assistantEvent") {
@@ -5792,7 +6353,7 @@ function appendMessage(message, { streaming = false, messageIndex = -1, transien
 
   if (isCollapsibleOutput) {
     const details = make("details", "message-collapse");
-    if (message.isError) details.open = true;
+    if (message.isError || toolOutputGloballyExpanded) details.open = true;
     details.append(header, body);
     bubble.append(details);
     if (message.role === "toolResult" && !message.isError) {
@@ -5806,7 +6367,7 @@ function appendMessage(message, { streaming = false, messageIndex = -1, transien
     bubble.append(header, body);
   }
   if (!streaming && !transient) renderActionFeedbackControls(bubble, message, messageIndex);
-  elements.chat.append(bubble);
+  appendChatMessageBubble(bubble);
   return { bubble, body };
 }
 
@@ -5849,11 +6410,11 @@ function appendTranscriptMessage(message, { streaming = false, messageIndex = -1
 }
 
 function stateHasRunIndicatorActivity(state = currentState) {
-  return !!state?.isStreaming || !!state?.isCompacting;
+  return !!state?.isStreaming || !!state?.isCompacting || isUserBashActive();
 }
 
 function runIndicatorIsActive() {
-  return runIndicatorLocallyActive || stateHasRunIndicatorActivity(currentState);
+  return runIndicatorLocallyActive || stateHasRunIndicatorActivity(currentState) || isUserBashActive();
 }
 
 function clearRunIndicatorGraceCheck() {
@@ -5926,22 +6487,24 @@ function stopRunIndicatorTicker() {
   runIndicatorTimer = null;
 }
 
+function createRunIndicatorBubble() {
+  runIndicatorBubble = make("article", "message runIndicator run-indicator-message streaming");
+  runIndicatorBubble.setAttribute("aria-live", "polite");
+  runIndicatorBubble.setAttribute("aria-label", "Agent is running:");
+
+  const body = make("div", "message-body");
+  const row = make("div", "run-indicator-row");
+  const pulse = make("span", "run-indicator-pulse");
+  pulse.setAttribute("aria-hidden", "true");
+  runIndicatorText = make("span", "run-indicator-text");
+  runIndicatorMeta = make("span", "run-indicator-meta");
+  row.append(pulse, runIndicatorText, runIndicatorMeta);
+  body.append(row);
+  runIndicatorBubble.append(body);
+}
+
 function ensureRunIndicatorBubble() {
-  if (runIndicatorBubble?.parentElement !== elements.chat) {
-    runIndicatorBubble = make("article", "message runIndicator run-indicator-message streaming");
-    runIndicatorBubble.setAttribute("aria-live", "polite");
-    runIndicatorBubble.setAttribute("aria-label", "Agent is running:");
-
-    const body = make("div", "message-body");
-    const row = make("div", "run-indicator-row");
-    const pulse = make("span", "run-indicator-pulse");
-    pulse.setAttribute("aria-hidden", "true");
-    runIndicatorText = make("span", "run-indicator-text");
-    runIndicatorMeta = make("span", "run-indicator-meta");
-    row.append(pulse, runIndicatorText, runIndicatorMeta);
-    body.append(row);
-    runIndicatorBubble.append(body);
-  }
+  if (!runIndicatorBubble || !runIndicatorText || !runIndicatorMeta) createRunIndicatorBubble();
   if (elements.chat.lastElementChild !== runIndicatorBubble) elements.chat.append(runIndicatorBubble);
 }
 
@@ -5949,9 +6512,11 @@ function updateRunIndicatorBubble() {
   if (!runIndicatorIsActive()) return;
   if (!runIndicatorStartedAt) runIndicatorStartedAt = performance.now();
   ensureRunIndicatorBubble();
-  runIndicatorText.textContent = runIndicatorHeadline();
+  const headline = runIndicatorHeadline();
+  if (runIndicatorText.textContent !== headline) runIndicatorText.textContent = headline;
   const detail = runIndicatorDetail();
-  runIndicatorMeta.textContent = runIndicatorShowsElapsed() ? `${detail} · run time ${formatRunIndicatorElapsed()}` : detail;
+  const meta = runIndicatorShowsElapsed() ? `${detail} · run time ${formatRunIndicatorElapsed()}` : detail;
+  if (runIndicatorMeta.textContent !== meta) runIndicatorMeta.textContent = meta;
 }
 
 function removeRunIndicatorBubble() {
@@ -6124,6 +6689,7 @@ function renderAllMessages({ preserveScroll = false } = {}) {
     });
   }
   rememberActionEntries(transcriptItems);
+  applyToolOutputExpansionToDom();
   renderRunIndicator({ scroll: false });
   updateStickyUserPromptButton();
   if (shouldFollow) scrollChatToBottom({ force: true });
@@ -6135,12 +6701,13 @@ function renderAllMessages({ preserveScroll = false } = {}) {
   updateStickyUserPromptButton();
 }
 
-function addTransientMessage({ role = "notice", title, content, level = "info" }) {
+function addTransientMessage({ role = "notice", title, content, level = "info", ...details }) {
   transientMessages.push({
     role,
     title,
     level,
     content,
+    ...details,
     timestamp: Date.now(),
   });
   if (transientMessages.length > 80) transientMessages.splice(0, transientMessages.length - 80);
@@ -6954,6 +7521,7 @@ function renderMessages(messages) {
   latestMessages = messages || [];
   cleanupLiveToolRunsForMessages(latestMessages);
   syncLastUserPromptFromMessages(latestMessages);
+  syncPromptHistoryFromMessages(latestMessages);
   renderAllMessages();
   renderFooter();
   renderFeedbackTray();
@@ -7037,9 +7605,9 @@ function ensureStreamingThinkingBubble() {
   return true;
 }
 
-function showStreamingThinking(placeholder = "Thinking…") {
+function showStreamingThinking(initialText = "") {
   if (!ensureStreamingThinkingBubble()) return;
-  if (!streamThinking.textContent) streamThinking.textContent = placeholder;
+  if (initialText && !streamThinking.textContent) streamThinking.textContent = initialText;
 }
 
 function resetStreamBubble() {
@@ -7055,7 +7623,7 @@ function resetStreamBubble() {
 }
 
 function thinkingDeltaText(update) {
-  return update.delta || update.thinking || update.content || "";
+  return visibleThinkingText(update.delta || update.thinking || update.content || "");
 }
 
 function assistantStreamingMessage(event) {
@@ -7082,37 +7650,38 @@ function assistantThinkingTextFromMessage(message) {
   if (!Array.isArray(content)) return null;
   const parts = content
     .filter((part) => part && typeof part === "object" && (part.type === "thinking" || typeof part.thinking === "string"))
-    .map((part) => assistantThinkingText(part))
+    .map((part) => visibleThinkingText(assistantThinkingText(part)))
     .filter((text) => text.trim());
   return parts.length ? parts.join("\n\n") : "";
 }
 
 function setStreamingThinkingText(text) {
-  if (!thinkingOutputVisible) return;
+  const thinking = visibleThinkingText(text);
+  if (!thinkingOutputVisible || !thinking) return false;
   showStreamingThinking("");
-  if (streamThinking) streamThinking.textContent = text;
+  if (streamThinking) streamThinking.textContent = thinking;
+  return true;
 }
 
 function syncStreamingThinkingFromMessage(event, { placeholder = "" } = {}) {
   if (!thinkingOutputVisible) return true;
   const text = assistantThinkingTextFromMessage(assistantStreamingMessage(event));
   if (text === null) return false;
-  if (text || placeholder || streamThinkingBubble) setStreamingThinkingText(text || placeholder);
-  return true;
+  return setStreamingThinkingText(text || placeholder);
 }
 
 function handleMessageUpdate(event) {
   const update = event.assistantMessageEvent || {};
   if (update.type === "thinking_start") {
     setRunIndicatorActivity("Thinking…", { scroll: false });
-    syncStreamingThinkingFromMessage(event, { placeholder: "Thinking…" });
+    syncStreamingThinkingFromMessage(event);
     scrollChatToBottom();
   } else if (update.type === "thinking_delta") {
     const delta = thinkingDeltaText(update);
     currentRunStreamChars += delta.length;
     setRunIndicatorActivity("Thinking…", { scroll: false });
     const synced = syncStreamingThinkingFromMessage(event);
-    if (thinkingOutputVisible && (!synced || (!streamThinking?.textContent && delta))) {
+    if (thinkingOutputVisible && delta && (!synced || !streamThinking?.textContent)) {
       showStreamingThinking("");
       if (streamThinking?.textContent === "Thinking…") streamThinking.textContent = "";
       if (streamThinking) streamThinking.textContent += delta;
@@ -7732,6 +8301,35 @@ async function refreshAll(tabContext = activeTabContext()) {
   resumeGitWorkflowForActiveTab(tabContext);
 }
 
+function ensureActiveEventStream(tabContext = activeTabContext()) {
+  if (!tabContext.tabId || !isCurrentTabContext(tabContext)) return;
+  if (!eventSource || eventSource.readyState === EventSource.CLOSED) connectEvents(tabContext);
+}
+
+async function reconcileForegroundState(reason = "resume") {
+  if (document.visibilityState === "hidden") return;
+
+  const tabResult = await Promise.allSettled([refreshTabs()]);
+  const tabContext = activeTabContext();
+  ensureActiveEventStream(tabContext);
+
+  const results = [...tabResult];
+  if (tabContext.tabId) results.push(...(await Promise.allSettled([refreshAll(tabContext)])));
+  if (!isCurrentTabContext(tabContext)) return;
+
+  for (const result of results) {
+    if (result.status === "rejected") addEvent(`foreground refresh failed after ${reason}: ${result.reason?.message || String(result.reason)}`, "error");
+  }
+}
+
+function scheduleForegroundReconcile(reason = "resume", delay = FOREGROUND_RECONCILE_DELAY_MS) {
+  clearTimeout(foregroundReconcileTimer);
+  foregroundReconcileTimer = setTimeout(() => {
+    foregroundReconcileTimer = null;
+    reconcileForegroundState(reason).catch((error) => addEvent(`foreground refresh failed after ${reason}: ${error.message || String(error)}`, "error"));
+  }, delay);
+}
+
 async function openToNetwork() {
   if (latestNetwork?.open) {
     await closeNetworkAccess();
@@ -7806,6 +8404,216 @@ async function closeNetworkAccess() {
   }
 }
 
+async function stopServer() {
+  if (!confirm("Stop the Pi Web UI server?\n\nThis disconnects all browser clients and stops the Pi tabs managed by this Web UI.")) return;
+
+  const button = elements.stopServerButton;
+  button.disabled = true;
+  button.textContent = "Stopping…";
+  try {
+    await api("/api/shutdown", { method: "POST", scoped: false });
+    addEvent("Pi Web UI server stop requested", "warn");
+    setBackendOffline(true, new Error("stop requested from side panel"));
+  } catch (error) {
+    if (error?.backendOffline) {
+      addEvent("Pi Web UI server appears to be offline after stop request", "warn");
+      setBackendOffline(true, error);
+      return;
+    }
+    addEvent(error.message || String(error), "error");
+    button.disabled = false;
+    button.textContent = "Stop Server";
+  }
+}
+
+function appShortcutModelLabel(model) {
+  return model ? `${model.provider}/${model.id}` : "unknown model";
+}
+
+async function cycleModelFromShortcut(direction = "forward") {
+  const tabContext = activeTabContext();
+  if (!tabContext.tabId) return;
+  try {
+    const response = await api("/api/model-cycle", { method: "POST", body: { direction }, tabId: tabContext.tabId });
+    applyResponseTab(response);
+    const model = response.data?.model;
+    const scope = response.data?.scoped ? `scoped (${response.data.scopeSource})` : "all models";
+    if (isCurrentTabContext(tabContext)) {
+      addTransientMessage({ role: "native", title: "model cycle", content: `Model set to ${appShortcutModelLabel(model)} via ${direction} cycle over ${scope}.`, level: "info" });
+      await Promise.allSettled([refreshState(tabContext), refreshModels(tabContext), refreshStats(tabContext)]);
+    }
+  } catch (error) {
+    if (isCurrentTabContext(tabContext)) {
+      addEvent(error.message, "error");
+      addTransientMessage({ role: "error", title: "model cycle", content: error.message, level: "error" });
+    }
+  }
+}
+
+async function cycleThinkingFromShortcut() {
+  const tabContext = activeTabContext();
+  if (!tabContext.tabId) return;
+  try {
+    const response = await api("/api/thinking-cycle", { method: "POST", body: {}, tabId: tabContext.tabId });
+    if (response.data?.level && currentState) currentState = { ...currentState, thinkingLevel: response.data.level };
+    if (isCurrentTabContext(tabContext)) {
+      addTransientMessage({ role: "native", title: "thinking", content: response.data?.level ? `Thinking level: ${response.data.level}` : "Thinking level did not change.", level: "info" });
+      await Promise.allSettled([refreshState(tabContext), refreshStats(tabContext)]);
+    }
+  } catch (error) {
+    if (isCurrentTabContext(tabContext)) {
+      addEvent(error.message, "error");
+      addTransientMessage({ role: "error", title: "thinking", content: error.message, level: "error" });
+    }
+  }
+}
+
+function clearPromptFromShortcut() {
+  const input = elements.promptInput;
+  if (document.activeElement !== input) return false;
+  if (input.selectionStart !== input.selectionEnd) return false;
+  if (!input.value) return false;
+  input.value = "";
+  resizePromptInput();
+  renderCommandSuggestions();
+  addEvent("prompt cleared", "info");
+  return true;
+}
+
+function parseUserBashInput(message) {
+  const text = String(message || "").trim();
+  if (!text.startsWith("!") || text === "!" || text === "!!") return null;
+  const excludeFromContext = text.startsWith("!!");
+  const command = text.slice(excludeFromContext ? 2 : 1).trim();
+  if (!command) return null;
+  return { command, excludeFromContext };
+}
+
+function userBashOutputSummary(result = {}, excludeFromContext = false) {
+  const output = String(result.output || "").trimEnd();
+  const status = result.cancelled ? "cancelled" : result.exitCode === 0 ? "exit 0" : result.exitCode === undefined || result.exitCode === null ? "finished" : `exit ${result.exitCode}`;
+  const context = excludeFromContext ? "excluded from LLM context" : "included in the next LLM context";
+  const lines = [`# ${status}; ${context}`];
+  if (output) lines.push("", output);
+  if (result.truncated && result.fullOutputPath) lines.push("", `Full output: ${result.fullOutputPath}`);
+  return lines.join("\n");
+}
+
+function clearComposerAfterUserBash({ usesPromptInput, targetTabId, tabContext }) {
+  if (!usesPromptInput) return;
+  clearAttachments(targetTabId);
+  if (isCurrentTabContext(tabContext)) {
+    elements.promptInput.value = "";
+    resizePromptInput();
+  } else {
+    tabDrafts.set(targetTabId, "");
+  }
+}
+
+function enqueueUserBashCommand(parsed, { usesPromptInput = false, targetTabId = activeTabId } = {}) {
+  if (!targetTabId || !parsed?.command) return;
+  const tabContext = activeTabContext(targetTabId);
+  clearComposerAfterUserBash({ usesPromptInput, targetTabId, tabContext });
+  const queue = userBashQueueForTab(targetTabId);
+  queue.push({ command: parsed.command, excludeFromContext: parsed.excludeFromContext === true, enqueuedAt: Date.now() });
+  const waiting = queue.length;
+  if (isCurrentTabContext(tabContext)) {
+    addTransientMessage({
+      role: "bashExecution",
+      title: parsed.excludeFromContext ? "bash (!! queued)" : "bash (! queued)",
+      command: parsed.command,
+      output: `Queued behind the active bash command. Position: ${waiting}.\n\nOutput will be ${parsed.excludeFromContext ? "excluded from" : "included in the next"} LLM context when it runs.`,
+      excludeFromContext: parsed.excludeFromContext === true,
+      level: "info",
+    });
+    addEvent(`bash queued (${waiting} waiting): ${parsed.command}`, "info");
+    setRunIndicatorActivity(`Bash queued (${waiting} waiting)…`);
+    updateComposerModeButtons();
+  }
+}
+
+function dequeueNextUserBashCommand(targetTabId) {
+  return userBashQueueForTab(targetTabId).shift() || null;
+}
+
+async function runUserBashCommand(parsed, { usesPromptInput = false, targetTabId = activeTabId, queued = false } = {}) {
+  if (!targetTabId || !parsed?.command) return;
+  const tabContext = activeTabContext(targetTabId);
+  const { command, excludeFromContext } = parsed;
+  autoFollowChat = true;
+  setComposerActionsOpen(false);
+  hideCommandSuggestions();
+  userBashByTab.set(targetTabId, { command, excludeFromContext, startedAt: Date.now() });
+  markTabWorkingLocally(targetTabId);
+  if (isCurrentTabContext(tabContext)) {
+    const waiting = queuedUserBashCount(targetTabId);
+    setRunIndicatorActivity(`Running bash: ${command}${waiting ? ` (${waiting} queued)` : ""}`);
+    addTransientMessage({
+      role: "bashExecution",
+      title: excludeFromContext ? "bash (!!)" : "bash (!)" ,
+      command,
+      output: `${queued ? "Dequeued and running.\n\n" : ""}${excludeFromContext ? "Output will be excluded from LLM context." : "Output will be included in the next LLM context."}\n\nRunning…`,
+      excludeFromContext,
+      level: "info",
+    });
+  }
+  clearComposerAfterUserBash({ usesPromptInput, targetTabId, tabContext });
+
+  try {
+    const response = await api("/api/bash", { method: "POST", body: { command, excludeFromContext }, tabId: targetTabId });
+    const result = response.data || {};
+    applyResponseTab(response);
+    if (isCurrentTabContext(tabContext)) {
+      addTransientMessage({
+        role: "bashExecution",
+        title: excludeFromContext ? "bash (!! complete)" : "bash (! complete)",
+        command,
+        output: userBashOutputSummary(result, excludeFromContext),
+        exitCode: result.exitCode,
+        cancelled: result.cancelled === true,
+        truncated: result.truncated === true,
+        fullOutputPath: result.fullOutputPath,
+        excludeFromContext,
+        level: result.cancelled ? "warn" : result.exitCode ? "error" : "info",
+      });
+      addEvent(`bash ${result.cancelled ? "cancelled" : "finished"}: ${command}`, result.cancelled || result.exitCode ? "warn" : "info");
+      scheduleRefreshMessages(250, tabContext);
+      scheduleRefreshState(250, tabContext);
+    } else {
+      scheduleRefreshTabs(300);
+    }
+  } catch (error) {
+    if (isCurrentTabContext(tabContext)) {
+      addEvent(error.message, "error");
+      addTransientMessage({ role: "error", title: excludeFromContext ? "!! bash failed" : "! bash failed", content: error.message, level: "error" });
+    }
+  } finally {
+    userBashByTab.delete(targetTabId);
+    const nextQueued = dequeueNextUserBashCommand(targetTabId);
+    if (isCurrentTabContext(tabContext)) {
+      if (nextQueued) {
+        setRunIndicatorActivity(`Starting queued bash (${queuedUserBashCount(targetTabId)} waiting)…`);
+      } else if (!currentState?.isStreaming && !currentState?.isCompacting) {
+        markTabIdleLocally(targetTabId);
+        clearRunIndicatorActivity();
+      } else {
+        syncRunIndicatorFromState(currentState);
+      }
+      updateComposerModeButtons();
+    }
+    if (nextQueued) void runUserBashCommand(nextQueued, { usesPromptInput: false, targetTabId, queued: true });
+  }
+}
+
+async function sendUserBashCommand(parsed, { usesPromptInput = false, targetTabId = activeTabId } = {}) {
+  if (!targetTabId || !parsed?.command) return;
+  if (isUserBashActive(targetTabId) || queuedUserBashCount(targetTabId) > 0) {
+    enqueueUserBashCommand(parsed, { usesPromptInput, targetTabId });
+    return;
+  }
+  await runUserBashCommand(parsed, { usesPromptInput, targetTabId });
+}
+
 async function sendPrompt(kind = "prompt", explicitMessage) {
   const usesPromptInput = explicitMessage === undefined;
   const rawMessage = usesPromptInput ? elements.promptInput.value : explicitMessage;
@@ -7816,6 +8624,11 @@ async function sendPrompt(kind = "prompt", explicitMessage) {
   const attachments = usesPromptInput ? [...attachmentsForTab(targetTabId)] : [];
   if (!originalMessage && attachments.length === 0) return;
   if (kind === "prompt" && attachments.length === 0 && await handleNativeSlashSelectorCommand(originalMessage, { usesPromptInput })) return;
+  const userBash = kind === "prompt" && attachments.length === 0 ? parseUserBashInput(originalMessage) : null;
+  if (userBash) {
+    await sendUserBashCommand(userBash, { usesPromptInput, targetTabId });
+    return;
+  }
 
   const targetWasStreaming = !!currentState?.isStreaming;
   const busyBehavior = elements.busyBehavior.value || "followUp";
@@ -7834,7 +8647,10 @@ async function sendPrompt(kind = "prompt", explicitMessage) {
     message = composeMessageWithAttachments(originalMessage, prepared.uploadedFiles, prepared.inlineImageIds);
     const bodyBase = { message };
     if (prepared.images.length) bodyBase.images = prepared.images;
-    if (kind === "prompt" && !message.startsWith("/")) rememberLastUserPrompt(message, { tabId: targetTabId });
+    if (!message.startsWith("/")) {
+      rememberPromptHistory(message, { tabId: targetTabId });
+      if (kind === "prompt") rememberLastUserPrompt(message, { tabId: targetTabId });
+    }
     if (startsRun && isCurrentTabContext(tabContext)) setRunIndicatorActivity("Sending prompt to Pi…");
 
     let response;
@@ -7860,12 +8676,15 @@ async function sendPrompt(kind = "prompt", explicitMessage) {
     }
     if (targetStillActive && response?.command === "native_slash_command" && response.data?.copyText) {
       try {
-        await navigator.clipboard.writeText(response.data.copyText);
+        await copyText(response.data.copyText);
       } catch (error) {
         response.data.message = `${response.data.message || "Copy requested, but clipboard access failed."}\n\nClipboard access failed: ${error.message}\n\n${response.data.copyText}`;
         response.data.level = "warn";
       }
     }
+    if (targetStillActive && response?.command === "native_slash_command" && response.data?.download) {
+      if (triggerNativeDownload(response.data.download)) addEvent(`download started: ${response.data.download.fileName || response.data.download.url}`, "info");
+    }
     if (targetStillActive && response?.command === "native_slash_command" && response.data?.message) {
       addTransientMessage({ role: "native", title: message.split(/\s+/, 1)[0], content: response.data.message, level: response.data.level || "info" });
     }
@@ -8071,7 +8890,7 @@ function handleEvent(event) {
   switch (event.type) {
     case "webui_connected":
       addEvent(`connected to ${event.tabTitle || "terminal"} for ${event.cwd}`);
-      refreshTabs().catch((error) => addEvent(error.message, "error"));
+      scheduleForegroundReconcile("event stream reconnect", 0);
       break;
     case "webui_tab_renamed":
       applyTabMetadata(event.tab || { id: event.tabId, title: event.tabTitle, activity: event.tabActivity });
@@ -8166,6 +8985,7 @@ function handleEvent(event) {
       scheduleRefreshState();
       scheduleRefreshMessages();
       scheduleRefreshFooter();
+      scheduleRefreshCodexUsage(2200);
       renderFeedbackTray();
       {
         const workflowTabId = event.tabId || activeTabId;
@@ -8258,7 +9078,7 @@ function handleEvent(event) {
         syncActiveTabActivityFromState(currentState);
         syncRunIndicatorFromState(currentState);
         renderStatus();
-      } else if (["set_model", "set_thinking_level", "new_session", "compact"].includes(event.command)) {
+      } else if (["set_model", "cycle_model", "set_thinking_level", "cycle_thinking_level", "new_session", "compact"].includes(event.command)) {
         if (event.command === "new_session") {
           const tabId = event.tabId || activeTabId;
           forgetLastUserPrompt(tabId);
@@ -8330,7 +9150,7 @@ publishMenuContainer?.addEventListener("focusout", () => {
 });
 elements.releaseNpmButton.addEventListener("click", () => runPublishWorkflow("/release-npm"));
 elements.releaseAurButton.addEventListener("click", () => runPublishWorkflow("/release-aur"));
-elements.gitWorkflowCancelButton.addEventListener("click", cancelGitWorkflow);
+elements.gitWorkflowCancelButton.addEventListener("click", () => cancelGitWorkflow());
 elements.nativeCommandDialog.addEventListener("close", () => {
   elements.nativeCommandSearch.oninput = null;
   nativeCommandTabId = null;
@@ -8349,8 +9169,17 @@ async function abortActiveRun({ source = "button" } = {}) {
   abortRequestInFlight = true;
   resetAbortLongPressAffordance();
   updateComposerModeButtons();
+  const hadActiveBash = isUserBashActive(tabContext.tabId);
   const hadActiveRun = runIndicatorIsActive();
   try {
+    if (hadActiveBash) {
+      const command = userBashByTab.get(tabContext.tabId)?.command || "bash";
+      setRunIndicatorActivity(`Abort requested${source === "escape" ? " from Esc" : source === "long-press" ? " from long-press" : ""}; stopping bash…`);
+      await api("/api/abort-bash", { method: "POST", body: {}, tabId: tabContext.tabId });
+      if (!isCurrentTabContext(tabContext)) return;
+      addTransientMessage({ role: "native", title: "bash aborted", content: `⛔ Abort requested for bash command:\n${command}`, level: "warn" });
+      return;
+    }
     if (hadActiveRun) setRunIndicatorActivity(`Abort requested${source === "escape" ? " from Esc" : source === "long-press" ? " from long-press" : ""}; checking whether Pi stopped…`);
     await api("/api/abort", { method: "POST", body: {}, tabId: tabContext.tabId });
     if (!isCurrentTabContext(tabContext)) return;
@@ -8470,6 +9299,7 @@ if (elements.backgroundClearButton) {
   elements.backgroundClearButton.addEventListener("click", () => clearCustomBackground().catch((error) => addEvent(error.message || String(error), "error")));
 }
 elements.openNetworkButton.addEventListener("click", openToNetwork);
+elements.stopServerButton.addEventListener("click", stopServer);
 elements.agentDoneNotificationsToggle.addEventListener("change", () => {
   setAgentDoneNotificationsEnabled(elements.agentDoneNotificationsToggle.checked, {
     requestPermission: elements.agentDoneNotificationsToggle.checked,
@@ -8528,6 +9358,72 @@ document.addEventListener("pointermove", (event) => {
   }
   rememberPointerPosition(event);
 }, { passive: true });
+
+function isTextEntryTarget(target) {
+  if (!target) return false;
+  const tag = String(target.tagName || "").toLowerCase();
+  return target.isContentEditable || tag === "textarea" || tag === "input" || tag === "select";
+}
+
+function shouldHandleNativeAppShortcut(event) {
+  if (event.defaultPrevented) return false;
+  if (elements.dialog?.open || elements.pathPickerDialog?.open || elements.nativeCommandDialog?.open) return false;
+  return event.target === elements.promptInput || !isTextEntryTarget(event.target);
+}
+
+function handleNativeAppShortcut(event) {
+  if (!shouldHandleNativeAppShortcut(event)) return;
+  const key = event.key;
+  const lowerKey = String(key || "").toLowerCase();
+  const ctrlOrMeta = event.ctrlKey || event.metaKey;
+
+  if (ctrlOrMeta && !event.altKey && lowerKey === "l") {
+    event.preventDefault();
+    openNativeModelSelector();
+    return;
+  }
+  if (ctrlOrMeta && !event.altKey && lowerKey === "p") {
+    event.preventDefault();
+    cycleModelFromShortcut(event.shiftKey ? "backward" : "forward");
+    return;
+  }
+  if (ctrlOrMeta && !event.altKey && !event.shiftKey && lowerKey === "t") {
+    event.preventDefault();
+    setThinkingOutputVisible(!thinkingOutputVisible, { announce: true });
+    return;
+  }
+  if (ctrlOrMeta && !event.altKey && !event.shiftKey && lowerKey === "o") {
+    event.preventDefault();
+    setToolOutputGloballyExpanded(!toolOutputGloballyExpanded, { announce: true });
+    return;
+  }
+  if (ctrlOrMeta && !event.altKey && !event.shiftKey && lowerKey === "c") {
+    if (clearPromptFromShortcut()) event.preventDefault();
+    return;
+  }
+  if (!event.ctrlKey && !event.metaKey && !event.altKey && event.shiftKey && key === "Tab") {
+    event.preventDefault();
+    cycleThinkingFromShortcut();
+    return;
+  }
+  if (!event.ctrlKey && !event.metaKey && event.altKey && key === "Enter") {
+    event.preventDefault();
+    if (hasComposerPayload()) sendPrompt("follow-up");
+    return;
+  }
+  if (!event.ctrlKey && !event.metaKey && event.altKey && key === "ArrowUp") {
+    event.preventDefault();
+    restoreQueuedMessagesToComposerFromShortcut();
+  }
+}
+
+window.addEventListener("keydown", handleNativeAppShortcut, { capture: true });
+document.addEventListener("visibilitychange", () => {
+  if (document.visibilityState === "visible") scheduleForegroundReconcile("visibility resume", 0);
+});
+window.addEventListener("pageshow", () => scheduleForegroundReconcile("page show", 0));
+window.addEventListener("focus", () => scheduleForegroundReconcile("window focus"));
+window.addEventListener("online", () => scheduleForegroundReconcile("network online", 0));
 window.addEventListener("keydown", (event) => {
   if (event.key !== "Escape") return;
   if (elements.dialog?.open || elements.pathPickerDialog?.open) return;
@@ -8561,6 +9457,9 @@ window.addEventListener("keydown", (event) => {
   }
 });
 
+elements.refreshCodexUsageButton?.addEventListener("click", () => {
+  refreshCodexUsage({ forceAuthRefresh: true }).finally(() => scheduleRefreshCodexUsage());
+});
 elements.pathPickerAddFastPickButton.addEventListener("click", () => addCurrentFastPick().catch((error) => addEvent(error.message, "error")));
 elements.pathPickerCancelButton.addEventListener("click", () => closePathPicker(null));
 elements.pathPickerChooseButton.addEventListener("click", () => closePathPicker(pathPickerState?.cwd || null));
@@ -8585,6 +9484,7 @@ elements.composer.addEventListener("dragleave", handleComposerDragLeave);
 elements.composer.addEventListener("drop", handleComposerDrop);
 
 elements.promptInput.addEventListener("keydown", (event) => {
+  if (event.defaultPrevented) return;
   if (shouldSendPromptFromEnter(event)) {
     event.preventDefault();
     hideCommandSuggestions();
@@ -8613,9 +9513,18 @@ elements.promptInput.addEventListener("keydown", (event) => {
       hideCommandSuggestions();
     }
   }
+
+  if (!event.ctrlKey && !event.metaKey && !event.altKey && !event.shiftKey && event.key === "ArrowUp" && recallPreviousPromptFromHistory()) {
+    event.preventDefault();
+    return;
+  }
+  if (!event.ctrlKey && !event.metaKey && !event.altKey && !event.shiftKey && event.key === "ArrowDown" && recallNextPromptFromHistory()) {
+    event.preventDefault();
+  }
 });
 
 elements.promptInput.addEventListener("input", () => {
+  resetPromptHistoryNavigation();
   resizePromptInput();
   renderCommandSuggestions();
 });
@@ -8624,6 +9533,7 @@ elements.promptInput.addEventListener("focus", () => {
   setTimeout(updateVisualViewportVars, 0);
 });
 elements.promptInput.addEventListener("click", () => {
+  resetPromptHistoryNavigation();
   updateVisualViewportVars();
   syncMobileChatToBottomForInput();
   renderCommandSuggestions();
@@ -8644,6 +9554,7 @@ focusPromptInput({ defer: true });
 updateComposerModeButtons();
 updateOptionalFeatureAvailability();
 loadLastUserPromptCache();
+loadPromptHistoryCache();
 installViewportHandlers();
 currentThemeName = storedThemeName();
 renderBackgroundControl();
@@ -8654,9 +9565,11 @@ initializeThemes().catch((error) => {
 initializeFastPicks().catch((error) => addEvent(`failed to initialize path fast picks: ${error.message}`, "error"));
 restoreAgentDoneNotificationsSetting();
 restoreThinkingVisibilitySetting();
+restoreToolOutputExpansionSetting();
 restoreSidePanelSectionState();
 bindSidePanelSectionToggles();
 restoreSidePanelState();
+initializeCodexUsage();
 bindMobileViewChanges();
 registerPwaServiceWorker();
 renderServerOfflinePanel();