@hienlh/ppm 0.23.24 → 0.23.26

package/src/web/components/settings/settings-body.tsx

@@ -1,3 +1,4 @@
+import { useSettingsStore } from "@/stores/settings-store";
 /**
  * The Settings shell, shared by every host: the floating window, the mobile tab, and (until it
  * moves out) the sidebar panel.
@@ -19,7 +20,7 @@ import { Button } from "@/components/ui/button";
 import { ScrollArea } from "@/components/ui/scroll-area";
 import { Separator } from "@/components/ui/separator";
 import {
-  DEFAULT_SETTINGS_CATEGORY, SETTINGS_NAVIGATE_EVENT, isSettingsCategoryId, settingsCategory,
+  DEFAULT_SETTINGS_CATEGORY, SETTINGS_NAVIGATE_EVENT, isSettingsCategoryId, settingsCategory, resolveSettingsCategory,
   type SettingsCategoryId,
 } from "./settings-categories";
 import { SettingsCategoryRail } from "./settings-category-rail";
@@ -38,14 +39,17 @@ export interface SettingsBodyProps {
 }
 
 export function SettingsBody({ initialCategory, onCategoryChange }: SettingsBodyProps) {
-  const [active, setActive] = useState<SettingsCategoryId>(initialCategory ?? DEFAULT_SETTINGS_CATEGORY);
+  const minimalMode = useSettingsStore((s) => s.minimalMode);
+  const [selected, setActive] = useState<SettingsCategoryId>(initialCategory ?? DEFAULT_SETTINGS_CATEGORY);
   // Narrow layout only: is the index covering the pane? A deep link opens straight on the pane.
   const [showList, setShowList] = useState(initialCategory === undefined);
 
+  const active = resolveSettingsCategory(selected, minimalMode);
   const category = settingsCategory(active);
   const Icon = category.icon;
 
   function select(id: SettingsCategoryId) {
+    id = resolveSettingsCategory(id, minimalMode);
     setActive(id);
     // Also cleared when picking from the rail: if the container later shrinks, a stale list
     // overlay would otherwise cover the pane the user just chose.

package/src/web/components/settings/settings-categories.ts

@@ -105,7 +105,7 @@ export const SETTINGS_CATEGORIES: SettingsCategoryDef[] = [
   { id: "proxy", group: "integrations", label: "API Proxy", subtitle: "Expose accounts as Anthropic API", icon: Globe },
   { id: "remote-access", group: "integrations", label: "Remote Access", subtitle: "Tailscale, public link", icon: MonitorSmartphone },
 
-  { id: "schedules", group: "advanced", label: "Scheduled Agents", subtitle: "Run Claude on a cron schedule", icon: CalendarClock },
+  { id: "schedules", group: "advanced", label: "Scheduled Agents", subtitle: "Prompts and scripts, on a cron or always on", icon: CalendarClock },
   { id: "shortcuts", group: "advanced", label: "Keyboard Shortcuts", subtitle: "Customize key bindings", icon: Keyboard },
   { id: "files", group: "advanced", label: "File Filters", subtitle: "Exclude patterns, ignore files", icon: FolderSearch },
   { id: "query-audit", group: "advanced", label: "Query Audit Log", subtitle: "SQL history retention and size", icon: DatabaseZap },
@@ -134,7 +134,22 @@ export function settingsCategory(id: SettingsCategoryId): SettingsCategoryDef {
   return SETTINGS_CATEGORIES.find((c) => c.id === id)!;
 }
 
+/** Settings for services that remain available when PPM starts with --minimal. */
+const MINIMAL_SETTINGS_CATEGORIES = new Set<SettingsCategoryId>([
+  "general", "appearance", "ai-provider", "accounts", "voice", "notifications",
+  "remote-access", "shortcuts", "files",
+]);
+
+export function settingsCategoryAvailable(id: SettingsCategoryId, minimalMode: boolean): boolean {
+  return !minimalMode || MINIMAL_SETTINGS_CATEGORIES.has(id);
+}
+
+/** Resolve before rendering so a restored disabled pane never mounts or fetches. */
+export function resolveSettingsCategory(id: SettingsCategoryId, minimalMode: boolean): SettingsCategoryId {
+  return settingsCategoryAvailable(id, minimalMode) ? id : DEFAULT_SETTINGS_CATEGORY;
+}
+
 /** Categories of one group, in declaration order. */
-export function settingsCategoriesInGroup(group: SettingsGroupId): SettingsCategoryDef[] {
-  return SETTINGS_CATEGORIES.filter((c) => c.group === group);
+export function settingsCategoriesInGroup(group: SettingsGroupId, minimalMode = false): SettingsCategoryDef[] {
+  return SETTINGS_CATEGORIES.filter((c) => c.group === group && settingsCategoryAvailable(c.id, minimalMode));
 }

package/src/web/components/settings/settings-category-list.tsx

@@ -1,3 +1,4 @@
+import { useSettingsStore } from "@/stores/settings-store";
 /**
  * Narrow-container layout: one column, list first and pane second.
  *
@@ -14,11 +15,12 @@ import {
 } from "./settings-categories";
 
 export function SettingsCategoryList({ onSelect }: { onSelect: (id: SettingsCategoryId) => void }) {
+  const minimalMode = useSettingsStore((s) => s.minimalMode);
   return (
     <ScrollArea className="h-full">
       <nav className="p-3 space-y-5" aria-label="Settings categories">
         {SETTINGS_GROUPS.map((group) => {
-          const categories = settingsCategoriesInGroup(group.id);
+          const categories = settingsCategoriesInGroup(group.id, minimalMode);
           if (categories.length === 0) return null;
           return (
             <div key={group.id} className="space-y-1">

package/src/web/components/settings/settings-category-rail.tsx

@@ -1,3 +1,4 @@
+import { useSettingsStore } from "@/stores/settings-store";
 /**
  * Left pane of the split layout: every category visible at once, grouped.
  *
@@ -19,11 +20,12 @@ interface SettingsCategoryRailProps {
 }
 
 export function SettingsCategoryRail({ active, onSelect }: SettingsCategoryRailProps) {
+  const minimalMode = useSettingsStore((s) => s.minimalMode);
   return (
     <ScrollArea className="h-full">
       <nav className="p-2 space-y-4" aria-label="Settings categories">
         {SETTINGS_GROUPS.map((group) => {
-          const categories = settingsCategoriesInGroup(group.id);
+          const categories = settingsCategoriesInGroup(group.id, minimalMode);
           if (categories.length === 0) return null;
           return (
             <div key={group.id} className="space-y-1">

package/src/web/components/settings/settings-section-content.tsx

@@ -1,3 +1,4 @@
+import { useSettingsStore } from "@/stores/settings-store";
 /**
  * Maps a settings category to the component that fills the content pane.
  *
@@ -10,7 +11,7 @@
 import { Suspense } from "react";
 import { lazyWithPreload, type PreloadableComponent } from "@/lib/lazy-with-preload";
 import { Loader2 } from "@/lib/icons";
-import type { SettingsCategoryId } from "./settings-categories";
+import { resolveSettingsCategory, settingsCategoryAvailable, type SettingsCategoryId } from "./settings-categories";
 
 export const SECTIONS: Record<SettingsCategoryId, PreloadableComponent<object>> = {
   general: lazyWithPreload(() => import("./general-settings-section").then((m) => ({ default: m.GeneralSettingsSection }))),
@@ -37,11 +38,15 @@ export const SECTIONS: Record<SettingsCategoryId, PreloadableComponent<object>>
 
 /** Load every pane's code, so that opening Settings shows its pane without a spinner. */
 export function preloadSettingsSections(): Promise<unknown> {
-  return Promise.all(Object.values(SECTIONS).map((section) => section.preload()));
+  const minimalMode = useSettingsStore.getState().minimalMode;
+  return Promise.all((Object.keys(SECTIONS) as SettingsCategoryId[])
+    .filter((category) => settingsCategoryAvailable(category, minimalMode))
+    .map((category) => SECTIONS[category].preload()));
 }
 
 export function SettingsSectionContent({ category }: { category: SettingsCategoryId }) {
-  const Section = SECTIONS[category];
+  const minimalMode = useSettingsStore((s) => s.minimalMode);
+  const Section = SECTIONS[resolveSettingsCategory(category, minimalMode)];
   return (
     <Suspense
       fallback={

package/src/web/components/shared/markdown-code-block.tsx

@@ -1,3 +1,4 @@
+import { useSettingsStore } from "@/stores/settings-store";
 import { useState, useEffect, useMemo, useRef, type ReactNode } from "react";
 import { useMdContext, FILE_EXT_RE, GLOB_CHARS_RE } from "./markdown-context";
 import { highlightToHtml, highlightSync, getActiveShikiTheme } from "@/theme/adapters/shiki-adapter";
@@ -65,6 +66,7 @@ function hastToText(node: any): string {
 
 /** Pre — code block wrapper with mermaid detection, Shiki highlighting, action buttons */
 export function MdPre({ children, node, ...rest }: any) {
+  const minimalMode = useSettingsStore((s) => s.minimalMode);
   const { codeActions, projectName, isStreaming } = useMdContext();
 
   const codeNode = node?.children?.[0];
@@ -94,7 +96,7 @@ export function MdPre({ children, node, ...rest }: any) {
       {codeActions && (
         <div className="code-actions absolute top-1 right-1 flex gap-1">
           <ActionBtn title="Copy" icon={<CopyIcon />} activeIcon={<CheckIcon />} onClick={() => void copyToClipboard(text)} />
-          {isBash && projectName && (
+          {!minimalMode && isBash && projectName && (
             <ActionBtn
               title="Send to terminal"
               icon={<PlayIcon />}

package/src/web/hooks/use-design-session-redirect.ts

@@ -1,3 +1,4 @@
+import { useSettingsStore } from "@/stores/settings-store";
 import { useEffect } from "react";
 import { api, projectUrl } from "@/lib/api-client";
 import { usePanelStore } from "@/stores/panel-store";
@@ -21,9 +22,10 @@ export function useDesignSessionRedirect(input: {
   projectName?: string;
   providerId?: string;
 }) {
+  const minimalMode = useSettingsStore((s) => s.minimalMode);
   const { tabId, sessionId, designSlug, projectName, providerId } = input;
   useEffect(() => {
-    if (!tabId || !sessionId || designSlug || !projectName) return;
+    if (minimalMode || !tabId || !sessionId || designSlug || !projectName) return;
     const panel = usePanelStore.getState().getPanelForTab(tabId);
     if (panel?.tabs.find((t) => t.id === tabId)?.type !== "chat") return;
     let cancelled = false;
@@ -36,5 +38,5 @@ export function useDesignSessionRedirect(input: {
       })
       .catch(() => { /* an unknown session stays a plain chat */ });
     return () => { cancelled = true; };
-  }, [tabId, sessionId, designSlug, projectName, providerId]);
+  }, [minimalMode, tabId, sessionId, designSlug, projectName, providerId]);
 }

package/src/web/hooks/use-global-keybindings.ts

@@ -1,3 +1,4 @@
+import { isMinimalTab } from "@/lib/minimal-mode";
 import { useEffect, useState, useCallback } from "react";
 import { useTabStore } from "@/stores/tab-store";
 import { useSettingsStore } from "@/stores/settings-store";
@@ -46,7 +47,65 @@ export function useGlobalKeybindings() {
       return true;
     }
 
+    /** Mod+1..9: the project at that place in the list. Returns true when the event was consumed. */
+    function dispatchSwitchProject(e: KeyboardEvent, m: (ev: KeyboardEvent, id: string) => boolean) {
+      for (let i = 1; i <= 9; i++) {
+        if (!m(e, `switch-project-${i}`)) continue;
+        e.preventDefault();
+        const target = useProjectStore.getState().projects[i - 1];
+        if (target) {
+          useProjectStore.getState().setActiveProject(target);
+          useTabStore.getState().switchProject(target.name);
+        }
+        return true;
+      }
+      return false;
+    }
+
     function handler(e: KeyboardEvent) {
+      if (useSettingsStore.getState().minimalMode) {
+        if (e.type !== "keydown" || composing || e.isComposing) return;
+        const { matchesEvent: match } = useKeybindingsStore.getState();
+        if (dispatchChatNav(e, match)) return;
+        if (match(e, "save-prevent")) e.preventDefault();
+        // Like full mode below: inside a text field only the locked shortcuts fire.
+        const target = e.target as HTMLElement | null;
+        if (target?.tagName === "TEXTAREA" || target?.tagName === "INPUT" || target?.isContentEditable) return;
+        if (match(e, "toggle-sidebar")) {
+          e.preventDefault();
+          useSettingsStore.getState().toggleSidebar();
+        } else if (match(e, "new-file")) {
+          e.preventDefault();
+          useTabStore.getState().openNewFile();
+        } else if (match(e, "open-settings")) {
+          e.preventDefault();
+          openSettings();
+        } else if (match(e, "open-chat")) {
+          e.preventDefault();
+          const project = useProjectStore.getState().activeProject;
+          useTabStore.getState().openTab({ type: "chat", title: "AI Chat", projectId: project?.name ?? null,
+            metadata: project ? { projectName: project.name } : undefined, closable: true });
+        } else if (match(e, "voice-input")) {
+          e.preventDefault();
+          window.dispatchEvent(new CustomEvent("toggle-voice-input"));
+        } else if (match(e, "open-search")) {
+          e.preventDefault();
+          const settings = useSettingsStore.getState();
+          if (settings.sidebarCollapsed) settings.toggleSidebar();
+          settings.setSidebarActiveTab("search");
+        } else if (match(e, "next-tab") || match(e, "prev-tab")) {
+          e.preventDefault();
+          const state = useTabStore.getState();
+          const chats = state.tabs.filter((tab) => isMinimalTab(tab.type));
+          if (!chats.length) return;
+          const index = chats.findIndex((tab) => tab.id === state.activeTabId);
+          const next = (index + (match(e, "next-tab") ? 1 : -1) + chats.length) % chats.length;
+          state.setActiveTab(chats[next]!.id);
+        } else {
+          dispatchSwitchProject(e, match);
+        }
+        return;
+      }
       // Track whether Shift is pressed alone (not as a modifier for another key)
       if (e.type === "keydown" && e.key === "Shift") {
         shiftAlone = true;
@@ -237,19 +296,7 @@ export function useGlobalKeybindings() {
         return;
       }
 
-      // Switch project 1-9
-      for (let i = 1; i <= 9; i++) {
-        if (match(e, `switch-project-${i}`)) {
-          e.preventDefault();
-          const projects = useProjectStore.getState().projects;
-          const target = projects[i - 1];
-          if (target) {
-            useProjectStore.getState().setActiveProject(target);
-            useTabStore.getState().switchProject(target.name);
-          }
-          return;
-        }
-      }
+      if (dispatchSwitchProject(e, match)) return;
 
       // Extension-contributed keybindings (with user override support)
       const extKbs = useExtensionStore.getState().contributions?.keybindings;
@@ -274,6 +321,7 @@ export function useGlobalKeybindings() {
 
     // Custom event listener for programmatic opening
     function handleOpenPalette(e: Event) {
+      if (useSettingsStore.getState().minimalMode) return;
       const query = (e as CustomEvent).detail;
       setPaletteInitialQuery(typeof query === "string" ? query : "");
       setPaletteOpen(true);

package/src/web/hooks/use-inline-blame.ts

@@ -115,7 +115,7 @@ export function useInlineBlame({
   // repository) when nothing was. Every path below is relative to it, because
   // that is where git runs. `fileRepo` null with a `repoFile` is a project
   // inside a repository: git runs unscoped there, as it always did.
-  const { fileScope, fileGitUrl } = useGitRepo(projectName);
+  const { fileScope, fileGitUrl } = useGitRepo(enabled ? projectName : undefined);
   const scope = filePath ? fileScope(filePath) : null;
   const fileRepo = scope?.repo ?? null;
   const gitRoot = fileRepo?.path ?? projectPath;

package/src/web/hooks/use-schedules.ts

@@ -1,17 +1,17 @@
 /** Fetch + poll schedules for the settings section. */
 import { useState, useEffect, useCallback } from "react";
 import { api } from "@/lib/api-client";
-import type { Schedule, ScheduleRun } from "../../types/scheduler";
+import type { ScheduleRun, ScheduleView } from "../../types/scheduler";
 
 const POLL_MS = 10_000;
 
 export function useSchedules() {
-  const [schedules, setSchedules] = useState<Schedule[]>([]);
+  const [schedules, setSchedules] = useState<ScheduleView[]>([]);
   const [loading, setLoading] = useState(true);
 
   const refetch = useCallback(async () => {
     try {
-      setSchedules(await api.get<Schedule[]>("/api/schedules"));
+      setSchedules(await api.get<ScheduleView[]>("/api/schedules"));
     } catch {
       // Keep stale list on transient errors; next poll retries
     } finally {

package/src/web/hooks/use-tab-prefetch.ts

@@ -58,7 +58,7 @@ function scheduleAfterDelayWhenIdle(fn: () => void, delayMs: number): { cancel:
  *
  * Mount once, at app level — not inside a per-tab component.
  */
-export function useTabPrefetch(): void {
+export function useTabPrefetch(enabled = true): void {
   const isMobile = useIsMobile();
   const currentProject = usePanelStore((s) => s.currentProject);
 
@@ -66,7 +66,7 @@ export function useTabPrefetch(): void {
   // prefetching grows `mounted`, which would otherwise retrigger the effect and
   // restart the queue on every step.
   useEffect(() => {
-    if (isMobile) return;
+    if (!enabled || isMobile) return;
 
     let disposed = false;
     let remaining = PREFETCH_CAP;
@@ -120,5 +120,5 @@ export function useTabPrefetch(): void {
       cancelPending();
       unsubscribe();
     };
-  }, [isMobile, currentProject]);
+  }, [enabled, isMobile, currentProject]);
 }

package/src/web/lib/api-settings.ts

@@ -104,7 +104,7 @@ export function deleteAccount(id: string): Promise<void> {
   return api.del(`/api/accounts/${id}`);
 }
 
-export function patchAccount(id: string, updates: { status: string }): Promise<AccountInfo | null> {
+export function patchAccount(id: string, updates: { status?: string; label?: string }): Promise<AccountInfo | null> {
   return api.patch<AccountInfo | null>(`/api/accounts/${id}`, updates);
 }
 
@@ -224,6 +224,7 @@ export interface AISettings {
   share_provider_context?: boolean;
   tab_tools?: boolean;
   ppm_tools?: PpmToolSwitches;
+  leftover_processes_idle_minutes?: number;
   providers: Record<string, AIProviderSettings>;
 }
 

package/src/web/lib/api-share-host.ts

@@ -0,0 +1,43 @@
+import { api } from "./api-client";
+import type { CertState } from "./api-named-tunnel";
+
+export type ShareHostMode = "quick" | "named" | "shared";
+
+/** `GET /api/share-host/status`: what the user asked for, and what the supervisor runs. */
+export interface ShareHostStatus {
+  enabled: boolean;
+  mode: ShareHostMode;
+  hostname: string | null;
+  tunnelName: string | null;
+  /** A supervisor runs that can apply a change without a restart. */
+  canApply: boolean;
+  supervised: boolean;
+  running: boolean;
+  /** Reviewers can open `url` now. */
+  connected: boolean;
+  /** Where review links open: the live address, or a fixed one that is reconnecting. */
+  url: string | null;
+  warning: string | null;
+  ppmTunnel: { named: boolean; hostname: string | null; enabled: boolean };
+  certState: CertState;
+  authEnabled: boolean;
+}
+
+/** Whether the running supervisor took a change, and what to tell the user when it did not. */
+export type ShareHostApplied = { applied: true } | { applied: false; message: string };
+
+export interface ShareHostSetupResult {
+  hostname: string;
+  tunnelName: string;
+  applied: ShareHostApplied;
+}
+
+/** Typed client for the review address API (`/api/share-host`). */
+export const shareHostApi = {
+  status: () => api.get<ShareHostStatus>("/api/share-host/status"),
+  zone: () => api.get<{ zone: string; proposedHostname: string }>("/api/share-host/zone"),
+  setEnabled: (enabled: boolean) => api.post<ShareHostApplied>("/api/share-host/enabled", { enabled }),
+  useTemporary: () => api.post<ShareHostApplied>("/api/share-host/quick"),
+  setup: (mode: "named" | "shared", hostname: string) =>
+    api.post<ShareHostSetupResult>("/api/share-host/setup", { mode, hostname }),
+};

package/src/web/lib/design/design-share-address-state.ts

@@ -17,9 +17,16 @@ export const QUICK_ADDRESS_WARNING =
 /** What the tunnel switch answered (`POST /api/tunnel/enabled`). */
 export type TunnelReload = "sent" | "busy" | "no-supervisor";
 
+/**
+ * `review`: the review-only address (Remote Access → Review links), which reaches the review
+ * pages and nothing else of PPM; `public`: PPM's own public link.
+ */
+export type ShareStartTarget = "review" | "public";
+
 export interface ShareStartAttempt {
   /** Epoch ms the owner pressed Start. */
   at: number;
+  target: ShareStartTarget;
   /** Null until the switch answered. */
   reload: TunnelReload | null;
   /** The switch itself failed. */
@@ -30,12 +37,15 @@ export type ShareAddressView =
   | { kind: "loading" }
   | { kind: "error"; message: string }
   | { kind: "signin-off" }
-  | { kind: "named"; url: string; warning: string | null }
-  | { kind: "quick"; url: string; warning: string | null }
-  | { kind: "starting" }
-  | { kind: "failed"; message: string }
+  /** `reviewOnly`: the address is the review-only one, so PPM itself is not public. */
+  | { kind: "named"; url: string; warning: string | null; reviewOnly: boolean }
+  | { kind: "quick"; url: string; warning: string | null; reviewOnly: boolean }
+  | { kind: "starting"; target: ShareStartTarget }
+  | { kind: "failed"; message: string; target: ShareStartTarget }
   /** No public address; `enabled` = the switch is on but nothing is serving (a dark tunnel). */
-  | { kind: "none"; enabled: boolean; warning: string | null };
+  | { kind: "none"; enabled: boolean; warning: string | null }
+  /** The review-only address is switched on but has no address right now. */
+  | { kind: "review-down"; warning: string | null };
 
 export interface ShareAddressInputs {
   address: DesignShareAddress | null;
@@ -47,22 +57,25 @@ export interface ShareAddressInputs {
 export function shareAddressView({ address, loadError, start, now }: ShareAddressInputs): ShareAddressView {
   if (!address) return loadError ? { kind: "error", message: loadError } : { kind: "loading" };
   if (!address.authEnabled) return { kind: "signin-off" };
+  const reviewOnly = address.via === "share-host";
   if (address.url && address.kind !== "none") {
-    return address.kind === "named"
-      ? { kind: "named", url: address.url, warning: address.warning }
-      : { kind: "quick", url: address.url, warning: address.warning };
+    return { kind: address.kind === "named" ? "named" : "quick", url: address.url, warning: address.warning, reviewOnly };
   }
   if (start) {
-    if (start.error) return { kind: "failed", message: start.error };
+    const { target } = start;
+    if (start.error) return { kind: "failed", message: start.error, target };
     if (start.reload === "no-supervisor") {
       return {
         kind: "failed",
+        target,
         message: "PPM is running without its supervisor, so nothing can start the tunnel now. It starts the next time PPM is started normally.",
       };
     }
-    if (now - start.at <= SHARE_START_TIMEOUT_MS) return { kind: "starting" };
-    return { kind: "failed", message: address.warning ?? "The temporary address did not come up within a minute." };
+    if (now - start.at <= SHARE_START_TIMEOUT_MS) return { kind: "starting", target };
+    const late = target === "review" ? "The review-only address" : "The temporary address";
+    return { kind: "failed", target, message: address.warning ?? `${late} did not come up within a minute.` };
   }
+  if (reviewOnly) return { kind: "review-down", warning: address.warning };
   return { kind: "none", enabled: address.enabled, warning: address.warning };
 }
 

package/src/web/lib/design/open-design-tab.ts

@@ -116,7 +116,7 @@ export interface SessionToOpen {
  * design tab for a session opened as a chat, but only this can open one that is closed.
  */
 export function openSessionInItsTab(session: SessionToOpen, projectName: string, panelId?: string): string {
-  if (session.designSlug) {
+  if (session.designSlug && !useSettingsStore.getState().minimalMode) {
     return openDesignTab({
       projectName, slug: session.designSlug, sessionId: session.id, providerId: session.providerId, panelId,
     });

package/src/web/lib/minimal-mode.ts

@@ -0,0 +1,20 @@
+import type { TabType } from "@/stores/tab-store";
+
+/** Tabs available in the reduced workspace; all other saved tabs stay untouched. */
+export function isMinimalTab(type: TabType): boolean {
+  return type === "chat" || type === "settings" || type === "editor";
+}
+
+const MINIMAL_KEY_ACTIONS = new Set([
+  "save-prevent", "toggle-sidebar", "new-file", "open-settings", "open-chat", "voice-input",
+  "open-search", "next-tab", "prev-tab", "chat-nav-prev", "chat-nav-next",
+]);
+
+/**
+ * The shortcuts `useGlobalKeybindings` answers in minimal mode, which are all Settings lists
+ * there: the others open what the mode hides (the palette, the terminal, Git, Problems, and the
+ * compare view, a diff tab).
+ */
+export function isMinimalKeyAction(id: string): boolean {
+  return MINIMAL_KEY_ACTIONS.has(id) || /^switch-project-[1-9]$/.test(id);
+}