free-coding-models 0.3.21 → 0.3.22

package/CHANGELOG.md

@@ -1,7 +1,36 @@
 # Changelog
-
 ---
 
+## 0.3.22
+
+### Added
+- **Hierarchical command palette navigation**: Ctrl+P now opens an improved command palette with expandable/collapsible categories and subcategories for better organization.
+- **Arrow key navigation in command palette**: Use left/right arrows to expand and collapse categories, up/down to navigate, Enter to execute or toggle.
+- **Rich color scheme for command palette**: Categories use bold blue headers, subcategories use bold text, commands show keyboard shortcuts.
+- **Visual expand/collapse indicators**: ▼ shows expanded categories, ▶ shows collapsed, • marks individual commands.
+- **Concise default view**: Categories are collapsed by default (except Filters) showing less detail on first open.
+- **Colored tier filters**: Tier filters (S+, S, A+, A, A-, B+, B, C) now display with their corresponding TUI colors for quick identification.
+- **Specific provider filters**: Added 13 individual provider filters (NVIDIA NIM, Groq, Cerebras, SambaNova, OpenRouter, Together AI, DeepInfra, Fireworks, Hyperbolic, Google AI, Hugging Face) with their signature provider colors.
+- **Filter by model category**: New "Filter by model" category with autocomplete that dynamically shows top 20 visible models, complete with provider icons and colored model names.
+- **Improved search cursor**: Cursor placement fixed to appear right after the `>` prompt instead of after placeholder text for natural typing flow.
+- **Lightning bolt in title**: Command Palette title now shows ⚡ emoji for better visibility and visual appeal.
+
+### Changed
+- **Footer layout cleanup**: Added consistent spacing before `F Toggle Favorite`, moved `N Changelog • Ctrl+C Exit` to a dedicated final footer line for better readability.
+- **Removed Y key binding**: Install Endpoints is no longer a direct hotkey — accessible only via Settings (`P`) or Command Palette (`Ctrl+P`). The `Y` key is now free/unbound.
+- **Removed proxy notice from footer**: The "Proxy is temporarily disabled" banner has been fully retired from the TUI footer and its backing constant removed.
+- **Command palette fuzzy search fix**: `buildCommandPaletteEntries()` now expands all categories so child commands are visible to fuzzy search.
+- **Flat Pages + Actions in ⚡️ Command Palette**: page entries and action entries are now listed directly at root level (no extra submenu depth) for faster access.
+- **Command explanations after shortcuts**: command palette rows now show concise English hints after hotkeys (example: `(Z) — Change target AI Coding CLI Tool.`).
+- **⚡️ emoji consistency**: user-facing Command Palette mentions now consistently render as `⚡️ Command Palette` in TUI and docs.
+- **README Quick Start flow**: install section now explicitly adds “create a free account on one of the providers” with a direct anchor link.
+- **Provider section renamed for clarity**: Quick Start provider table now lives under `List of Free AI Providers`.
+- **Quick Start CTA highlight**: added a large green `USE ⚡️ COMMAND PALETTE / CTRL+P` badge right after the command palette instruction.
+
+### Fixed
+- **Double emoji display bug**: Fixed duplicate emoji icons in command palette entries (was showing `▶ 🔍 🔍 Filters` instead of `▶ 🔍 Filters`).
+- **Provider cycle command behavior**: `Cycle provider` in ⚡️ Command Palette now correctly cycles providers again instead of resetting to `All`.
+
 ## 0.3.21
 
 ### Changed

package/README.md

@@ -22,12 +22,14 @@ npm install -g free-coding-models
 free-coding-models
 ```
 
+create a free account on one of the [providers](#-list-of-free-ai-providers)
+
 </p>
 
 <p align="center">
   <a href="#-why-this-tool">Why</a> •
   <a href="#-quick-start">Quick Start</a> •
-  <a href="#-providers">Providers</a> •
+  <a href="#-list-of-free-ai-providers">Providers</a> •
   <a href="#-usage">Usage</a> •
   <a href="#-tui-keys">TUI Keys</a> •
   <a href="#-contributing">Contributing</a>
@@ -55,7 +57,9 @@ It then writes the model you pick directly into your coding tool's config — so
 
 ## ⚡ Quick Start
 
-**① Get a free API key** — you only need one to get started:
+### 🟢 List of Free AI Providers
+
+Create a free account on one provider below to get started:
 
 **160 coding models** across 20 providers, ranked by [SWE-bench Verified](https://www.swebench.com).
 
@@ -94,7 +98,7 @@ It then writes the model you pick directly into your coding tool's config — so
 | **A-/B+** | 30–40% | Smaller tasks, constrained infra |
 | **B/C** | < 30% | Code completion, edge/minimal setups |
 
-**② Install and run:**
+**① Install and run:**
 
 ```bash
 npm install -g free-coding-models
@@ -103,9 +107,15 @@ free-coding-models
 
 On first run, you'll be prompted to enter your API key(s). You can skip providers and add more later with **`P`**.
 
+Use ⚡️ Command Palette! with **Ctrl+P**.
+
+<p align="center">
+  <img src="https://img.shields.io/badge/USE_%E2%9A%A1%EF%B8%8F%20COMMAND%20PALETTE-CTRL%2BP-22c55e?style=for-the-badge" alt="Use ⚡️ Command Palette with Ctrl+P">
+</p>
+
 Need to fix contrast because your terminal theme is fighting the TUI? Press **`G`** at any time to cycle **Auto → Dark → Light**. The switch recolors the full interface live: table, Settings, Help, Smart Recommend, Feedback, and Changelog.
 
-**③ Pick a model and launch your tool:**
+**② Pick a model and launch your tool:**
 
 ```
 ↑↓ navigate   →   Enter to launch
@@ -176,10 +186,9 @@ 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) |
+| `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) |
 | `Q` | Smart Recommend overlay |
 | `N` | Changelog |
 | `W` | Cycle ping cadence |
@@ -201,7 +210,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
+- **⚡️ 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.21",
+  "version": "0.3.22",
   "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

@@ -409,6 +409,7 @@ export async function runApp(cliArgs, config) {
     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.
+    commandPaletteExpandedIds: new Set(['filters']), // 📖 Set of expanded category/subcategory IDs (filters expanded by default for quick access).
     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
@@ -457,6 +458,8 @@ export async function runApp(cliArgs, config) {
     changelogPhase: 'index',      // 📖 'index' (all versions) | 'details' (specific version)
     changelogCursor: 0,           // 📖 Selected row in index phase
     changelogSelectedVersion: null, // 📖 Which version to show details for
+    // 📖 Custom text filter (Ctrl+P palette → type text → Enter). Ephemeral — not saved to config.
+    customTextFilter: null,       // 📖 Active free-text filter string (null = off). Matches model name, ctx, provider key/name.
   }
 
   // 📖 Re-clamp viewport on terminal resize
@@ -690,8 +693,22 @@ export async function runApp(cliArgs, config) {
       const allowedTiers = (activeTier && TIER_LETTER_MAP[activeTier]) ? TIER_LETTER_MAP[activeTier] : [activeTier]
       const tierHide = activeTier !== null && !allowedTiers.includes(r.tier)
       const originHide = activeOrigin !== null && r.providerKey !== activeOrigin
-      r.hidden = tierHide || originHide
-
+      if (tierHide || originHide) {
+        r.hidden = true
+        return
+      }
+      // 📖 Custom text filter — case-insensitive includes match against model name, ctx, provider key, and provider display name.
+      if (state.customTextFilter) {
+        const q = state.customTextFilter.toLowerCase()
+        const providerName = (sources[r.providerKey]?.name || '').toLowerCase()
+        const match = (r.label || '').toLowerCase().includes(q)
+          || (r.ctx || '').toLowerCase().includes(q)
+          || (r.providerKey || '').toLowerCase().includes(q)
+          || providerName.includes(q)
+        r.hidden = !match
+        return
+      }
+      r.hidden = false
     })
     return state.results
   }

package/src/command-palette.js

@@ -1,64 +1,200 @@
 /**
  * @file command-palette.js
  * @description Command palette registry and fuzzy search helpers for the main TUI.
+ *          Now supports hierarchical categories with expandable/collapsible groups.
  *
  * @functions
- *   → `buildCommandPaletteEntries` — builds the current command list with dynamic provider/tier context
+ *   → `buildCommandPaletteTree` — builds the hierarchical command tree with categories and subcategories
+ *   → `flattenCommandTree` — converts tree to flat list for filtering (respects expansion state)
  *   → `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 }
+ * @exports { buildCommandPaletteTree, flattenCommandTree, 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'] },
+// 📖 Base command tree template (will be enhanced with dynamic model list)
+const BASE_COMMAND_TREE = [
+  {
+    id: 'filters',
+    label: 'Filters',
+    icon: '🔍',
+    children: [
+      {
+        id: 'filter-tier',
+        label: 'Filter by tier',
+        icon: '📊',
+        children: [
+          { id: 'filter-tier-all', label: 'All tiers', tier: null, shortcut: 'T', description: 'Show all models', keywords: ['filter', 'tier', 'all'] },
+          { id: 'filter-tier-splus', label: 'S+ tier', tier: 'S+', description: 'Best coding models', keywords: ['filter', 'tier', 's+'] },
+          { id: 'filter-tier-s', label: 'S tier', tier: 'S', description: 'Excellent models', keywords: ['filter', 'tier', 's'] },
+          { id: 'filter-tier-aplus', label: 'A+ tier', tier: 'A+', description: 'Very good models', keywords: ['filter', 'tier', 'a+'] },
+          { id: 'filter-tier-a', label: 'A tier', tier: 'A', description: 'Good models', keywords: ['filter', 'tier', 'a'] },
+          { id: 'filter-tier-aminus', label: 'A- tier', tier: 'A-', description: 'Solid models', keywords: ['filter', 'tier', 'a-'] },
+          { id: 'filter-tier-bplus', label: 'B+ tier', tier: 'B+', description: 'Fair models', keywords: ['filter', 'tier', 'b+'] },
+          { id: 'filter-tier-b', label: 'B tier', tier: 'B', description: 'Basic models', keywords: ['filter', 'tier', 'b'] },
+          { id: 'filter-tier-c', label: 'C tier', tier: 'C', description: 'Limited models', keywords: ['filter', 'tier', 'c'] },
+        ]
+      },
+      {
+        id: 'filter-provider',
+        label: 'Filter by provider',
+        icon: '🏢',
+        children: [
+          { id: 'filter-provider-cycle', label: 'Cycle provider', shortcut: 'D', description: 'Switch between providers', keywords: ['filter', 'provider', 'origin'] },
+          { id: 'filter-provider-all', label: 'All providers', providerKey: null, description: 'Show all providers', keywords: ['filter', 'provider', 'all'] },
+          { id: 'filter-provider-nvidia', label: 'NVIDIA NIM', providerKey: 'nvidiaNim', description: 'NVIDIA models', keywords: ['filter', 'provider', 'nvidia', 'nim'] },
+          { id: 'filter-provider-groq', label: 'Groq', providerKey: 'groq', description: 'Groq models', keywords: ['filter', 'provider', 'groq'] },
+          { id: 'filter-provider-cerebras', label: 'Cerebras', providerKey: 'cerebras', description: 'Cerebras models', keywords: ['filter', 'provider', 'cerebras'] },
+          { id: 'filter-provider-sambanova', label: 'SambaNova', providerKey: 'sambanova', description: 'SambaNova models', keywords: ['filter', 'provider', 'sambanova'] },
+          { id: 'filter-provider-openrouter', label: 'OpenRouter', providerKey: 'openrouter', description: 'OpenRouter models', keywords: ['filter', 'provider', 'openrouter'] },
+          { id: 'filter-provider-together', label: 'Together AI', providerKey: 'together', description: 'Together models', keywords: ['filter', 'provider', 'together'] },
+          { id: 'filter-provider-deepinfra', label: 'DeepInfra', providerKey: 'deepinfra', description: 'DeepInfra models', keywords: ['filter', 'provider', 'deepinfra'] },
+          { id: 'filter-provider-fireworks', label: 'Fireworks AI', providerKey: 'fireworks', description: 'Fireworks models', keywords: ['filter', 'provider', 'fireworks'] },
+          { id: 'filter-provider-hyperbolic', label: 'Hyperbolic', providerKey: 'hyperbolic', description: 'Hyperbolic models', keywords: ['filter', 'provider', 'hyperbolic'] },
+          { id: 'filter-provider-google', label: 'Google AI', providerKey: 'google', description: 'Google models', keywords: ['filter', 'provider', 'google'] },
+          { id: 'filter-provider-huggingface', label: 'Hugging Face', providerKey: 'huggingface', description: 'Hugging Face models', keywords: ['filter', 'provider', 'huggingface'] },
+        ]
+      },
+      {
+        id: 'filter-model',
+        label: 'Filter by model',
+        icon: '🤖',
+        children: []
+      },
+      {
+        id: 'filter-other',
+        label: 'Other filters',
+        icon: '⚙️',
+        children: [
+          { id: 'filter-configured-toggle', label: 'Toggle configured-only', shortcut: 'E', description: 'Show only configured providers', keywords: ['filter', 'configured', 'keys'] },
+        ]
+      },
+    ]
+  },
+  {
+    id: 'sort',
+    label: 'Sort',
+    icon: '📶',
+    children: [
+      { id: 'sort-rank', label: 'Sort by rank', shortcut: 'R', description: 'Rank by SWE score', keywords: ['sort', 'rank'] },
+      { id: 'sort-tier', label: 'Sort by tier', description: 'Group by quality tier', keywords: ['sort', 'tier'] },
+      { id: 'sort-provider', label: 'Sort by provider', shortcut: 'O', description: 'Group by provider', keywords: ['sort', 'origin', 'provider'] },
+      { id: 'sort-model', label: 'Sort by model', shortcut: 'M', description: 'Alphabetical order', keywords: ['sort', 'model', 'name'] },
+      { id: 'sort-latest-ping', label: 'Sort by latest ping', shortcut: 'L', description: 'Recent response time', keywords: ['sort', 'latest', 'ping'] },
+      { id: 'sort-avg-ping', label: 'Sort by avg ping', shortcut: 'A', description: 'Average response time', keywords: ['sort', 'avg', 'average', 'ping'] },
+      { id: 'sort-swe', label: 'Sort by SWE score', shortcut: 'S', description: 'Coding ability score', keywords: ['sort', 'swe', 'score'] },
+      { id: 'sort-ctx', label: 'Sort by context', shortcut: 'C', description: 'Context window size', keywords: ['sort', 'context', 'ctx'] },
+      { id: 'sort-health', label: 'Sort by health', shortcut: 'H', description: 'Current model status', keywords: ['sort', 'health', 'condition'] },
+      { id: 'sort-verdict', label: 'Sort by verdict', shortcut: 'V', description: 'Overall assessment', keywords: ['sort', 'verdict'] },
+      { id: 'sort-stability', label: 'Sort by stability', shortcut: 'B', description: 'Reliability score', keywords: ['sort', 'stability'] },
+      { id: 'sort-uptime', label: 'Sort by uptime', shortcut: 'U', description: 'Success rate', keywords: ['sort', 'uptime'] },
+    ]
+  },
+  // 📖 Pages - directly at root level, not in submenu
+  { id: 'open-settings', label: 'Settings', shortcut: 'P', icon: '⚙️', type: 'page', description: 'API keys and preferences', keywords: ['settings', 'config', 'api key'] },
+  { id: 'open-help', label: 'Help', shortcut: 'K', icon: '❓', type: 'page', description: 'Show all shortcuts', keywords: ['help', 'shortcuts', 'hotkeys'] },
+  { id: 'open-changelog', label: 'Changelog', shortcut: 'N', icon: '📋', type: 'page', description: 'Version history', keywords: ['changelog', 'release'] },
+  { id: 'open-feedback', label: 'Feedback', shortcut: 'I', icon: '📝', type: 'page', description: 'Report bugs or requests', keywords: ['feedback', 'bug', 'request'] },
+  { id: 'open-recommend', label: 'Smart recommend', shortcut: 'Q', icon: '🎯', type: 'page', description: 'Find best model for task', keywords: ['recommend', 'best model'] },
+  { id: 'open-install-endpoints', label: 'Install endpoints', icon: '🔌', type: 'page', description: 'Install provider catalogs', keywords: ['install', 'endpoints', 'providers'] },
+  // 📖 Actions - directly at root level, not in submenu
+  { id: 'action-cycle-theme', label: 'Cycle theme', shortcut: 'G', icon: '🌗', type: 'action', description: 'Switch dark/light/auto', keywords: ['theme', 'dark', 'light', 'auto'] },
+  { id: 'action-cycle-tool-mode', label: 'Target Tool', shortcut: 'Z', icon: '🔄', type: 'action', description: 'Change target AI Coding CLI Tool.', keywords: ['tool', 'mode', 'launcher', 'target'] },
+  { id: 'action-cycle-ping-mode', label: 'Cycle ping mode', shortcut: 'W', icon: '⚡', type: 'action', description: 'Adjust ping speed', keywords: ['ping', 'cadence', 'speed', 'slow'] },
+  { id: 'action-toggle-favorite', label: 'Toggle favorite', shortcut: 'F', icon: '⭐', type: 'action', description: 'Pin to favorites', keywords: ['favorite', 'star'] },
+  { id: 'action-reset-view', label: 'Reset view', shortcut: 'Shift+R', icon: '🔄', type: 'action', description: 'Reset filters and sort', keywords: ['reset', 'view', 'sort', 'filters'] },
 ]
 
+/**
+ * 📖 Build the command palette tree with dynamic model filters.
+ * @param {Array} visibleModels - Optional list of visible models to create model filter entries
+ * @returns {Array} The command tree with model filters added
+ */
+export function buildCommandPaletteTree(visibleModels = []) {
+  // 📖 Clone the base tree
+  const tree = JSON.parse(JSON.stringify(BASE_COMMAND_TREE))
+  
+  // 📖 Find the filter-model category and add dynamic model entries
+  const filterModelCategory = tree.find(cat => cat.id === 'filters')
+    ?.children.find(sub => sub.id === 'filter-model')
+  
+  if (filterModelCategory && Array.isArray(visibleModels) && visibleModels.length > 0) {
+    // 📖 Add top 20 most-used or most relevant models
+    const topModels = visibleModels
+      .filter(m => !m.hidden && m.status !== 'noauth')
+      .slice(0, 20)
+    
+    for (const model of topModels) {
+      filterModelCategory.children.push({
+        id: `filter-model-${model.providerKey}-${model.modelId}`,
+        label: model.label,
+        modelId: model.modelId,
+        providerKey: model.providerKey,
+        keywords: ['filter', 'model', model.label.toLowerCase(), model.modelId.toLowerCase()],
+      })
+    }
+  }
+  
+  return tree
+}
+
+/**
+ * 📖 Flatten the command tree into a list, respecting which nodes are expanded.
+ * @param {Array} tree - The command tree
+ * @param {Set} expandedIds - Set of IDs that are expanded
+ * @returns {Array} Flat list with type markers ('category' | 'subcategory' | 'command' | 'page' | 'action')
+ */
+export function flattenCommandTree(tree, expandedIds = new Set()) {
+  const result = []
+  
+  function traverse(nodes, depth = 0) {
+    for (const node of nodes) {
+      // 📖 Check if this is a direct page/action (not in a submenu)
+      if (node.type === 'page' || node.type === 'action') {
+        result.push({
+          ...node,
+          type: node.type,
+          depth: 0,
+          hasChildren: false,
+          isExpanded: false,
+        })
+        continue
+      }
+      
+      const isExpanded = expandedIds.has(node.id)
+      const hasChildren = Array.isArray(node.children) && node.children.length > 0
+      
+      if (hasChildren) {
+        result.push({
+          ...node,
+          type: depth === 0 ? 'category' : 'subcategory',
+          depth,
+          hasChildren,
+          isExpanded,
+        })
+        
+        if (isExpanded) {
+          traverse(node.children, depth + 1)
+        }
+      } else {
+        result.push({
+          ...node,
+          type: 'command',
+          depth,
+          hasChildren: false,
+          isExpanded: false,
+        })
+      }
+    }
+  }
+  
+  traverse(tree)
+  return result
+}
+
 const ID_TO_TIER = {
   'filter-tier-all': null,
   'filter-tier-splus': 'S+',
@@ -71,11 +207,31 @@ const ID_TO_TIER = {
   '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,
-  }))
+/**
+ * 📖 Legacy function for backward compatibility - builds flat list from tree.
+ * 📖 Expands all categories so every command is searchable by fuzzyMatchCommand.
+ * @param {Array} visibleModels - Optional list of visible models for model filter entries
+ */
+export function buildCommandPaletteEntries(visibleModels = []) {
+  const tree = buildCommandPaletteTree(visibleModels)
+  // 📖 Collect every node id that has children so flattenCommandTree traverses into them.
+  const allIds = new Set()
+  function collectIds(nodes) {
+    for (const n of nodes) {
+      allIds.add(n.id)
+      if (Array.isArray(n.children)) collectIds(n.children)
+    }
+  }
+  collectIds(tree)
+  const flat = flattenCommandTree(tree, allIds)
+  return flat.map((entry) => {
+    // 📖 Copy tier and providerKey properties to tierValue for backward compatibility
+    const result = { ...entry }
+    if (entry.tier !== undefined) {
+      result.tierValue = entry.tier
+    }
+    return result
+  })
 }
 
 /**
@@ -126,15 +282,20 @@ export function fuzzyMatchCommand(query, text) {
 
 /**
  * 📖 Filter and rank command palette entries by fuzzy score.
- * @param {Array<{ id: string, label: string, category: string, keywords?: string[] }>} entries
+ * Now handles hierarchical structure with expandable categories.
+ * @param {Array} flatEntries - Flattened command tree entries
  * @param {string} query
- * @returns {Array<{ id: string, label: string, category: string, shortcut?: string|null, keywords?: string[], score: number, matchPositions: number[] }>}
+ * @returns {Array} Sorted and filtered entries with match scores
  */
-export function filterCommandPaletteEntries(entries, query) {
+export function filterCommandPaletteEntries(flatEntries, query) {
   const normalizedQuery = (query || '').trim()
+  
+  if (!normalizedQuery) {
+    return flatEntries
+  }
 
   const ranked = []
-  for (const entry of entries) {
+  for (const entry of flatEntries) {
     const labelMatch = fuzzyMatchCommand(normalizedQuery, entry.label)
     let bestScore = labelMatch.score
     let matchPositions = labelMatch.positions
@@ -145,7 +306,6 @@ export function filterCommandPaletteEntries(entries, query) {
         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
@@ -158,11 +318,24 @@ export function filterCommandPaletteEntries(entries, query) {
     ranked.push({ ...entry, score: bestScore, matchPositions })
   }
 
+  // Auto-expand categories that contain matches
+  const result = []
+  const idsToExpand = new Set()
+  
+  // First pass: mark all categories containing matched items
+  for (const entry of ranked) {
+    if (entry.type === 'command' && entry.matchPositions) {
+      // Find parent categories
+      let current = result.find(r => r.id === entry.id)
+      if (current) {
+        idsToExpand.add(entry.parentId)
+      }
+    }
+  }
+
   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
+    if (a.depth !== b.depth) return a.depth - b.depth
     return a.label.localeCompare(b.label)
   })
 

package/src/key-handler.js

@@ -31,7 +31,7 @@ import { loadChangelog } from './changelog-loader.js'
 import { loadConfig, replaceConfigContents } from './config.js'
 import { cleanupLegacyProxyArtifacts } from './legacy-proxy-cleanup.js'
 import { cycleThemeSetting, detectActiveTheme } from './theme.js'
-import { buildCommandPaletteEntries, filterCommandPaletteEntries } from './command-palette.js'
+import { buildCommandPaletteTree, flattenCommandTree, filterCommandPaletteEntries } from './command-palette.js'
 import { WIDTH_WARNING_MIN_COLS } from './constants.js'
 
 // 📖 Some providers need an explicit probe model because the first catalog entry
@@ -609,6 +609,7 @@ export function createKeyHandler(ctx) {
   function resetViewSettings() {
     state.tierFilterMode = 0
     state.originFilterMode = 0
+    state.customTextFilter = null  // 📖 Clear ephemeral text filter on view reset
     state.sortColumn = 'avg'
     state.sortDirection = 'asc'
     if (!state.config.settings || typeof state.config.settings !== 'object') state.config.settings = {}
@@ -653,8 +654,33 @@ export function createKeyHandler(ctx) {
   }
 
   function refreshCommandPaletteResults() {
-    const commands = buildCommandPaletteEntries()
-    state.commandPaletteResults = filterCommandPaletteEntries(commands, state.commandPaletteQuery)
+    const tree = buildCommandPaletteTree(state.results || [])
+    const flat = flattenCommandTree(tree, state.commandPaletteExpandedIds)
+    state.commandPaletteResults = filterCommandPaletteEntries(flat, state.commandPaletteQuery)
+
+    const query = (state.commandPaletteQuery || '').trim()
+    if (query.length > 0) {
+      state.commandPaletteResults.unshift({
+        id: 'filter-custom-text-apply',
+        label: `🔍 Apply text filter: ${query}`,
+        type: 'command',
+        depth: 0,
+        hasChildren: false,
+        isExpanded: false,
+        filterQuery: query,
+      })
+    } else if (state.customTextFilter) {
+      state.commandPaletteResults.unshift({
+        id: 'filter-custom-text-remove',
+        label: `❌ Remove custom filter: ${state.customTextFilter}`,
+        type: 'command',
+        depth: 0,
+        hasChildren: false,
+        isExpanded: false,
+        filterQuery: null,
+      })
+    }
+
     if (state.commandPaletteCursor >= state.commandPaletteResults.length) {
       state.commandPaletteCursor = Math.max(0, state.commandPaletteResults.length - 1)
     }
@@ -682,7 +708,43 @@ export function createKeyHandler(ctx) {
     if (!entry?.id) return
 
     if (entry.id.startsWith('filter-tier-')) {
-      setTierFilterFromCommand(entry.tierValue ?? null)
+      setTierFilterFromCommand(entry.tier ?? null)
+      return
+    }
+
+    if (entry.id.startsWith('filter-provider-') && entry.id !== 'filter-provider-cycle') {
+      if (entry.providerKey === null || entry.providerKey === undefined) {
+        state.originFilterMode = 0 // All
+      } else {
+        state.originFilterMode = ORIGIN_CYCLE.findIndex(key => key === entry.providerKey) + 1
+        if (state.originFilterMode <= 0) state.originFilterMode = 0
+      }
+      applyTierFilter()
+      refreshVisibleSorted({ resetCursor: true })
+      persistUiSettings()
+      return
+    }
+
+    if (entry.id.startsWith('filter-model-')) {
+      if (entry.modelId && entry.providerKey) {
+        state.customTextFilter = `${entry.providerKey}/${entry.modelId}`
+        applyTierFilter()
+        refreshVisibleSorted({ resetCursor: true })
+      }
+      return
+    }
+
+    // 📖 Custom text filter — apply or remove the free-text filter from the command palette.
+    if (entry.id === 'filter-custom-text-apply') {
+      state.customTextFilter = entry.filterQuery || null
+      applyTierFilter()
+      refreshVisibleSorted({ resetCursor: true })
+      return
+    }
+    if (entry.id === 'filter-custom-text-remove') {
+      state.customTextFilter = null
+      applyTierFilter()
+      refreshVisibleSorted({ resetCursor: true })
       return
     }
 
@@ -758,6 +820,7 @@ export function createKeyHandler(ctx) {
       if (key.ctrl && key.name === 'c') { exit(0); return }
 
       const pageStep = Math.max(1, (state.terminalRows || 1) - 10)
+      const selected = state.commandPaletteResults[state.commandPaletteCursor]
 
       if (key.name === 'escape') {
         closeCommandPalette()
@@ -775,6 +838,23 @@ export function createKeyHandler(ctx) {
         state.commandPaletteCursor = state.commandPaletteCursor < count - 1 ? state.commandPaletteCursor + 1 : 0
         return
       }
+      if (key.name === 'left') {
+        if (selected?.hasChildren && selected.isExpanded) {
+          state.commandPaletteExpandedIds.delete(selected.id)
+          refreshCommandPaletteResults()
+        }
+        return
+      }
+      if (key.name === 'right') {
+        if (selected?.hasChildren && !selected.isExpanded) {
+          state.commandPaletteExpandedIds.add(selected.id)
+          refreshCommandPaletteResults()
+        } else if (selected?.type === 'command') {
+          closeCommandPalette()
+          executeCommandPaletteEntry(selected)
+        }
+        return
+      }
       if (key.name === 'pageup') {
         state.commandPaletteCursor = Math.max(0, state.commandPaletteCursor - pageStep)
         return
@@ -800,9 +880,17 @@ export function createKeyHandler(ctx) {
         return
       }
       if (key.name === 'return') {
-        const selectedCommand = state.commandPaletteResults[state.commandPaletteCursor]
-        closeCommandPalette()
-        executeCommandPaletteEntry(selectedCommand)
+        if (selected?.hasChildren) {
+          if (selected.isExpanded) {
+            state.commandPaletteExpandedIds.delete(selected.id)
+          } else {
+            state.commandPaletteExpandedIds.add(selected.id)
+          }
+          refreshCommandPaletteResults()
+        } else {
+          closeCommandPalette()
+          executeCommandPaletteEntry(selected)
+        }
         return
       }
       if (str && str.length === 1 && !key.ctrl && !key.meta) {
@@ -1619,11 +1707,7 @@ export function createKeyHandler(ctx) {
       return
     }
 
-    // 📖 Y key: open Install Endpoints flow for configured providers.
-    if (key.name === 'y') {
-      openInstallEndpointsOverlay()
-      return
-    }
+    // 📖 Y key freed — Install Endpoints is now accessible only via Settings (P) or Command Palette (Ctrl+P).
 
     // 📖 Profile system removed - API keys now persist permanently across all sessions
 
@@ -1636,7 +1720,7 @@ export function createKeyHandler(ctx) {
     }
 
     // 📖 Sorting keys: R=rank, O=origin, M=model, L=latest ping, A=avg ping, S=SWE-bench, C=context, H=health, V=verdict, B=stability, U=uptime, G=usage
-    // 📖 T is reserved for tier filter cycling. Y now opens the install-endpoints flow.
+    // 📖 T is reserved for tier filter cycling. Y is now free (Install Endpoints moved to Settings/Palette).
     // 📖 D is now reserved for provider filter cycling
     // 📖 Shift+R is reserved for reset view settings
     const sortKeys = {

package/src/overlays.js

@@ -528,18 +528,16 @@ export function createOverlayRenderers(state, deps) {
 
   // ─── Command palette renderer ──────────────────────────────────────────────
   // 📖 renderCommandPalette draws a centered floating modal over the live table.
-  // 📖 It returns cursor-positioned ANSI rows instead of replacing the full screen,
-  // 📖 so ping updates continue to animate in the background behind the palette.
+  // 📖 Supports hierarchical categories with expand/collapse and rich colors.
   function renderCommandPalette() {
     const terminalRows = state.terminalRows || 24
     const terminalCols = state.terminalCols || 80
-    const panelWidth = Math.max(44, Math.min(96, terminalCols - 8))
-    const panelInnerWidth = Math.max(28, panelWidth - 4)
+    const panelWidth = Math.max(52, Math.min(100, terminalCols - 8))
+    const panelInnerWidth = Math.max(32, panelWidth - 4)
     const panelPad = 2
     const panelOuterWidth = panelWidth + (panelPad * 2)
-    const footerRowCount = 2
-    const headerRowCount = 3
-    const bodyRows = Math.max(6, Math.min(16, terminalRows - 12))
+    const headerRowCount = 4
+    const bodyRows = Math.max(8, Math.min(18, terminalRows - 12))
 
     const truncatePlain = (text, width) => {
       if (width <= 1) return ''
@@ -559,30 +557,70 @@ export function createOverlayRenderers(state, deps) {
     }
 
     const allResults = Array.isArray(state.commandPaletteResults) ? state.commandPaletteResults.slice(0, 80) : []
-    const groupedLines = []
+    const panelLines = []
     const cursorLineByRow = {}
-    let category = null
 
     if (allResults.length === 0) {
-      groupedLines.push(themeColors.dim('  No command found. Try a broader query.'))
+      panelLines.push(themeColors.dim('  No commands found. Try a different search.'))
     } else {
       for (let idx = 0; idx < allResults.length; idx++) {
         const entry = allResults[idx]
-        if (entry.category !== category) {
-          category = entry.category
-          groupedLines.push(themeColors.textBold(` ${category}`))
+        const isCursor = idx === state.commandPaletteCursor
+        
+        const indent = '  '.repeat(entry.depth || 0)
+        const expandIndicator = entry.hasChildren
+          ? (entry.isExpanded ? themeColors.infoBold('▼') : themeColors.dim('▶'))
+          : themeColors.dim('•')
+        
+        // 📖 Only use icon from entry, label should NOT include emoji
+        const iconPrefix = entry.icon ? `${entry.icon} ` : ''
+        const plainLabel = truncatePlain(entry.label, panelInnerWidth - indent.length - iconPrefix.length - 4)
+        const label = entry.matchPositions ? highlightMatch(plainLabel, entry.matchPositions) : plainLabel
+        
+        let rowLine
+        if (entry.type === 'category') {
+          rowLine = `${indent}${expandIndicator} ${iconPrefix}${themeColors.headerBold(label)}`
+        } else if (entry.type === 'subcategory') {
+          rowLine = `${indent}${expandIndicator} ${iconPrefix}${themeColors.textBold(label)}`
+        } else if (entry.type === 'page') {
+          // 📖 Pages are at root level with icon + label + shortcut + description
+          const shortcut = entry.shortcut ? themeColors.dim(` (${entry.shortcut})`) : ''
+          const description = entry.description ? themeColors.dim(` — ${entry.description}`) : ''
+          rowLine = `${expandIndicator} ${iconPrefix}${themeColors.textBold(label)}${shortcut}${description}`
+        } else if (entry.type === 'action') {
+          // 📖 Actions are at root level with icon + label + shortcut + description
+          const shortcut = entry.shortcut ? themeColors.dim(` (${entry.shortcut})`) : ''
+          const description = entry.description ? themeColors.dim(` — ${entry.description}`) : ''
+          rowLine = `${expandIndicator} ${iconPrefix}${themeColors.textBold(label)}${shortcut}${description}`
+        } else {
+          // 📖 Regular commands in submenus
+          const shortcut = entry.shortcut ? themeColors.dim(` (${entry.shortcut})`) : ''
+          const description = entry.description ? themeColors.dim(` — ${entry.description}`) : ''
+          // 📖 Color tiers and providers
+          let coloredLabel = label
+          let prefixWithIcon = iconPrefix
+          
+          if (entry.providerKey && !entry.icon) {
+            // 📖 Model filter: add provider icon
+            const providerIcon = '🏢'
+            prefixWithIcon = `${providerIcon} `
+            coloredLabel = themeColors.provider(entry.providerKey, label, { bold: false })
+          } else if (entry.tier) {
+            coloredLabel = themeColors.tier(entry.tier, label)
+          } else if (entry.providerKey) {
+            coloredLabel = themeColors.provider(entry.providerKey, label, { bold: false })
+          }
+          
+          rowLine = `${indent}  ${expandIndicator} ${prefixWithIcon}${coloredLabel}${shortcut}${description}`
         }
 
-        const isCursor = idx === state.commandPaletteCursor
-        const pointer = isCursor ? themeColors.accentBold('  ❯ ') : themeColors.dim('    ')
-        const shortcutText = entry.shortcut ? themeColors.dim(entry.shortcut) : ''
-        const shortcutWidth = entry.shortcut ? Math.min(16, displayWidth(entry.shortcut)) : 0
-        const labelMax = Math.max(12, panelInnerWidth - 8 - shortcutWidth)
-        const plainLabel = truncatePlain(entry.label, labelMax)
-        const label = highlightMatch(plainLabel, entry.matchPositions)
-        const row = `${pointer}${padEndDisplay(label, labelMax)}${entry.shortcut ? ` ${shortcutText}` : ''}`
-        cursorLineByRow[idx] = groupedLines.length
-        groupedLines.push(isCursor ? themeColors.bgCursor(row) : row)
+        cursorLineByRow[idx] = panelLines.length
+        
+        if (isCursor) {
+          panelLines.push(themeColors.bgCursor(rowLine))
+        } else {
+          panelLines.push(rowLine)
+        }
       }
     }
 
@@ -590,44 +628,43 @@ export function createOverlayRenderers(state, deps) {
     state.commandPaletteScrollOffset = keepOverlayTargetVisible(
       state.commandPaletteScrollOffset,
       targetLine,
-      groupedLines.length,
+      panelLines.length,
       bodyRows
     )
-    const { visible, offset } = sliceOverlayLines(groupedLines, state.commandPaletteScrollOffset, bodyRows)
+    const { visible, offset } = sliceOverlayLines(panelLines, state.commandPaletteScrollOffset, bodyRows)
     state.commandPaletteScrollOffset = offset
 
     const query = state.commandPaletteQuery || ''
     const queryWithCursor = query.length > 0
-      ? themeColors.textBold(`${query}▏`)
-      : themeColors.dim('type a command…') + themeColors.accentBold('▏')
+      ? `${query}${themeColors.accentBold('▏')}`
+      : themeColors.accentBold('▏') + themeColors.dim(' Search commands…')
 
-    const panelLines = []
-    const title = themeColors.textBold('Command Palette')
+    const headerLines = []
+    const title = themeColors.headerBold('⚡️ Command Palette')
     const titleLeft = ` ${title}`
-    const titleRight = themeColors.dim('Esc close')
-    const titleWidth = Math.max(1, panelInnerWidth - 1 - displayWidth('Esc close'))
-    panelLines.push(`${padEndDisplay(titleLeft, titleWidth)} ${titleRight}`)
-    panelLines.push(` ${padEndDisplay(`> ${queryWithCursor}`, panelInnerWidth)}`)
-    panelLines.push(themeColors.dim(` ${'-'.repeat(Math.max(1, panelInnerWidth))}`))
-
-    for (const line of visible) {
-      panelLines.push(` ${padEndDisplay(line, panelInnerWidth)}`)
-    }
+    const titleRight = themeColors.dim('Esc')
+    const titleWidth = Math.max(1, panelInnerWidth - 1 - displayWidth('Esc'))
+    headerLines.push(`${padEndDisplay(titleLeft, titleWidth)} ${titleRight}`)
+    headerLines.push(` ${padEndDisplay(`> ${queryWithCursor}`, panelInnerWidth)}`)
+    headerLines.push(themeColors.dim(` ${'─'.repeat(Math.max(1, panelInnerWidth))}`))
+
+    const footerLines = [
+      themeColors.dim(` ${'─'.repeat(Math.max(1, panelInnerWidth))}`),
+      ` ${padEndDisplay(themeColors.dim('↵ Select • ← → Expand'), panelInnerWidth)}`,
+      ` ${padEndDisplay(themeColors.dim('↑↓ Navigate • Type search'), panelInnerWidth)}`,
+    ]
 
-    // 📖 Keep panel body stable by filling with blank rows when result list is short.
-    while (panelLines.length < bodyRows + headerRowCount) {
-      panelLines.push(` ${' '.repeat(panelInnerWidth)}`)
+    const allPanelLines = [...headerLines, ...visible, ...footerLines]
+    
+    while (allPanelLines.length < bodyRows + headerRowCount + 3) {
+      allPanelLines.splice(headerLines.length + visible.length, 0, ` ${' '.repeat(panelInnerWidth)}`)
     }
 
-    panelLines.push(themeColors.dim(` ${'-'.repeat(Math.max(1, panelInnerWidth))}`))
-    panelLines.push(` ${padEndDisplay(themeColors.dim('↑↓ navigate • Enter run • Type to search'), panelInnerWidth)}`)
-    panelLines.push(` ${padEndDisplay(themeColors.dim('PgUp/PgDn • Home/End'), panelInnerWidth)}`)
-
     const blankPaddedLine = ' '.repeat(panelOuterWidth)
     const paddedPanelLines = [
       blankPaddedLine,
       blankPaddedLine,
-      ...panelLines.map((line) => `${' '.repeat(panelPad)}${padEndDisplay(line, panelWidth)}${' '.repeat(panelPad)}`),
+      ...allPanelLines.map((line) => `${' '.repeat(panelPad)}${padEndDisplay(line, panelWidth)}${' '.repeat(panelPad)}`),
       blankPaddedLine,
       blankPaddedLine,
     ]
@@ -641,8 +678,6 @@ export function createOverlayRenderers(state, deps) {
       return themeColors.overlayBgCommandPalette(padded)
     })
 
-    // 📖 Absolute cursor positioning overlays the palette on top of the existing table.
-    // 📖 The next frame starts with ALT_HOME, so this remains stable without manual cleanup.
     return tintedLines
       .map((line, idx) => `\x1b[${top + idx};${left}H${line}`)
       .join('')
@@ -716,11 +751,10 @@ export function createOverlayRenderers(state, deps) {
     lines.push('')
     lines.push(`  ${heading('Controls')}`)
     lines.push(`  ${key('W')}  Toggle ping mode  ${hint('(speed 2s → normal 10s → slow 30s → forced 4s)')}`)
-    lines.push(`  ${key('Ctrl+P')}  Open command palette  ${hint('(search and run actions quickly)')}`)
+    lines.push(`  ${key('Ctrl+P')}  Open ⚡️ command palette  ${hint('(search and run actions quickly)')}`)
     lines.push(`  ${key('E')}  Toggle configured models only  ${hint('(enabled by default)')}`)
     lines.push(`  ${key('Z')}  Cycle tool mode  ${hint('(OpenCode → Desktop → OpenClaw → Crush → Goose → Pi → Aider → Qwen → OpenHands → Amp)')}`)
     lines.push(`  ${key('F')}  Toggle favorite on selected row  ${hint('(⭐ pinned at top, persisted)')}`)
-    lines.push(`  ${key('Y')}  Install endpoints  ${hint('(provider catalog → compatible tools, direct provider only)')}`)
     lines.push(`  ${key('Q')}  Smart Recommend  ${hint('(🎯 find the best model for your task — questionnaire + live analysis)')}`)
     lines.push(`  ${key('G')}  Cycle theme  ${hint('(auto → dark → light)')}`)
     lines.push(`  ${themeColors.errorBold('I')}  Feedback, bugs & requests  ${hint('(📝 send anonymous feedback, bug reports, or feature requests)')}`)

package/src/product-flags.js

@@ -1,14 +1,9 @@
 /**
  * @file src/product-flags.js
- * @description Product-level copy for temporarily unavailable surfaces.
+ * @description Product-level flags and feature gates.
  *
  * @details
- *   📖 The proxy bridge is being rebuilt from scratch. The main TUI still
- *   📖 shows a clear status line so users know the missing integration is
- *   📖 intentional instead of silently broken.
- *
- * @exports PROXY_DISABLED_NOTICE
+ *   📖 Previously held PROXY_DISABLED_NOTICE for the proxy bridge rebuild.
+ *   📖 That notice was removed in 0.3.22 after the proxy surface was fully
+ *   📖 retired. File kept as a home for future product-level flags.
  */
-
-// 📖 Public note rendered in the main TUI footer and reused in CLI/runtime guards.
-export const PROXY_DISABLED_NOTICE = 'ℹ️ Proxy is temporarily disabled while we rebuild it into a much more stable bridge for external tools.'

package/src/render-table.js

@@ -50,7 +50,6 @@ import { getAvg, getVerdict, getUptime, getStabilityScore, getVersionStatusInfo
 import { usagePlaceholderForProvider } from './ping.js'
 import { calculateViewport, sortResultsWithPinnedFavorites, padEndDisplay, displayWidth } from './render-helpers.js'
 import { getToolMeta } from './tool-metadata.js'
-import { PROXY_DISABLED_NOTICE } from './product-flags.js'
 import { getColumnSpacing } from './ui-config.js'
 
 const require = createRequire(import.meta.url)
@@ -149,11 +148,11 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
   const SEP_W = 3  // ' │ ' display width
   const ROW_MARGIN = 2  // left margin '  '
   const W_RANK = 6
-  const W_TIER = 6
-  const W_CTX = 6
+  const W_TIER = 5
+  const W_CTX = 4
   const W_SOURCE = 14
   const W_MODEL = 26
-  const W_SWE = 6
+  const W_SWE = 5
   const W_STATUS = 18
   const W_VERDICT = 14
   const W_UPTIME = 6
@@ -164,8 +163,9 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
   // 📖 Responsive column visibility: progressively hide least-useful columns
   // 📖 and shorten header labels when terminal width is insufficient.
   // 📖 Hiding order (least useful first): Rank → Up% → Tier → Stability
-  // 📖 Compact mode shrinks: Latest Ping→Lat. P (10), Avg Ping→Avg. P (8),
-  // 📖 Stability→StaB. (8), Provider→4chars+… (10), Health→6chars+… (13)
+  // 📖 Compact mode shrinks: Latest Ping→Lat. P (9), Avg Ping→Avg. P (8),
+  // 📖 Stability→StaB. (8), Provider→4chars+… (7), Health→6chars+… (13)
+  // 📖 Breakpoints: full=169 | compact=146 | -Rank=137 | -Up%=128 | -Tier=120 | -Stab=109
   let wPing = 14
   let wAvg = 11
   let wStab = 11
@@ -192,10 +192,10 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
     // 📖 Step 1: Compact mode — shorten labels and reduce column widths
     if (calcWidth() > terminalCols) {
       isCompact = true
-      wPing = 10     // 'Lat. P' instead of 'Latest Ping'
+      wPing = 9      // 'Lat. P' instead of 'Latest Ping'
       wAvg = 8       // 'Avg. P' instead of 'Avg Ping'
       wStab = 8      // 'StaB.' instead of 'Stability'
-      wSource = 10   // Provider truncated to 4 chars + '…'
+      wSource = 7    // Provider truncated to 4 chars + '…', 7 cols total
       wStatus = 13   // Health truncated after 6 chars + '…'
     }
     // 📖 Steps 2–5: Progressive column hiding (least useful first)
@@ -620,7 +620,7 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
   const activeHotkey = (keyLabel, text, bg) => themeColors.badge(`${keyLabel}${text}`, bg, getReadableTextRgb(bg))
   // 📖 Line 1: core navigation + filtering shortcuts
   lines.push(
-    hotkey('F', ' Toggle Favorite') +
+    '  ' + hotkey('F', ' Toggle Favorite') +
     themeColors.dim(`  •  `) +
     (tierFilterMode > 0
       ? activeHotkey('T', ` Tier (${activeTierLabel})`, getTierRgb(activeTierLabel))
@@ -636,11 +636,11 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
     themeColors.dim(`  •  `) +
     hotkey('K', ' Help')
   )
-  // 📖 Line 2: install flow, recommend, feedback, and extended hints.
+  // 📖 Line 2: command palette (highlighted as new), recommend, feedback, and extended hints.
+  // 📖 CTRL+P ⚡️ Command Palette uses neon-green-on-dark-green background to highlight the feature.
+  const paletteLabel = chalk.bgRgb(0, 60, 0).rgb(57, 255, 20).bold(' NEW ! CTRL+P ⚡️ Command Palette ')
   lines.push(
-    themeColors.dim(`  `) +
-    hotkey('Ctrl+P', ' Command palette') + themeColors.dim(`  •  `) +
-    hotkey('Y', ' Install endpoints') + themeColors.dim(`  •  `) +
+    '  ' + paletteLabel + themeColors.dim(`  •  `) +
     hotkey('Q', ' Smart Recommend') + themeColors.dim(`  •  `) +
     hotkey('G', ' Theme') + themeColors.dim(`  •  `) +
     hotkey('I', ' Feedback, bugs & requests')
@@ -661,11 +661,7 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
     '💬 ' +
     themeColors.footerDiscord('\x1b]8;;https://discord.gg/ZTNFHvvCkU\x1b\\Discord\x1b]8;;\x1b\\') +
     themeColors.dim(' → ') +
-    themeColors.footerDiscord('https://discord.gg/ZTNFHvvCkU') +
-    themeColors.dim('  •  ') +
-    themeColors.hotkey('N') + themeColors.dim(' Changelog') +
-    themeColors.dim('  •  ') +
-    themeColors.dim('Ctrl+C Exit')
+    themeColors.footerDiscord('https://discord.gg/ZTNFHvvCkU')
   lines.push(footerLine)
 
   if (versionStatus.isOutdated) {
@@ -677,10 +673,12 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
     lines.push(chalk.bgRed.white.bold(paddedBanner))
   }
 
-  // 📖 Stable release notice: keep the bridge rebuild status explicit in the main UI
-  // 📖 so users do not go hunting for hidden controls that are disabled on purpose.
-  const bridgeNotice = chalk.italic.rgb(...getTierRgb('A-'))(`  ${PROXY_DISABLED_NOTICE}`)
-  lines.push(bridgeNotice)
+  // 📖 Final footer line: changelog shortcut + exit hint (replaces the old proxy notice).
+  lines.push(
+    '  ' + themeColors.hotkey('N') + themeColors.dim(' Changelog') +
+    themeColors.dim('  •  ') +
+    themeColors.dim('Ctrl+C Exit')
+  )
 
   // 📖 Append \x1b[K (erase to EOL) to each line so leftover chars from previous
   // 📖 frames are cleared. Then pad with blank cleared lines to fill the terminal,

package/src/theme.js

@@ -278,11 +278,13 @@ function paintBg(bgRgb, text, fgRgb = null, options = {}) {
 export const themeColors = {
   text: (text) => paintRgb(currentPalette().text, text),
   textBold: (text) => paintRgb(currentPalette().textStrong, text, { bold: true }),
+  headerBold: (text) => paintRgb([142, 200, 255], text, { bold: true }),
   dim: (text) => paintRgb(currentPalette().muted, text),
   soft: (text) => paintRgb(currentPalette().soft, text),
   accent: (text) => paintRgb(currentPalette().accent, text),
   accentBold: (text) => paintRgb(currentPalette().accentStrong, text, { bold: true }),
   info: (text) => paintRgb(currentPalette().info, text),
+  infoBold: (text) => paintRgb([100, 180, 255], text, { bold: true }),
   success: (text) => paintRgb(currentPalette().success, text),
   successBold: (text) => paintRgb(currentPalette().successStrong, text, { bold: true }),
   warning: (text) => paintRgb(currentPalette().warning, text),