pyre-cli 10.1.0 → 10.2.0

package/src/live/input.ts

@@ -15,9 +15,10 @@ import { exportSnapshot, startLogging, stopLogging, toggleLogging, writeLogRow }
 import { render, footerLine, checkAlerts, invalidateTableCache, invalidateFrame } from './render.js';
 import type { LiveOptions, ExportFormat, InputMode, SortMode, GraphMode, ActivePanel } from './types.js';
 import { startP2PServer } from '../p2p/index.js';
-import { writeConfig } from '../state/config.js';
+import { writeConfig, readConfig } from '../state/config.js';
 import { AVAILABLE_AI_MODELS } from '../ai/models.js';
 import { loadPlugins, executePlugins } from '../plugins/index.js';
+import { PALETTE_COMMANDS } from './state.js';
 
   function persistConfig() {
     writeConfig({
@@ -43,6 +44,9 @@ import { loadPlugins, executePlugins } from '../plugins/index.js';
        dockerModeConfirmed: state.dockerModeConfirmed,
        aiModel: state.aiModel,
        aiBackend: state.aiBackend,
+       bookmarks: state.bookmarks.map(bm => ({ ...bm })),
+       graphZoomLevel: state.graphZoomLevel,
+       panelLayout: [...state.panelLayout],
     });
   }
 
@@ -59,7 +63,7 @@ function isEscKey(key: readline.Key, str?: string): boolean {
   return key.name === 'escape' || key.name === 'esc' || key.sequence === '\x1b' || str === '\x1b';
 }
 
-function handleInputModeKey(str: string, key: readline.Key) {
+  function handleInputModeKey(str: string, key: readline.Key) {
    if (isEscKey(key, str)) {
      state.inputMode = null;
      state.inputBuffer = '';
@@ -67,6 +71,59 @@ function handleInputModeKey(str: string, key: readline.Key) {
      return;
    }
 
+   if (state.inputMode === 'quick-ref') {
+     render();
+     return;
+   }
+
+   if (state.inputMode === 'bookmark-save') {
+     if (key.name === 'backspace') {
+       state.inputBuffer = state.inputBuffer.slice(0, -1);
+       render();
+       return;
+     }
+     if (isEnterKey(key, str)) {
+       saveBookmark();
+       return;
+     }
+     if (str && str.length === 1 && !key.ctrl && !key.meta) {
+       state.inputBuffer += str;
+       render();
+     }
+     return;
+   }
+
+   if (state.inputMode === 'command-palette') {
+     if (isUpKey(key, str) || key.name === 'k') {
+       state.paletteIndex = Math.max(0, state.paletteIndex - 1);
+       render();
+       return;
+     }
+     if (isDownKey(key, str) || key.name === 'j') {
+       state.paletteIndex = Math.min(state.paletteFilteredCommands.length - 1, state.paletteIndex + 1);
+       render();
+       return;
+     }
+     if (isEnterKey(key, str)) {
+       executePaletteCommand();
+       return;
+     }
+     if (key.name === 'backspace') {
+       state.inputBuffer = state.inputBuffer.slice(0, -1);
+       updatePaletteFilter();
+       state.paletteIndex = 0;
+       render();
+       return;
+     }
+     if (str && str.length === 1 && !key.ctrl && !key.meta) {
+       state.inputBuffer += str;
+       updatePaletteFilter();
+       state.paletteIndex = 0;
+       render();
+     }
+     return;
+   }
+
    if (state.inputMode === 'customizer') {
      const themesList = Object.keys(THEMES) as ThemeName[];
 
@@ -526,21 +583,27 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
   * rendering interval.  Idempotent — calling while already
   * running is a no-op.
   */
-   export async function startLive(opts: LiveOptions, splashPromise?: Promise<void>) {
-     if (state.running) return;
-     state.running = true;
-     state.paused = false;
-     state.detailed = !!opts.detailed;
-     if (opts.theme) state.currentTheme = opts.theme;
-     state.interval = opts.interval;
-     if (opts.exportDir) state.exportDir = opts.exportDir;
-     if (opts.alertCpu !== undefined) state.CPU_ALERT_PCT = opts.alertCpu;
-     if (opts.alertTemp !== undefined) state.TEMP_ALERT_C = opts.alertTemp;
-     if (opts.tempUnit) state.tempUnit = opts.tempUnit;
-     state.termWidth = process.stdout.columns || 80;
-     state.termHeight = process.stdout.rows || 24;
-     state.history.reset();
-     state.history.setMaxLen(Math.max(20, Math.min(200, state.termWidth - 30)));
+    export async function startLive(opts: LiveOptions, splashPromise?: Promise<void>) {
+      if (state.running) return;
+      state.running = true;
+      state.paused = false;
+      state.detailed = !!opts.detailed;
+      if (opts.theme) state.currentTheme = opts.theme;
+      state.interval = opts.interval;
+      if (opts.exportDir) state.exportDir = opts.exportDir;
+      if (opts.alertCpu !== undefined) state.CPU_ALERT_PCT = opts.alertCpu;
+      if (opts.alertTemp !== undefined) state.TEMP_ALERT_C = opts.alertTemp;
+      if (opts.tempUnit) state.tempUnit = opts.tempUnit;
+      state.termWidth = process.stdout.columns || 80;
+      state.termHeight = process.stdout.rows || 24;
+      state.history.reset();
+      state.history.setMaxLen(Math.max(20, 40 * (readConfig().graphZoomLevel || 1)));
+      state.bookmarks = readConfig().bookmarks || [];
+      state.bookmarkRecallIndex = 0;
+      state.graphZoomLevel = readConfig().graphZoomLevel || 1;
+      state.panelHistory = [];
+      state.paletteIndex = 0;
+      state.paletteFilteredCommands = [...PALETTE_COMMANDS];
 
     await loadPlugins().catch(() => {});
     const warmupPromise = doWarmup();
@@ -621,6 +684,29 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
           state.inputBuffer = state.processFilter;
           render();
           return;
+        case '?':
+          state.inputMode = state.inputMode === 'quick-ref' ? null : 'quick-ref';
+          render();
+          return;
+        case ':':
+          state.inputMode = state.inputMode === 'command-palette' ? null : 'command-palette';
+          state.inputBuffer = '';
+          state.paletteIndex = 0;
+          state.paletteFilteredCommands = [...PALETTE_COMMANDS];
+          render();
+          return;
+        case '[': {
+          state.graphZoomLevel = Math.max(1, state.graphZoomLevel - 1);
+          state.history.setMaxLen(Math.max(20, 40 * state.graphZoomLevel));
+          setStatus(`History zoom: ${state.graphZoomLevel}x (${state.history.maxLen} points)`);
+          return;
+        }
+        case ']': {
+          state.graphZoomLevel = Math.min(5, state.graphZoomLevel + 1);
+          state.history.setMaxLen(Math.max(20, 40 * state.graphZoomLevel));
+          setStatus(`History zoom: ${state.graphZoomLevel}x (${state.history.maxLen} points)`);
+          return;
+        }
         case '0': case '1': case '2': case '3': case '4':
         case '5': case '6': case '7': case '8': case '9': {
           const tabMap: Record<string, ActivePanel> = {
@@ -629,6 +715,7 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
           };
           const panelId = tabMap[key.sequence];
           if (panelId) {
+            pushPanelHistory(panelId);
             state.activePanel = state.activePanel === panelId ? 'grid' : panelId;
             setStatus(state.activePanel === 'grid' ? 'Grid view' : `${panelId} panel`);
             render();
@@ -636,18 +723,21 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
           return;
         }
         case 'P': {
+          pushPanelHistory('process');
           state.activePanel = state.activePanel === 'process' ? 'grid' : 'process';
           setStatus(state.activePanel === 'grid' ? 'Grid view' : 'Process panel');
           render();
           return;
         }
          case 'C': {
+           pushPanelHistory('containers');
            state.activePanel = state.activePanel === 'containers' ? 'grid' : 'containers';
            setStatus(state.activePanel === 'grid' ? 'Grid view' : 'Containers panel');
            render();
            return;
          }
          case 'B': {
+           pushPanelHistory('blender');
            state.activePanel = state.activePanel === 'blender' ? 'grid' : 'blender';
            setStatus(state.activePanel === 'grid' ? 'Grid view' : 'Blender panel');
            render();
@@ -682,10 +772,22 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
           render();
           break;
         case 'm':
-          state.inputMode = 'ai-model';
-          state.modelSelectionIndex = Math.max(0, AVAILABLE_AI_MODELS.findIndex(m => m.id === state.aiModel));
+          if (key.shift) {
+            // Shift+M: save bookmark
+            state.inputMode = 'bookmark-save';
+            state.inputBuffer = '';
+            render();
+          } else {
+            state.inputMode = 'ai-model';
+            state.modelSelectionIndex = Math.max(0, AVAILABLE_AI_MODELS.findIndex(m => m.id === state.aiModel));
+            render();
+          }
+          return;
+        case 'M':
+          // M (no shift): recall next bookmark
+          recallNextBookmark();
           render();
-          break;
+          return;
         case 'p':
           state.paused = !state.paused;
           setStatus(state.paused ? 'Paused' : 'Resumed');
@@ -701,132 +803,176 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
            render();
            break;
          case 'd':
-
            state.detailed = !state.detailed;
            setStatus(`Detailed sensor mode: ${state.detailed ? 'on' : 'off'}`);
            break;
-        case 'T':
-          state.tempUnit = state.tempUnit === 'c' ? 'f' : 'c';
-          setStatus(`Temperature unit: ${state.tempUnit.toUpperCase()}`);
-          invalidateTableCache();
-          render();
-          break;
-        case 's':
-          const sortCycle: SortMode[] = ['cpu', 'mem', 'pid', 'user', 'command', 'state', 'threads', 'runtime'];
-          const curIdx = sortCycle.indexOf(state.sortMode);
-          state.sortMode = sortCycle[(curIdx + 1) % sortCycle.length];
-          setStatus(`Sorting by ${state.sortMode}`);
-          render();
-          break;
-        case 'k':
-          state.inputMode = 'kill';
-          state.inputBuffer = '';
-          render();
-          break;
-        case 'S':
-          state.inputMode = 'signal';
-          state.inputBuffer = 'SIGTERM';
-          render();
-          break;
-        case 't':
-          state.treeView = !state.treeView;
-          setStatus(state.treeView ? 'Tree view enabled' : 'Flat view enabled');
-          render();
-          break;
-        case 'e':
-          exportSnapshot();
-          render();
-          break;
-        case 'l':
-          toggleLogging();
-          render();
-          break;
-        case 'f':
-          const fmtCycle: ExportFormat[] = ['json', 'csv', 'tsv', 'html', 'md'];
-          const curFmt = fmtCycle.indexOf(state.exportFormat);
-          state.exportFormat = fmtCycle[(curFmt + 1) % fmtCycle.length];
-          setStatus(`Export format: ${state.exportFormat}`);
-          render();
-          break;
-        case 'tab':
-          cycleTab(1);
-          break;
-        case 'up':
-          if (state.lastData?.processes?.length) {
-            state.trackedPid = null;
-            state.processSelectionIndex = Math.max(0, state.processSelectionIndex - 1);
-            render();
-          }
-          break;
-        case 'down':
-          if (state.lastData?.processes?.length) {
-            state.trackedPid = null;
-            const count = state.lastData.processes.length;
-            state.processSelectionIndex = Math.min(count - 1, state.processSelectionIndex + 1);
-            render();
-          }
-          break;
-        case 'space':
-        case ' ':
-          if (state.lastData?.processes?.length && state.processSelectionIndex >= 0) {
-            const sorted = state.lastData.processes;
-            const proc = sorted[state.processSelectionIndex];
-            if (proc) {
-              if (state.trackedPid === proc.pid) {
-                state.trackedPid = null;
-                setStatus(`Stopped following PID ${proc.pid}`);
-              } else {
-                state.trackedPid = proc.pid;
-                setStatus(`Following PID ${proc.pid} (${proc.command})`);
-              }
-              render();
-            }
-          }
-          break;
-        case 'return':
-        case 'enter':
-          if (state.inspectingProcess) {
-            state.inspectingProcess = null;
-            render();
-          } else if (state.lastData?.processes?.length && state.processSelectionIndex >= 0) {
-            const sorted = state.lastData.processes;
-            const proc = sorted[state.processSelectionIndex];
-            if (proc) {
-              state.inspectingProcess = proc;
-              state.trackedPid = proc.pid;
-              setStatus(`Inspecting & following PID ${proc.pid}`);
-              render();
-            }
-          }
-          break;
-        case 'escape':
-        case 'esc':
-          if (state.inspectingProcess) {
-            state.inspectingProcess = null;
-            render();
-          } else if (state.trackedPid !== null) {
-            state.trackedPid = null;
-            setStatus('Stopped following process');
-            render();
-          } else if (state.activePanel !== 'grid') {
-            state.activePanel = 'grid';
-            setStatus('Grid view');
-            render();
-          } else {
-            state.inputMode = 'menu';
-            state.menuSelectionIndex = 0;
-            render();
-          }
-          break;
-        default:
-          if (str && str.length === 1) {
-            const tabId = tabKeyToId(str);
-            if (tabId) {
-              state.activePanel = tabId as ActivePanel;
-              setStatus(`Panel: ${tabId.toUpperCase()}`);
-              render();
-            }
-          }
+         case 'T':
+           state.tempUnit = state.tempUnit === 'c' ? 'f' : 'c';
+           setStatus(`Temperature unit: ${state.tempUnit.toUpperCase()}`);
+           invalidateTableCache();
+           render();
+           break;
+         case 's':
+           const sortCycle: SortMode[] = ['cpu', 'mem', 'pid', 'user', 'command', 'state', 'threads', 'runtime'];
+           const curIdx = sortCycle.indexOf(state.sortMode);
+           state.sortMode = sortCycle[(curIdx + 1) % sortCycle.length];
+           setStatus(`Sorting by ${state.sortMode}`);
+           render();
+           break;
+         case 'k':
+           state.inputMode = 'kill';
+           state.inputBuffer = '';
+           render();
+           break;
+         case 'S':
+           state.inputMode = 'signal';
+           state.inputBuffer = 'SIGTERM';
+           render();
+           break;
+         case 't':
+           state.treeView = !state.treeView;
+           setStatus(state.treeView ? 'Tree view enabled' : 'Flat view enabled');
+           render();
+           break;
+         case 'e':
+           exportSnapshot();
+           render();
+           break;
+         case 'l':
+           toggleLogging();
+           render();
+           break;
+         case 'f':
+           const fmtCycle: ExportFormat[] = ['json', 'csv', 'tsv', 'html', 'md'];
+           const curFmt = fmtCycle.indexOf(state.exportFormat);
+           state.exportFormat = fmtCycle[(curFmt + 1) % fmtCycle.length];
+           setStatus(`Export format: ${state.exportFormat}`);
+           render();
+           break;
+         case 'tab':
+           if (key.shift) {
+             // Shift+Tab: go back in panel history
+             if (state.panelHistory.length > 0) {
+               const prev = state.panelHistory.pop()!;
+               state.activePanel = prev as any;
+               setStatus(`Panel: ${prev.toUpperCase()} (back)`);
+             } else {
+               cycleTab(-1);
+             }
+           } else {
+             pushPanelHistory(state.activePanel === 'grid' ? 'cpu' : state.activePanel);
+             cycleTab(1);
+           }
+           break;
+         case 'up':
+           if (state.inputMode === 'command-palette') {
+             state.paletteIndex = Math.max(0, state.paletteIndex - 1);
+             render();
+             return;
+           }
+           if (state.lastData?.processes?.length) {
+             state.trackedPid = null;
+             state.processSelectionIndex = Math.max(0, state.processSelectionIndex - 1);
+             render();
+           }
+           break;
+         case 'down':
+           if (state.inputMode === 'command-palette') {
+             state.paletteIndex = Math.min(state.paletteFilteredCommands.length - 1, state.paletteIndex + 1);
+             render();
+             return;
+           }
+           if (state.lastData?.processes?.length) {
+             state.trackedPid = null;
+             const count = state.lastData.processes.length;
+             state.processSelectionIndex = Math.min(count - 1, state.processSelectionIndex + 1);
+             render();
+           }
+           break;
+         case 'space':
+         case ' ':
+           if (state.lastData?.processes?.length && state.processSelectionIndex >= 0) {
+             const sorted = state.lastData.processes;
+             const proc = sorted[state.processSelectionIndex];
+             if (proc) {
+               if (state.trackedPid === proc.pid) {
+                 state.trackedPid = null;
+                 setStatus(`Stopped following PID ${proc.pid}`);
+               } else {
+                 state.trackedPid = proc.pid;
+                 setStatus(`Following PID ${proc.pid} (${proc.command})`);
+               }
+               render();
+             }
+           }
+           break;
+         case 'return':
+         case 'enter':
+           if (state.inputMode === 'command-palette') {
+             executePaletteCommand();
+             return;
+           }
+           if (state.inputMode === 'bookmark-save') {
+             saveBookmark();
+             return;
+           }
+           if (state.inspectingProcess) {
+             state.inspectingProcess = null;
+             render();
+           } else if (state.lastData?.processes?.length && state.processSelectionIndex >= 0) {
+             const sorted = state.lastData.processes;
+             const proc = sorted[state.processSelectionIndex];
+             if (proc) {
+               state.inspectingProcess = proc;
+               state.trackedPid = proc.pid;
+               setStatus(`Inspecting & following PID ${proc.pid}`);
+               render();
+             }
+           }
+           break;
+         case 'escape':
+         case 'esc':
+           if (state.inputMode === 'quick-ref' || state.inputMode === 'command-palette' || state.inputMode === 'bookmark-save') {
+             state.inputMode = null;
+             state.inputBuffer = '';
+             render();
+             return;
+           }
+           if (state.inspectingProcess) {
+             state.inspectingProcess = null;
+             render();
+           } else if (state.trackedPid !== null) {
+             state.trackedPid = null;
+             setStatus('Stopped following process');
+             render();
+           } else if (state.activePanel !== 'grid') {
+             state.activePanel = 'grid';
+             setStatus('Grid view');
+             render();
+           } else {
+             state.inputMode = 'menu';
+             state.menuSelectionIndex = 0;
+             render();
+           }
+           break;
+         default:
+           if (str && str.length === 1) {
+             if (state.inputMode === 'command-palette' || state.inputMode === 'bookmark-save') {
+               state.inputBuffer += str;
+               if (state.inputMode === 'command-palette') {
+                 updatePaletteFilter();
+               }
+               render();
+               return;
+             }
+             const tabId = tabKeyToId(str);
+             if (tabId) {
+               pushPanelHistory(tabId);
+               state.activePanel = tabId as ActivePanel;
+               setStatus(`Panel: ${tabId.toUpperCase()}`);
+               render();
+             }
+           }
       }
     };
 
@@ -839,15 +985,222 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
     return map[str] ?? null;
   }
 
+  function saveBookmark() {
+    const name = state.inputBuffer.trim() || `view-${state.bookmarks.length + 1}`;
+    const bookmark = {
+      name,
+      activePanel: state.activePanel,
+      sortMode: state.sortMode,
+      processFilter: state.processFilter,
+      treeView: state.treeView,
+      showGraphs: state.showGraphs,
+      graphMode: state.graphMode,
+      trackedPid: state.trackedPid,
+      currentTheme: state.currentTheme,
+      panelLayout: [...state.panelLayout],
+      detailed: state.detailed,
+    };
+    state.bookmarks.push(bookmark);
+    state.inputMode = null;
+    state.inputBuffer = '';
+    setStatus(`Bookmark saved: "${name}" (${state.bookmarks.length} total)`);
+    invalidateTableCache();
+    render();
+  }
+
+  function recallNextBookmark() {
+    if (state.bookmarks.length === 0) {
+      setStatus('No bookmarks saved. Press Shift+M to save current view.');
+      return;
+    }
+    const idx = state.bookmarkRecallIndex % state.bookmarks.length;
+    const bm = state.bookmarks[idx];
+    state.activePanel = bm.activePanel as typeof state.activePanel;
+    state.sortMode = bm.sortMode as typeof state.sortMode;
+    state.processFilter = bm.processFilter;
+    state.treeView = bm.treeView;
+    state.showGraphs = bm.showGraphs;
+    state.graphMode = bm.graphMode as typeof state.graphMode;
+    state.trackedPid = bm.trackedPid;
+    state.currentTheme = bm.currentTheme as typeof state.currentTheme;
+    state.panelLayout = [...bm.panelLayout];
+    state.detailed = bm.detailed;
+    state.bookmarkRecallIndex = (idx + 1) % state.bookmarks.length;
+    setStatus(`Recalled bookmark: "${bm.name}"`);
+    invalidateTableCache();
+    render();
+  }
+
+  function executePaletteCommand() {
+    const cmds = state.paletteFilteredCommands;
+    if (cmds.length === 0 || state.paletteIndex >= cmds.length) {
+      state.inputMode = null;
+      state.inputBuffer = '';
+      state.paletteIndex = 0;
+      render();
+      return;
+    }
+    const cmd = cmds[state.paletteIndex];
+    state.inputMode = null;
+    state.inputBuffer = '';
+    state.paletteIndex = 0;
+
+    // Execute the command
+    switch (cmd.id) {
+      case 'cpu': case 'mem': case 'gpu': case 'power': case 'battery':
+      case 'thermal': case 'network': case 'packets': case 'tasks': case 'disk':
+      case 'process': case 'containers': case 'p2p': case 'anomalies': case 'blender':
+        state.activePanel = state.activePanel === cmd.id ? 'grid' : cmd.id as any;
+        setStatus(state.activePanel === 'grid' ? 'Grid view' : `Panel: ${cmd.id.toUpperCase()}`);
+        break;
+      case 'grid':
+        state.activePanel = 'grid';
+        setStatus('Grid view');
+        break;
+      case 'graph-toggle':
+        state.showGraphs = !state.showGraphs;
+        setStatus(state.showGraphs ? 'Graphs shown' : 'Graphs hidden');
+        break;
+      case 'graph-mode':
+        state.graphMode = state.graphMode === 'spark' ? 'bar' : 'spark';
+        setStatus(`Graph mode: ${state.graphMode}`);
+        break;
+      case 'pause':
+        state.paused = !state.paused;
+        setStatus(state.paused ? 'Paused' : 'Resumed');
+        break;
+      case 'detailed':
+        state.detailed = !state.detailed;
+        setStatus(`Detailed sensor mode: ${state.detailed ? 'on' : 'off'}`);
+        break;
+      case 'tree':
+        state.treeView = !state.treeView;
+        setStatus(state.treeView ? 'Tree view' : 'Flat view');
+        break;
+      case 'temp-unit':
+        state.tempUnit = state.tempUnit === 'c' ? 'f' : 'c';
+        setStatus(`Temperature unit: ${state.tempUnit.toUpperCase()}`);
+        invalidateTableCache();
+        break;
+      case 'filter':
+        state.inputMode = 'filter';
+        state.inputBuffer = state.processFilter;
+        render();
+        return;
+      case 'sort':
+        const sortCycle: SortMode[] = ['cpu', 'mem', 'pid', 'user', 'command', 'state', 'threads', 'runtime'];
+        state.sortMode = sortCycle[(sortCycle.indexOf(state.sortMode) + 1) % sortCycle.length];
+        setStatus(`Sorting by ${state.sortMode}`);
+        break;
+      case 'kill':
+        state.inputMode = 'kill';
+        state.inputBuffer = '';
+        render();
+        return;
+      case 'signal':
+        state.inputMode = 'signal';
+        state.inputBuffer = 'SIGTERM';
+        render();
+        return;
+      case 'export':
+        exportSnapshot();
+        render();
+        return;
+      case 'log':
+        toggleLogging();
+        render();
+        return;
+      case 'format-cycle': {
+        const fmtCycle: ExportFormat[] = ['json', 'csv', 'tsv', 'html', 'md'];
+        state.exportFormat = fmtCycle[(fmtCycle.indexOf(state.exportFormat) + 1) % fmtCycle.length];
+        setStatus(`Export format: ${state.exportFormat}`);
+        break;
+      }
+      case 'interval-inc':
+        state.interval += 1;
+        restartTicker();
+        setStatus(`Interval set to ${state.interval}s`);
+        break;
+      case 'interval-dec':
+        state.interval = Math.max(1, state.interval - 1);
+        restartTicker();
+        setStatus(`Interval set to ${state.interval}s`);
+        break;
+      case 'customize':
+        state.inputMode = 'customizer';
+        state.customizerIndex = 0;
+        render();
+        return;
+      case 'ai-model':
+        state.inputMode = 'ai-model';
+        state.modelSelectionIndex = Math.max(0, AVAILABLE_AI_MODELS.findIndex(m => m.id === state.aiModel));
+        render();
+        return;
+      case 'bookmark-save':
+        state.inputMode = 'bookmark-save';
+        state.inputBuffer = '';
+        render();
+        return;
+      case 'bookmark-recall':
+        recallNextBookmark();
+        render();
+        return;
+      case 'zoom-in':
+        state.graphZoomLevel = Math.max(1, state.graphZoomLevel - 1);
+        state.history.setMaxLen(Math.max(20, 40 * state.graphZoomLevel));
+        setStatus(`History zoom: ${state.graphZoomLevel}x (${state.history.maxLen} points)`);
+        break;
+      case 'zoom-out':
+        state.graphZoomLevel = Math.min(5, state.graphZoomLevel + 1);
+        state.history.setMaxLen(Math.max(20, 40 * state.graphZoomLevel));
+        setStatus(`History zoom: ${state.graphZoomLevel}x (${state.history.maxLen} points)`);
+        break;
+      case 'quick-ref':
+        state.inputMode = state.inputMode === 'quick-ref' ? null : 'quick-ref';
+        render();
+        return;
+    }
+    invalidateTableCache();
+    render();
+  }
+
+  function updatePaletteFilter() {
+    const q = state.inputBuffer.toLowerCase().trim();
+    if (!q) {
+      state.paletteFilteredCommands = [...PALETTE_COMMANDS];
+    } else {
+      state.paletteFilteredCommands = PALETTE_COMMANDS.filter(cmd =>
+        cmd.label.toLowerCase().includes(q) ||
+        cmd.keys.toLowerCase().includes(q) ||
+        cmd.category.toLowerCase().includes(q) ||
+        cmd.id.toLowerCase().includes(q)
+      );
+    }
+    state.paletteIndex = Math.max(0, Math.min(state.paletteIndex, state.paletteFilteredCommands.length - 1));
+  }
+
   function cycleTab(direction: number) {
     const tabs = state.PANEL_TABS.map(t => t.id) as string[];
-    const current = state.activePanel === 'grid' ? -1 : tabs.indexOf(state.activePanel);
-    const next = (current + direction + tabs.length) % tabs.length;
-    state.activePanel = tabs[next] as typeof state.activePanel;
+    const visibleTabs = tabs.filter(id => state.visiblePanels[id as keyof VisibleItems] !== false);
+    const current = state.activePanel === 'grid' ? -1 : visibleTabs.indexOf(state.activePanel);
+    const next = current === -1 ? 0 : (current + direction + visibleTabs.length) % visibleTabs.length;
+    const prev = state.activePanel === 'grid' ? null : state.activePanel;
+    state.activePanel = visibleTabs[next] as typeof state.activePanel;
+    if (prev && prev !== state.activePanel) {
+      pushPanelHistory(prev);
+    }
     setStatus(`Panel: ${state.activePanel.toUpperCase()}`);
     render();
   }
 
+  function pushPanelHistory(panelId: string) {
+    const last = state.panelHistory.length > 0 ? state.panelHistory[state.panelHistory.length - 1] : null;
+    if (panelId !== last) {
+      state.panelHistory.push(panelId);
+      if (state.panelHistory.length > 20) state.panelHistory.shift();
+    }
+  }
+
   function handleNormalMouse(seq: string) {
     if (seq.length < 6) return;
     const cb = seq.charCodeAt(3) - 32;
@@ -890,8 +1243,8 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
 
   function handleMouseClick(y: number, x: number) {
     if (y !== TAB_BAR_ROW) return;
-    const hitboxes = getTabHitboxes();
-    const hit = hitboxes.find(h => x >= h.start && x < h.end);
+    const hitboxes = getTabHitboxes(state.visiblePanels);
+    const hit = hitboxes.find(h => x >= h.start && h.end > x);
     if (hit) {
       state.activePanel = state.activePanel === hit.id ? 'grid' : (hit.id as typeof state.activePanel);
       setStatus(state.activePanel === 'grid' ? 'Grid view' : `Panel: ${hit.id.toUpperCase()}`);