free-coding-models 0.3.18 → 0.3.21

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ---
 
+## 0.3.21
+
+### Changed
+- **Responsive table layout**: the TUI now adapts to narrow terminals by progressively shrinking columns and hiding least-useful ones. Compact mode shortens headers (`Lat. P`, `Avg. P`, `StaB.`, `PrOD…`) and tightens Provider (10 cols), Health (13 cols), Latest Ping (10 cols), and Avg Ping (8 cols). Below compact, Rank → Up% → Tier → Stability are hidden one by one. Minimum usable width: ~116 cols.
+- **SWE% column tightened**: reduced from 9 to 6 columns wide — trims excess right padding without losing data.
+- **Provider truncation in compact mode**: provider names longer than 5 chars are truncated to 4 chars + `…` (e.g. `Cere…`).
+- **Health truncation in compact mode**: status text longer than 6 chars is truncated with `…` (e.g. `🔥 429 TR…`).
+- **Removed "Used" column from TUI**: the token usage column has been removed from the main table as it was outdated.
+- **Width guardrail threshold tightened**: the narrow-terminal warning now triggers only below 80 columns (instead of broader widths) and keeps the same 2-second auto-hide behavior.
+- **Width warning is always enforced in narrow terminals**: removed the `Small Width Warnings` Settings toggle and the `--disable-widths-warning` runtime flag so the startup guardrail stays consistent.
+
+### Fixed
+- **`--premium` filter lock-in**: premium now applies a resettable startup preset (S-tier + verdict sort) instead of hard-locking an extra hidden elite-only filter.
+
+## 0.3.19
+
+### Added
+- **Command palette overlay (`Ctrl+P`)**: Added a searchable floating palette with fuzzy matching so users can quickly run filters, sorts, overlays, and global actions.
+
+### Changed
+- **Main footer and help discoverability**: surfaced `Ctrl+P` in table hints and Help overlay so the new command launcher is visible immediately.
+- **Command palette spacing polish**: added two-character inner padding around the floating palette so the overlay feels less cramped and visually cleaner.
+
+### Fixed
+- **Command palette visual jitter**: background ping cycles now pause while the command palette is open so table rows stop reshuffling during command search.
+- **Command palette background freeze**: while the palette is open, the full table behind it is now frozen (spinner glyphs, ping countdown, and dynamic row updates) and resumes instantly on close.
+
 ## 0.3.18
 
 ### Added

package/README.md

@@ -133,7 +133,7 @@ free-coding-models --goose --tier S
 # "I want NVIDIA's top models only"
 free-coding-models --origin nvidia --tier S
 
-# "Show me only elite models that are currently healthy"
+# "Start with an elite-focused preset, then adjust filters live"
 free-coding-models --premium
 
 # "I want to script this — give me JSON"
@@ -176,6 +176,7 @@ Press **`Z`** in the TUI to cycle between tools without restarting.
 | `E` | Toggle configured-only mode |
 | `F` | Favorite / unfavorite model |
 | `G` | Cycle global theme (`Auto → Dark → Light`) |
+| `Ctrl+P` | Open command palette (search + run actions) |
 | `R/S/C/M/O/L/A/H/V/B/U` | Sort columns |
 | `P` | Settings (API keys, providers, updates, theme) |
 | `Y` | Install Endpoints (push provider into tool config) |
@@ -200,6 +201,7 @@ Press **`Z`** in the TUI to cycle between tools without restarting.
 - **Configured-only default** — only shows providers you have keys for
 - **Keyless latency** — models ping even without an API key (show 🔑 NO KEY)
 - **Smart Recommend** — questionnaire picks the best model for your task type
+- **Command Palette** — `Ctrl+P` opens a searchable action launcher for filters, sorting, overlays, and quick toggles
 - **Install Endpoints** — push a full provider catalog into any tool's config (`Y`)
 - **Missing tool bootstrap** — detect absent CLIs, offer one-click install, then continue the selected launch automatically
 - **Width guardrail** — shows a warning instead of a broken table in narrow terminals

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "free-coding-models",
-  "version": "0.3.18",
+  "version": "0.3.21",
   "description": "Find the fastest coding LLM models in seconds — ping free models from multiple providers, pick the best one for OpenCode, Cursor, or any AI coding assistant.",
   "keywords": [
     "nvidia",

package/src/app.js

@@ -105,7 +105,7 @@ import { usageForRow as _usageForRow } from '../src/usage-reader.js'
 import { buildProviderModelTokenKey, loadTokenUsageByProviderModel } from '../src/token-usage-reader.js'
 import { parseOpenRouterResponse, fetchProviderQuota as _fetchProviderQuotaFromModule } from '../src/provider-quota-fetchers.js'
 import { isKnownQuotaTelemetry } from '../src/quota-capabilities.js'
-import { ALT_ENTER, ALT_LEAVE, ALT_HOME, PING_TIMEOUT, PING_INTERVAL, FPS, COL_MODEL, COL_MS, CELL_W, FRAMES, TIER_CYCLE, SETTINGS_OVERLAY_BG, HELP_OVERLAY_BG, RECOMMEND_OVERLAY_BG, OVERLAY_PANEL_WIDTH, TABLE_HEADER_LINES, TABLE_FOOTER_LINES, TABLE_FIXED_LINES, msCell, spinCell } from '../src/constants.js'
+import { ALT_ENTER, ALT_LEAVE, ALT_HOME, PING_TIMEOUT, PING_INTERVAL, FPS, COL_MODEL, COL_MS, CELL_W, FRAMES, TIER_CYCLE, SETTINGS_OVERLAY_BG, HELP_OVERLAY_BG, RECOMMEND_OVERLAY_BG, OVERLAY_PANEL_WIDTH, TABLE_HEADER_LINES, TABLE_FOOTER_LINES, TABLE_FIXED_LINES, WIDTH_WARNING_MIN_COLS, msCell, spinCell } from '../src/constants.js'
 import { TIER_COLOR } from '../src/tier-colors.js'
 import { resolveCloudflareUrl, buildPingRequest, ping, extractQuotaPercent, getProviderQuotaPercentCached, usagePlaceholderForProvider } from '../src/ping.js'
 import { runFiableMode, filterByTierOrExit, fetchOpenRouterFreeModels } from '../src/analysis.js'
@@ -192,9 +192,8 @@ export async function runApp(cliArgs, config) {
   if (cliArgs.pingInterval) config.settings.pingInterval = cliArgs.pingInterval
   if (cliArgs.hideUnconfigured) config.settings.hideUnconfiguredModels = true
   if (cliArgs.showUnconfigured) config.settings.hideUnconfiguredModels = false
-  if (cliArgs.disableWidthsWarning) config.settings.disableWidthsWarning = true
 
-  // 📖 Apply premium mode: show only S‑tier models sorted by verdict
+  // 📖 Apply premium mode as an initial, user-resettable view preset.
   if (cliArgs.premiumMode) {
     config.settings.tierFilter = 'S'
     config.settings.sortColumn = 'verdict'
@@ -383,13 +382,11 @@ export async function runApp(cliArgs, config) {
     mode,                         // 📖 'opencode' or 'openclaw' — controls Enter action
     tierFilterMode: 0,            // 📖 Index into TIER_CYCLE (0=All, 1=S+, 2=S, ...)
     originFilterMode: 0,          // 📖 Index into ORIGIN_CYCLE (0=All, then providers)
-    premiumMode: cliArgs.premiumMode, // 📖 Special elite-only mode: S/S+ only, Health UP only, Perfect/Normal/Slow verdict only.
     hideUnconfiguredModels: config.settings?.hideUnconfiguredModels === true, // 📖 Hide providers with no configured API key when true.
-    disableWidthsWarning: config.settings?.disableWidthsWarning ?? false, // 📖 Cached for runtime checks; keep it in sync with config.settings.
       scrollOffset: 0,              // 📖 First visible model index in viewport
       terminalRows: process.stdout.rows || 24,  // 📖 Current terminal height
       terminalCols: process.stdout.columns || 80, // 📖 Current terminal width
-      widthWarningStartedAt: (process.stdout.columns || 80) < 166 && !(config.settings?.disableWidthsWarning ?? false) ? now : null, // 📖 Start immediately only when warnings are enabled in a narrow viewport.
+      widthWarningStartedAt: (process.stdout.columns || 80) < WIDTH_WARNING_MIN_COLS ? now : null, // 📖 Start immediately in very narrow viewports.
     widthWarningDismissed: false, // 📖 Esc hides the narrow-terminal warning early for the current narrow-width session.
     widthWarningShowCount: 0, // 📖 Counter for how many times the narrow-terminal warning has been shown (max 2 per session).
     // 📖 Settings screen state (P key opens it)
@@ -406,6 +403,12 @@ export async function runApp(cliArgs, config) {
     settingsUpdateError: null,    // 📖 Last update-check error message for maintenance row
     config,                       // 📖 Live reference to the config object (updated on save)
     visibleSorted: [],            // 📖 Cached visible+sorted models — shared between render loop and key handlers
+    commandPaletteOpen: false,    // 📖 Whether the Ctrl+P command palette overlay is active.
+    commandPaletteQuery: '',      // 📖 Current command palette search query.
+    commandPaletteCursor: 0,      // 📖 Selected command index in the filtered command list.
+    commandPaletteScrollOffset: 0, // 📖 Vertical scroll offset for the command palette result viewport.
+    commandPaletteResults: [],    // 📖 Cached fuzzy-filtered command entries for the command palette.
+    commandPaletteFrozenTable: null, // 📖 Frozen table snapshot rendered behind the command palette overlay.
     helpVisible: false,           // 📖 Whether the help overlay (K key) is active
     settingsScrollOffset: 0,      // 📖 Vertical scroll offset for Settings overlay viewport
     helpScrollOffset: 0,          // 📖 Vertical scroll offset for Help overlay viewport
@@ -459,12 +462,10 @@ export async function runApp(cliArgs, config) {
   // 📖 Re-clamp viewport on terminal resize
   process.stdout.on('resize', () => {
     const prevCols = state.terminalCols
-    const widthsWarningDisabled = state.config.settings?.disableWidthsWarning === true
     state.terminalRows = process.stdout.rows || 24
     state.terminalCols = process.stdout.columns || 80
-    state.disableWidthsWarning = widthsWarningDisabled
-    if (state.terminalCols < 166 && !widthsWarningDisabled) {
-      if (prevCols >= 166 || state.widthWarningDismissed) {
+    if (state.terminalCols < WIDTH_WARNING_MIN_COLS) {
+      if (prevCols >= WIDTH_WARNING_MIN_COLS || state.widthWarningDismissed) {
         state.widthWarningStartedAt = Date.now()
         state.widthWarningDismissed = false
         state.widthWarningShowCount++ // 📖 Increment counter when showing the warning again
@@ -624,15 +625,10 @@ export async function runApp(cliArgs, config) {
       outputResults = outputResults.filter(r => ['S+', 'S', 'A+'].includes(r.tier))
     }
 
-    // 📖 Apply premium mode filter if specified: elite-only (S/S+, UP, Good Verdict)
+    // 📖 Apply premium mode as a preselected tier family in JSON mode as well.
     if (cliArgs.premiumMode) {
-      outputResults = outputResults.filter(r => {
-        const isEliteTier = r.tier === 'S' || r.tier === 'S+'
-        const isHealthUp = r.status === 'up'
-        const verdict = getVerdict(r)
-        const isGoodVerdict = ['Perfect', 'Normal', 'Slow'].includes(verdict)
-        return isEliteTier && isHealthUp && isGoodVerdict
-      })
+      const premiumTiers = TIER_LETTER_MAP.S || ['S+', 'S']
+      outputResults = outputResults.filter(r => premiumTiers.includes(r.tier))
     }
 
     // 📖 Sort by avg ping (ascending)
@@ -696,17 +692,6 @@ export async function runApp(cliArgs, config) {
       const originHide = activeOrigin !== null && r.providerKey !== activeOrigin
       r.hidden = tierHide || originHide
 
-      // 📖 Premium Mode: elite-only constraints (Health UP, Good Verdict, S/S+ only)
-      if (state.premiumMode && !r.hidden) {
-        const isEliteTier = r.tier === 'S' || r.tier === 'S+'
-        const isHealthUp = r.status === 'up'
-        const verdict = getVerdict(r)
-        const isGoodVerdict = ['Perfect', 'Normal', 'Slow'].includes(verdict)
-
-        if (!isEliteTier || !isHealthUp || !isGoodVerdict) {
-          r.hidden = true
-        }
-      }
     })
     return state.results
   }
@@ -761,6 +746,7 @@ export async function runApp(cliArgs, config) {
     getToolMeta,
     getToolInstallPlan,
     padEndDisplay,
+    displayWidth,
   })
 
   onKeyPress = createKeyHandler({
@@ -858,16 +844,85 @@ export async function runApp(cliArgs, config) {
     refreshAutoPingMode()
     state.frame++
     // 📖 Cache visible+sorted models each frame so Enter handler always matches the display
-    if (!state.settingsOpen && !state.installEndpointsOpen && !state.toolInstallPromptOpen && !state.recommendOpen && !state.feedbackOpen && !state.changelogOpen) {
+    if (!state.settingsOpen && !state.installEndpointsOpen && !state.toolInstallPromptOpen && !state.recommendOpen && !state.feedbackOpen && !state.changelogOpen && !state.commandPaletteOpen) {
       const visible = state.results.filter(r => !r.hidden)
       state.visibleSorted = sortResultsWithPinnedFavorites(visible, state.sortColumn, state.sortDirection)
     }
+    let tableContent = null
+    if (state.commandPaletteOpen) {
+      if (!state.commandPaletteFrozenTable) {
+        // 📖 Freeze the full table (including countdown and spinner glyphs) while
+        // 📖 the command palette is open so the background remains perfectly static.
+        state.commandPaletteFrozenTable = renderTable(
+          state.results,
+          state.pendingPings,
+          state.frame,
+          state.cursor,
+          state.sortColumn,
+          state.sortDirection,
+          state.pingInterval,
+          state.lastPingTime,
+          state.mode,
+          state.tierFilterMode,
+          state.scrollOffset,
+          state.terminalRows,
+          state.terminalCols,
+          state.originFilterMode,
+          null,
+          state.pingMode,
+          state.pingModeSource,
+          state.hideUnconfiguredModels,
+          state.widthWarningStartedAt,
+          state.widthWarningDismissed,
+          state.widthWarningShowCount,
+          state.settingsUpdateState,
+          state.settingsUpdateLatestVersion,
+          false,
+          state.startupLatestVersion,
+          state.versionAlertsEnabled
+        )
+      }
+      tableContent = state.commandPaletteFrozenTable
+    } else {
+      state.commandPaletteFrozenTable = null
+      tableContent = renderTable(
+        state.results,
+        state.pendingPings,
+        state.frame,
+        state.cursor,
+        state.sortColumn,
+        state.sortDirection,
+        state.pingInterval,
+        state.lastPingTime,
+        state.mode,
+        state.tierFilterMode,
+        state.scrollOffset,
+        state.terminalRows,
+        state.terminalCols,
+        state.originFilterMode,
+        null,
+        state.pingMode,
+        state.pingModeSource,
+        state.hideUnconfiguredModels,
+        state.widthWarningStartedAt,
+        state.widthWarningDismissed,
+        state.widthWarningShowCount,
+        state.settingsUpdateState,
+        state.settingsUpdateLatestVersion,
+        false,
+        state.startupLatestVersion,
+        state.versionAlertsEnabled
+      )
+    }
+
     const content = state.settingsOpen
       ? overlays.renderSettings()
       : state.installEndpointsOpen
         ? overlays.renderInstallEndpoints()
       : state.toolInstallPromptOpen
         ? overlays.renderToolInstallPrompt()
+      : state.commandPaletteOpen
+        ? tableContent + overlays.renderCommandPalette()
       : state.recommendOpen
         ? overlays.renderRecommend()
         : state.feedbackOpen
@@ -876,7 +931,7 @@ export async function runApp(cliArgs, config) {
                 ? overlays.renderHelp()
               : state.changelogOpen
                 ? overlays.renderChangelog()
-                 : renderTable(state.results, state.pendingPings, state.frame, state.cursor, state.sortColumn, state.sortDirection, state.pingInterval, state.lastPingTime, state.mode, state.tierFilterMode, state.scrollOffset, state.terminalRows, state.terminalCols, state.originFilterMode, null, state.pingMode, state.pingModeSource, state.hideUnconfiguredModels, state.widthWarningStartedAt, state.widthWarningDismissed, state.widthWarningShowCount, state.settingsUpdateState, state.settingsUpdateLatestVersion, false, state.startupLatestVersion, state.versionAlertsEnabled, state.config.settings?.disableWidthsWarning ?? false)
+                 : tableContent
     process.stdout.write(ALT_HOME + content)
     if (process.stdout.isTTY) {
       process.stdout.flush && process.stdout.flush()
@@ -894,7 +949,7 @@ export async function runApp(cliArgs, config) {
   const initialVisible = state.results.filter(r => !r.hidden)
   state.visibleSorted = sortResultsWithPinnedFavorites(initialVisible, state.sortColumn, state.sortDirection)
 
-  process.stdout.write(ALT_HOME + renderTable(state.results, state.pendingPings, state.frame, state.cursor, state.sortColumn, state.sortDirection, state.pingInterval, state.lastPingTime, state.mode, state.tierFilterMode, state.scrollOffset, state.terminalRows, state.terminalCols, state.originFilterMode, null, state.pingMode, state.pingModeSource, state.hideUnconfiguredModels, state.widthWarningStartedAt, state.widthWarningDismissed, state.widthWarningShowCount, state.settingsUpdateState, state.settingsUpdateLatestVersion, false, state.startupLatestVersion, state.versionAlertsEnabled, state.config.settings?.disableWidthsWarning ?? false))
+  process.stdout.write(ALT_HOME + renderTable(state.results, state.pendingPings, state.frame, state.cursor, state.sortColumn, state.sortDirection, state.pingInterval, state.lastPingTime, state.mode, state.tierFilterMode, state.scrollOffset, state.terminalRows, state.terminalCols, state.originFilterMode, null, state.pingMode, state.pingModeSource, state.hideUnconfiguredModels, state.widthWarningStartedAt, state.widthWarningDismissed, state.widthWarningShowCount, state.settingsUpdateState, state.settingsUpdateLatestVersion, false, state.startupLatestVersion, state.versionAlertsEnabled))
   if (process.stdout.isTTY) {
     process.stdout.flush && process.stdout.flush()
   }
@@ -920,6 +975,15 @@ export async function runApp(cliArgs, config) {
   const runPingCycle = async () => {
     try {
     refreshAutoPingMode()
+
+    // 📖 Command palette intentionally pauses background ping bursts to avoid
+    // 📖 visible row jitter while users type and navigate commands.
+    if (state.commandPaletteOpen) {
+      state.lastPingTime = Date.now()
+      scheduleNextPing()
+      return
+    }
+
     state.lastPingTime = Date.now()
 
     // 📖 Refresh persisted usage snapshots each cycle so background usage data appears live in table.

package/src/cli-help.js

@@ -26,14 +26,13 @@ const ANALYSIS_FLAGS = [
   { flag: '--json', description: 'Output results as JSON for scripts/automation' },
   { flag: '--tier <S|A|B|C>', description: 'Filter models by tier family' },
   { flag: '--recommend', description: 'Open Smart Recommend immediately on startup' },
-  { flag: '--premium', description: 'Show only S/S+ models with perfect health and good verdict' },
+  { flag: '--premium', description: 'Start with S-tier filter + verdict sort (you can reset it in-app)' },
   { flag: '--sort <column>', description: 'Sort by column (rank, tier, origin, model, ping, avg, swe, ctx, condition, verdict, uptime, stability, usage)' },
   { flag: '--desc | --asc', description: 'Set sort direction (descending or ascending)' },
   { flag: '--origin <provider>', description: 'Filter models by provider origin' },
   { flag: '--ping-interval <ms>', description: 'Override ping interval in milliseconds' },
   { flag: '--hide-unconfigured', description: 'Hide models without configured API keys' },
   { flag: '--show-unconfigured', description: 'Show all models regardless of API key config' },
-  { flag: '--disable-widths-warning', description: 'Disable terminal width warning' },
 ]
 
 const CONFIG_FLAGS = [

package/src/command-palette.js

@@ -0,0 +1,170 @@
+/**
+ * @file command-palette.js
+ * @description Command palette registry and fuzzy search helpers for the main TUI.
+ *
+ * @functions
+ *   → `buildCommandPaletteEntries` — builds the current command list with dynamic provider/tier context
+ *   → `fuzzyMatchCommand` — scores a query against one string and returns match positions
+ *   → `filterCommandPaletteEntries` — returns sorted command matches for a query
+ *
+ * @exports { COMMAND_CATEGORY_ORDER, buildCommandPaletteEntries, fuzzyMatchCommand, filterCommandPaletteEntries }
+ *
+ * @see src/key-handler.js
+ * @see src/overlays.js
+ */
+
+export const COMMAND_CATEGORY_ORDER = ['Filters', 'Sort', 'Pages', 'Actions']
+
+const COMMANDS = [
+  // 📖 Filters
+  { id: 'filter-tier-all', category: 'Filters', label: 'Filter tiers: all', shortcut: 'T', keywords: ['filter', 'tier', 'all'] },
+  { id: 'filter-tier-splus', category: 'Filters', label: 'Filter tiers: S+', shortcut: null, keywords: ['filter', 'tier', 's+'] },
+  { id: 'filter-tier-s', category: 'Filters', label: 'Filter tiers: S', shortcut: null, keywords: ['filter', 'tier', 's'] },
+  { id: 'filter-tier-aplus', category: 'Filters', label: 'Filter tiers: A+', shortcut: null, keywords: ['filter', 'tier', 'a+'] },
+  { id: 'filter-tier-a', category: 'Filters', label: 'Filter tiers: A', shortcut: null, keywords: ['filter', 'tier', 'a'] },
+  { id: 'filter-tier-aminus', category: 'Filters', label: 'Filter tiers: A-', shortcut: null, keywords: ['filter', 'tier', 'a-'] },
+  { id: 'filter-tier-bplus', category: 'Filters', label: 'Filter tiers: B+', shortcut: null, keywords: ['filter', 'tier', 'b+'] },
+  { id: 'filter-tier-b', category: 'Filters', label: 'Filter tiers: B', shortcut: null, keywords: ['filter', 'tier', 'b'] },
+  { id: 'filter-tier-c', category: 'Filters', label: 'Filter tiers: C', shortcut: null, keywords: ['filter', 'tier', 'c'] },
+  { id: 'filter-provider-cycle', category: 'Filters', label: 'Filter provider: cycle', shortcut: 'D', keywords: ['filter', 'provider', 'origin'] },
+  { id: 'filter-configured-toggle', category: 'Filters', label: 'Toggle configured-only models', shortcut: 'E', keywords: ['filter', 'configured', 'keys'] },
+
+  // 📖 Sorting
+  { id: 'sort-rank', category: 'Sort', label: 'Sort by rank', shortcut: 'R', keywords: ['sort', 'rank'] },
+  { id: 'sort-tier', category: 'Sort', label: 'Sort by tier', shortcut: null, keywords: ['sort', 'tier'] },
+  { id: 'sort-provider', category: 'Sort', label: 'Sort by provider', shortcut: 'O', keywords: ['sort', 'origin', 'provider'] },
+  { id: 'sort-model', category: 'Sort', label: 'Sort by model name', shortcut: 'M', keywords: ['sort', 'model', 'name'] },
+  { id: 'sort-latest-ping', category: 'Sort', label: 'Sort by latest ping', shortcut: 'L', keywords: ['sort', 'latest', 'ping'] },
+  { id: 'sort-avg-ping', category: 'Sort', label: 'Sort by average ping', shortcut: 'A', keywords: ['sort', 'avg', 'average', 'ping'] },
+  { id: 'sort-swe', category: 'Sort', label: 'Sort by SWE score', shortcut: 'S', keywords: ['sort', 'swe', 'score'] },
+  { id: 'sort-ctx', category: 'Sort', label: 'Sort by context window', shortcut: 'C', keywords: ['sort', 'context', 'ctx'] },
+  { id: 'sort-health', category: 'Sort', label: 'Sort by health', shortcut: 'H', keywords: ['sort', 'health', 'condition'] },
+  { id: 'sort-verdict', category: 'Sort', label: 'Sort by verdict', shortcut: 'V', keywords: ['sort', 'verdict'] },
+  { id: 'sort-stability', category: 'Sort', label: 'Sort by stability', shortcut: 'B', keywords: ['sort', 'stability'] },
+  { id: 'sort-uptime', category: 'Sort', label: 'Sort by uptime', shortcut: 'U', keywords: ['sort', 'uptime'] },
+
+  // 📖 Pages / overlays
+  { id: 'open-settings', category: 'Pages', label: 'Open settings', shortcut: 'P', keywords: ['settings', 'config', 'api key'] },
+  { id: 'open-help', category: 'Pages', label: 'Open help', shortcut: 'K', keywords: ['help', 'shortcuts', 'hotkeys'] },
+  { id: 'open-changelog', category: 'Pages', label: 'Open changelog', shortcut: 'N', keywords: ['changelog', 'release'] },
+  { id: 'open-feedback', category: 'Pages', label: 'Open feedback', shortcut: 'I', keywords: ['feedback', 'bug', 'request'] },
+  { id: 'open-recommend', category: 'Pages', label: 'Open smart recommend', shortcut: 'Q', keywords: ['recommend', 'best model'] },
+  { id: 'open-install-endpoints', category: 'Pages', label: 'Open install endpoints', shortcut: 'Y', keywords: ['install', 'endpoints', 'providers'] },
+
+  // 📖 Actions
+  { id: 'action-cycle-theme', category: 'Actions', label: 'Cycle theme', shortcut: 'G', keywords: ['theme', 'dark', 'light', 'auto'] },
+  { id: 'action-cycle-tool-mode', category: 'Actions', label: 'Cycle tool mode', shortcut: 'Z', keywords: ['tool', 'mode', 'launcher'] },
+  { id: 'action-cycle-ping-mode', category: 'Actions', label: 'Cycle ping mode', shortcut: 'W', keywords: ['ping', 'cadence', 'speed', 'slow'] },
+  { id: 'action-toggle-favorite', category: 'Actions', label: 'Toggle favorite on selected model', shortcut: 'F', keywords: ['favorite', 'star'] },
+  { id: 'action-reset-view', category: 'Actions', label: 'Reset view settings', shortcut: 'Shift+R', keywords: ['reset', 'view', 'sort', 'filters'] },
+]
+
+const ID_TO_TIER = {
+  'filter-tier-all': null,
+  'filter-tier-splus': 'S+',
+  'filter-tier-s': 'S',
+  'filter-tier-aplus': 'A+',
+  'filter-tier-a': 'A',
+  'filter-tier-aminus': 'A-',
+  'filter-tier-bplus': 'B+',
+  'filter-tier-b': 'B',
+  'filter-tier-c': 'C',
+}
+
+export function buildCommandPaletteEntries() {
+  return COMMANDS.map((entry) => ({
+    ...entry,
+    tierValue: Object.prototype.hasOwnProperty.call(ID_TO_TIER, entry.id) ? ID_TO_TIER[entry.id] : undefined,
+  }))
+}
+
+/**
+ * 📖 Fuzzy matching optimized for short command labels and keyboard aliases.
+ * @param {string} query
+ * @param {string} text
+ * @returns {{ matched: boolean, score: number, positions: number[] }}
+ */
+export function fuzzyMatchCommand(query, text) {
+  const q = (query || '').trim().toLowerCase()
+  const t = (text || '').toLowerCase()
+
+  if (!q) return { matched: true, score: 0, positions: [] }
+  if (!t) return { matched: false, score: 0, positions: [] }
+
+  let qIdx = 0
+  const positions = []
+  for (let i = 0; i < t.length && qIdx < q.length; i++) {
+    if (q[qIdx] === t[i]) {
+      positions.push(i)
+      qIdx++
+    }
+  }
+
+  if (qIdx !== q.length) return { matched: false, score: 0, positions: [] }
+
+  let score = q.length * 10
+
+  // 📖 Bonus when matches are contiguous.
+  for (let i = 1; i < positions.length; i++) {
+    if (positions[i] === positions[i - 1] + 1) score += 5
+  }
+
+  // 📖 Bonus for word boundaries and prefix matches.
+  for (const pos of positions) {
+    if (pos === 0) score += 8
+    else {
+      const prev = t[pos - 1]
+      if (prev === ' ' || prev === ':' || prev === '-' || prev === '/') score += 6
+    }
+  }
+
+  // 📖 Small penalty for very long labels so focused labels float up.
+  score -= Math.max(0, t.length - q.length)
+
+  return { matched: true, score, positions }
+}
+
+/**
+ * 📖 Filter and rank command palette entries by fuzzy score.
+ * @param {Array<{ id: string, label: string, category: string, keywords?: string[] }>} entries
+ * @param {string} query
+ * @returns {Array<{ id: string, label: string, category: string, shortcut?: string|null, keywords?: string[], score: number, matchPositions: number[] }>}
+ */
+export function filterCommandPaletteEntries(entries, query) {
+  const normalizedQuery = (query || '').trim()
+
+  const ranked = []
+  for (const entry of entries) {
+    const labelMatch = fuzzyMatchCommand(normalizedQuery, entry.label)
+    let bestScore = labelMatch.score
+    let matchPositions = labelMatch.positions
+    let matched = labelMatch.matched
+
+    if (!matched && Array.isArray(entry.keywords)) {
+      for (const keyword of entry.keywords) {
+        const keywordMatch = fuzzyMatchCommand(normalizedQuery, keyword)
+        if (!keywordMatch.matched) continue
+        matched = true
+        // 📖 Keyword matches should rank below direct label matches.
+        const keywordScore = Math.max(1, keywordMatch.score - 7)
+        if (keywordScore > bestScore) {
+          bestScore = keywordScore
+          matchPositions = []
+        }
+      }
+    }
+
+    if (!matched) continue
+    ranked.push({ ...entry, score: bestScore, matchPositions })
+  }
+
+  ranked.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score
+    const aCat = COMMAND_CATEGORY_ORDER.indexOf(a.category)
+    const bCat = COMMAND_CATEGORY_ORDER.indexOf(b.category)
+    if (aCat !== bCat) return aCat - bCat
+    return a.label.localeCompare(b.label)
+  })
+
+  return ranked
+}

package/src/config.js

@@ -209,7 +209,6 @@ function normalizeSettingsSection(settings) {
   return {
     ...safeSettings,
     hideUnconfiguredModels: typeof safeSettings.hideUnconfiguredModels === 'boolean' ? safeSettings.hideUnconfiguredModels : true,
-    disableWidthsWarning: safeSettings.disableWidthsWarning === true,
     theme: ['dark', 'light', 'auto'].includes(safeSettings.theme) ? safeSettings.theme : 'auto',
   }
 }
@@ -230,7 +229,6 @@ function normalizeProfileSettings(settings) {
   return {
     ..._emptyProfileSettings(),
     ...safeSettings,
-    disableWidthsWarning: safeSettings.disableWidthsWarning === true,
     theme: ['dark', 'light', 'auto'].includes(safeSettings.theme) ? safeSettings.theme : 'auto',
   }
 }
@@ -843,7 +841,6 @@ export function _emptyProfileSettings() {
     pingInterval: 10000,  // 📖 default ms between pings in the steady "normal" mode
     hideUnconfiguredModels: true, // 📖 true = default to providers that are actually configured
     preferredToolMode: 'opencode', // 📖 remember the last Z-selected launcher across app restarts
-    disableWidthsWarning: false, // 📖 Disable widths warning (default off)
     theme: 'auto',        // 📖 'auto' follows the terminal/OS theme, override with 'dark' or 'light' if needed
   }
 }

package/src/constants.js

@@ -17,6 +17,7 @@
  *   - `CELL_W` is derived from `COL_MS` and used by `msCell` / `spinCell`.
  *   - `TABLE_HEADER_LINES` + `TABLE_FOOTER_LINES` = `TABLE_FIXED_LINES` must stay in sync
  *     with the actual number of lines rendered by `renderTable()` in bin/.
+ *   - `WIDTH_WARNING_MIN_COLS` controls when the narrow-terminal startup warning appears.
  *   - Overlay background colours (chalk.bgRgb) make each overlay panel visually distinct.
  *
  * @functions
@@ -30,6 +31,7 @@
  *   FRAMES, TIER_CYCLE,
  *   SETTINGS_OVERLAY_BG, HELP_OVERLAY_BG, RECOMMEND_OVERLAY_BG, LOG_OVERLAY_BG,
  *   OVERLAY_PANEL_WIDTH,
+ *   WIDTH_WARNING_MIN_COLS,
  *   TABLE_HEADER_LINES, TABLE_FOOTER_LINES, TABLE_FIXED_LINES,
  *   msCell, spinCell
  *
@@ -83,6 +85,9 @@ export const LOG_OVERLAY_BG       = chalk.bgRgb(0, 0, 0)  // 📖 Dark blue-gree
 // 📖 tint fills the panel consistently regardless of content length.
 export const OVERLAY_PANEL_WIDTH = 116
 
+// 📖 Narrow-terminal warning appears only below this width.
+export const WIDTH_WARNING_MIN_COLS = 80
+
 // 📖 Table row-budget constants — must stay in sync with renderTable()'s actual output.
 // 📖 If this drifts, model rows overflow and can push the title row out of view.
 export const TABLE_HEADER_LINES = 4  // 📖 title, spacer, column headers, separator