free-coding-models 0.3.23 → 0.3.24

package/CHANGELOG.md

@@ -1,6 +1,41 @@
 # Changelog
 ---
 
+## [0.3.24] - 2026-03-19
+
+### Added
+- **Unique emoji per tool** — Every CLI tool now has a dedicated emoji shown in the Compatible column, Z-cycle badge, command palette, help overlay, and README (📦 OpenCode, 🦞 OpenClaw, 💘 Crush, 🪿 Goose, π Pi, 🛠 Aider, 🐉 Qwen, 🤲 OpenHands, ⚡ Amp, 🦘 Rovo, ♊ Gemini)
+- **Merged compat column** — OpenCode CLI and Desktop share 📦 in a single slot (11 slots instead of 12 separate initials)
+- **COMPAT_COLUMN_SLOTS** — New export in tool-metadata.js for merged compatible-column rendering
+- **Width warning now always shows** - Terminal width warning displays every time terminal is resized below 80 columns (previously limited to 2 shows per session)
+- **Gemini CLI integration** - New CLI-only tool provider with 3 models (Gemini 3 Pro 🆕, Gemini 2.5 Pro, Gemini 2.5 Flash)
+- **Rovo Dev CLI integration** - New CLI-only tool provider with Claude Sonnet 4 🆕
+- **Tool compatibility alerts** - When trying to launch Rovo/Gemini models with wrong tool, shows alert and offers to switch
+- **Auto-install detection** - Prompt to install CLI tools when binary not found (Rovo/Gemini)
+- **OpenAI-compatible API support for Gemini** - Gemini CLI can use custom providers via environment variables
+- **New CLI flags** - Added `--rovo` and `--gemini` launch options
+- **"🆕" badges** - Mark newly added models in the table (Claude Sonnet 4, Gemini 3 Pro)
+- **OpenCode Zen free models** - 5 new free models (Big Pickle, GPT 5 Nano, MiMo V2 Flash Free, MiniMax M2.5 Free, Nemotron 3 Super Free) exclusive to OpenCode CLI/Desktop via `opencode-zen` provider
+- **"Compatible with" column** - New TUI column showing colored emojis for each tool a model supports; incompatible tools show dim spaces
+- **Tool color system** - Each of the 12 supported tools now has a unique RGB color and emoji used in the Z-cycle badge and compatibility column
+- **Incompatible model highlighting** - When a tool mode is active (via Z), models that can't run with that tool get a dark red background for instant visibility — they stay in their normal sorted position (not pushed to the bottom)
+- **Tool compatibility functions** - `getCompatibleTools()` and `isModelCompatibleWithTool()` in tool-metadata.js for programmatic compatibility checks
+- **Incompatible model fallback overlay** - When pressing Enter on a model that can't run on the active tool (red-highlighted row), an in-TUI overlay appears with two options: (1) switch to a compatible tool, or (2) pick a similar model by SWE score that works with the current tool
+- **findSimilarCompatibleModels()** - New function in tool-metadata.js that finds models with closest SWE scores compatible with the active tool
+- **Updated provider/model counts** - Now 23 providers with 171 models (was 20/160)
+
+### Changed
+- **Z key cycle** - Rovo and Gemini added to tool mode cycle (last in order)
+- **Tool metadata** - Removed `initial` field (replaced by emojis), added `cliOnly` flag for CLI-only tools, `emoji` and `color` properties for all 12 tools
+- **Provider metadata** - Added Rovo, Gemini, and OpenCode Zen provider information
+- **Responsive column hiding** - Compatible column hides first (before Rank) on narrow terminals
+- **Key handler** - Zen models auto-switch to OpenCode CLI on launch; API key warnings skip Zen models
+- **Documentation** - Updated README with CLI-only tools section, Zen models, compatibility matrix
+
+### Fixed
+- **Missing import error** - Fixed `getToolMeta` not defined in key-handler.js
+- **CLI-only tools API key requirement** - Gemini CLI and Rovo Dev CLI no longer require API keys to be configured before launching; these tools manage their own authentication
+
 ## 0.3.23
 
 ### Added

package/README.md

@@ -2,15 +2,15 @@
   <img src="https://img.shields.io/npm/v/free-coding-models?color=76b900&label=npm&logo=npm" alt="npm version">
   <img src="https://img.shields.io/node/v/free-coding-models?color=76b900&logo=node.js" alt="node version">
   <img src="https://img.shields.io/npm/l/free-coding-models?color=76b900" alt="license">
-  <img src="https://img.shields.io/badge/models-160-76b900?logo=nvidia" alt="models count">
-  <img src="https://img.shields.io/badge/providers-20-blue" alt="providers count">
+  <img src="https://img.shields.io/badge/models-174-76b900?logo=nvidia" alt="models count">
+  <img src="https://img.shields.io/badge/providers-23-blue" alt="providers count">
 </p>
 
 <h1 align="center">free-coding-models</h1>
 
 <p align="center">
   <strong>Find the fastest free coding model in seconds</strong><br>
-  <sub>Ping 160 models across 20 AI Free providers in real-time </sub><br><sub> Install Free API endpoints to your favorite AI coding tool: <br>OpenCode, OpenClaw, Crush, Goose, Aider, Qwen Code, OpenHands, Amp or Pi in one keystroke</sub>
+  <sub>Ping 174 models across 23 AI Free providers in real-time </sub><br><sub> Install Free API endpoints to your favorite AI coding tool: <br>📦 OpenCode, 🦞 OpenClaw, 💘 Crush, 🪿 Goose, 🛠 Aider, 🐉 Qwen Code, 🤲 OpenHands, ⚡ Amp, π Pi, 🦘 Rovo or ♊ Gemini in one keystroke</sub>
 </p>
 
 
@@ -47,7 +47,7 @@ create a free account on one of the [providers](#-list-of-free-ai-providers)
 
 ## 💡 Why this tool?
 
-There are **160+ free coding models** scattered across 20 providers. Which one is fastest right now? Which one is actually stable versus just lucky on the last ping?
+There are **174+ free coding models** scattered across 23 providers. Which one is fastest right now? Which one is actually stable versus just lucky on the last ping?
 
 This CLI pings them all in parallel, shows live latency, and calculates a **live Stability Score (0-100)**. Average latency alone is misleading if a model randomly spikes to 6 seconds; the stability score measures true reliability by combining **p95 latency** (30%), **jitter/variance** (30%), **spike rate** (20%), and **uptime** (20%). 
 
@@ -61,7 +61,7 @@ It then writes the model you pick directly into your coding tool's config — so
 
 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).
+**174 coding models** across 23 providers, ranked by [SWE-bench Verified](https://www.swebench.com).
 
 | Provider | Models | Tier range | Free tier | Env var |
 |----------|--------|-----------|-----------|--------|
@@ -85,6 +85,9 @@ Create a free account on one provider below to get started:
 | [Cloudflare Workers AI](https://dash.cloudflare.com) | 6 | S → B | Free: 10k neurons/day, text-gen 300 RPM | `CLOUDFLARE_API_TOKEN` + `CLOUDFLARE_ACCOUNT_ID` |
 | [Perplexity API](https://www.perplexity.ai/settings/api) | 4 | A+ → B | Tiered limits by spend (default ~50 RPM) | `PERPLEXITY_API_KEY` |
 | [Replicate](https://replicate.com/account/api-tokens) | 1 | A- | 6 req/min (no payment) – up to 3,000 RPM with payment | `REPLICATE_API_TOKEN` |
+| [Rovo Dev CLI](https://www.atlassian.com/rovo) | 1 | S+ | 5M tokens/day (beta) | CLI tool 🦘 |
+| [Gemini CLI](https://github.com/google-gemini/gemini-cli) | 3 | S+ → A+ | 1,000 req/day | CLI tool ♊ |
+| [OpenCode Zen](https://opencode.ai/zen) | 8 | S+ → A+ | Free with OpenCode account | Zen models ✨ |
 
 > 💡 One key is enough. Add more at any time with **`P`** inside the TUI.
 
@@ -121,7 +124,7 @@ Need to fix contrast because your terminal theme is fighting the TUI? Press **`G
 ↑↓ navigate   →   Enter to launch
 ```
 
-The model you select is automatically written into your tool's config (OpenCode, OpenClaw, Crush, etc.) and the tool opens immediately. Done.
+The model you select is automatically written into your tool's config (📦 OpenCode, 🦞 OpenClaw, 💘 Crush, etc.) and the tool opens immediately. Done.
 
 If the active CLI tool is missing, FCM now catches it before launch, offers a tiny Yes/No install prompt, installs the tool with its official global command, then resumes the same model launch automatically.
 
@@ -157,19 +160,69 @@ free-coding-models --openclaw --origin groq
 
 | Flag | Launches |
 |------|----------|
-| `--opencode` | OpenCode CLI |
-| `--opencode-desktop` | OpenCode Desktop |
-| `--openclaw` | OpenClaw |
-| `--crush` | Crush |
-| `--goose` | Goose |
-| `--aider` | Aider |
-| `--qwen` | Qwen Code |
-| `--openhands` | OpenHands |
-| `--amp` | Amp |
-| `--pi` | Pi |
+| `--opencode` | 📦 OpenCode CLI |
+| `--opencode-desktop` | 📦 OpenCode Desktop |
+| `--openclaw` | 🦞 OpenClaw |
+| `--crush` | 💘 Crush |
+| `--goose` | 🪿 Goose |
+| `--aider` | 🛠 Aider |
+| `--qwen` | 🐉 Qwen Code |
+| `--openhands` | 🤲 OpenHands |
+| `--amp` | ⚡ Amp |
+| `--pi` | π Pi |
+| `--rovo` | 🦘 Rovo Dev CLI |
+| `--gemini` | ♊ Gemini CLI |
 
 Press **`Z`** in the TUI to cycle between tools without restarting.
 
+### CLI-Only Tools
+
+**🦘 Rovo Dev CLI**
+- Provider: [Atlassian Rovo](https://www.atlassian.com/rovo)
+- Install: [Installation Guide](https://support.atlassian.com/rovo/docs/install-and-run-rovo-dev-cli-on-your-device/)
+- Free tier: 5M tokens/day (beta, requires Atlassian account)
+- Model: Claude Sonnet 4 (72.7% SWE-bench)
+- Launch: `free-coding-models --rovo` or press `Z` until Rovo mode
+- Features: Jira/Confluence integration, MCP server support
+
+**♊ Gemini CLI**
+- Provider: [Google Gemini](https://github.com/google-gemini/gemini-cli)
+- Install: `npm install -g @google/gemini-cli`
+- Free tier: 1,000 requests/day (personal Google account, no credit card)
+- Models: Gemini 3 Pro (76.2% SWE-bench), Gemini 2.5 Pro, Gemini 2.5 Flash
+- Launch: `free-coding-models --gemini` or press `Z` until Gemini mode
+- Features: OpenAI-compatible API support, MCP server support, Google Search grounding
+
+**Note:** When launching these tools via `Z` key or command palette, if the current mode doesn't match the tool, you'll see a confirmation alert asking to switch to the correct tool before launching.
+
+### OpenCode Zen Free Models
+
+[OpenCode Zen](https://opencode.ai/zen) is a hosted AI gateway offering 8 free coding models exclusively through OpenCode CLI and OpenCode Desktop. These models are **not** available through other tools.
+
+| Model | Tier | SWE-bench | Context |
+|-------|------|-----------|---------|
+| Big Pickle | S+ | 72.0% | 200k |
+| MiniMax M2.5 Free | S+ | 80.2% | 200k |
+| MiMo V2 Pro Free | S+ | 78.0% | 1M |
+| MiMo V2 Omni Free | S | 64.0% | 128k |
+| MiMo V2 Flash Free | S+ | 73.4% | 256k |
+| Nemotron 3 Super Free | A+ | 52.0% | 128k |
+| GPT 5 Nano | S | 65.0% | 128k |
+| Trinity Large Preview Free | S | 62.0% | 128k |
+
+To use Zen models: sign up at [opencode.ai/auth](https://opencode.ai/auth) and enter your Zen API key via `P` (Settings). Zen models appear in the main table and auto-switch to OpenCode CLI on launch.
+
+### Tool Compatibility
+
+The TUI shows a **"Compatible with"** column displaying colored emojis for each supported tool. When a tool mode is active (via `Z`), models incompatible with that tool are highlighted with a dark red background so you can instantly see which models work with your current tool.
+
+| Model Type | Compatible Tools |
+|------------|-----------------|
+| Regular (NVIDIA, Groq, etc.) | All tools except 🦘 Rovo and ♊ Gemini |
+| Rovo | 🦘 Rovo Dev CLI only |
+| Gemini | ♊ Gemini CLI only |
+| OpenCode Zen | 📦 OpenCode CLI and 📦 OpenCode Desktop only |
+
 → **[Full flags reference](./docs/flags.md)**
 
 ---
@@ -204,7 +257,7 @@ Press **`Z`** in the TUI to cycle between tools without restarting.
 
 ## ✨ Features
 
-- **Parallel pings** — all 160 models tested simultaneously via native `fetch`
+- **Parallel pings** — all 174 models tested simultaneously via native `fetch`
 - **Adaptive monitoring** — 2s burst for 60s → 10s normal → 30s idle
 - **Stability score** — composite 0–100 (p95 latency, jitter, spike rate, uptime)
 - **Smart ranking** — top 3 highlighted 🥇🥈🥉
@@ -215,6 +268,8 @@ Press **`Z`** in the TUI to cycle between tools without restarting.
 - **⚡️ 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 (from Settings `P` or ⚡️ Command Palette)
 - **Missing tool bootstrap** — detect absent CLIs, offer one-click install, then continue the selected launch automatically
+- **Tool compatibility matrix** — colored emojis show which tools each model supports; incompatible rows highlighted in dark red when a tool mode is active
+- **OpenCode Zen models** — 8 free models exclusive to OpenCode CLI/Desktop, powered by the Zen AI gateway
 - **Width guardrail** — shows a warning instead of a broken table in narrow terminals
 - **Readable everywhere** — semantic theme palette keeps table rows, overlays, badges, and help screens legible in dark and light terminals
 - **Global theme switch** — `G` cycles `auto`, `dark`, and `light` live without restarting

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "free-coding-models",
-  "version": "0.3.23",
+  "version": "0.3.24",
   "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/sources.js

@@ -344,6 +344,40 @@ export const iflow = [
   ['qwen3-max',                               'Qwen3 Max',           'A+', '55.0%', '256k'],
 ]
 
+// 📖 Rovo Dev CLI source - https://www.atlassian.com/rovo
+// 📖 CLI tool only - no API endpoint - requires 'acli rovodev run'
+// 📖 Install: https://support.atlassian.com/rovo/docs/install-and-run-rovo-dev-cli-on-your-device/
+// 📖 Free tier: 5M tokens/day (beta) - Claude Sonnet 4 (72.7% SWE-bench)
+// 📖 Requires Atlassian account + Rovo Dev activated on your site
+export const rovo = [
+  ['anthropic/claude-sonnet-4',         'Claude Sonnet 4 🆕',   'S+', '72.7%', '200k'],
+]
+
+// 📖 Gemini CLI source - https://github.com/google-gemini/gemini-cli
+// 📖 CLI tool with OpenAI-compatible API support
+// 📖 Install: npm install -g @google/gemini-cli
+// 📖 Free tier: 1,000 req/day with personal Google account (no credit card)
+// 📖 Models: Gemini 3 Pro (76.2% SWE-bench), Gemini 2.5 Pro, Gemini 2.5 Flash
+// 📖 Supports custom OpenAI-compatible providers via GEMINI_API_BASE_URL
+export const gemini = [
+  ['google/gemini-3-pro',               'Gemini 3 Pro 🆕',      'S+', '76.2%', '1M'],
+  ['google/gemini-2.5-pro',             'Gemini 2.5 Pro',      'S+', '63.2%', '1M'],
+  ['google/gemini-2.5-flash',           'Gemini 2.5 Flash',    'A+', '50.0%', '1M'],
+]
+
+// 📖 OpenCode Zen free models — hosted AI gateway accessed through OpenCode CLI/Desktop
+// 📖 Endpoint: https://opencode.ai/zen/v1/... — requires OpenCode Zen API key
+// 📖 These models are FREE on the Zen platform and only run on OpenCode CLI or OpenCode Desktop
+// 📖 Login: https://opencode.ai/auth — get your Zen API key
+// 📖 Config: set provider to opencode/<model-id> in OpenCode config
+export const opencodeZen = [
+  ['big-pickle',                              'Big Pickle 🆕',             'S+', '72.0%', '200k'],
+  ['gpt-5-nano',                              'GPT 5 Nano 🆕',            'S',  '65.0%', '128k'],
+  ['mimo-v2-flash-free',                      'MiMo V2 Flash Free 🆕',    'S+', '73.4%', '256k'],
+  ['minimax-m2.5-free',                       'MiniMax M2.5 Free 🆕',     'S+', '80.2%', '200k'],
+  ['nemotron-3-super-free',                   'Nemotron 3 Super Free 🆕',  'A+', '52.0%', '128k'],
+]
+
 // 📖 All sources combined - used by the main script
 // 📖 Each source has: name (display), url (API endpoint), models (array of model tuples)
 export const sources = {
@@ -447,6 +481,32 @@ export const sources = {
     url: 'https://apis.iflow.cn/v1/chat/completions',
     models: iflow,
   },
+  // 📖 CLI-only tools (no API endpoint - launched directly)
+  rovo: {
+    name: 'Rovo Dev CLI',
+    url: null, // CLI tool - no API endpoint
+    models: rovo,
+    cliOnly: true,
+    installUrl: 'https://support.atlassian.com/rovo/docs/install-and-run-rovo-dev-cli-on-your-device/',
+    binary: 'acli',
+    checkArgs: ['rovodev', '--help'],
+  },
+  gemini: {
+    name: 'Gemini CLI',
+    url: null, // CLI tool - no API endpoint (can use OpenAI-compatible via env)
+    models: gemini,
+    cliOnly: true,
+    installUrl: 'https://github.com/google-gemini/gemini-cli',
+    binary: 'gemini',
+    checkArgs: ['--version'],
+  },
+  // 📖 OpenCode Zen free models — hosted AI gateway, only runs on OpenCode CLI / Desktop
+  'opencode-zen': {
+    name: 'OpenCode Zen',
+    url: 'https://opencode.ai/zen/v1/chat/completions',
+    models: opencodeZen,
+    zenOnly: true,
+  },
 }
 
 // 📖 Flatten all models from all sources — each entry includes providerKey as 6th element

package/src/app.js

@@ -233,6 +233,8 @@ export async function runApp(cliArgs, config) {
       openhands: cliArgs.openHandsMode,
       amp: cliArgs.ampMode,
       pi: cliArgs.piMode,
+      rovo: cliArgs.rovoMode,
+      gemini: cliArgs.geminiMode,
     }
     return flagByMode[toolMode] === true
   })
@@ -389,7 +391,7 @@ export async function runApp(cliArgs, config) {
       terminalCols: process.stdout.columns || 80, // 📖 Current terminal width
       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).
+    widthWarningShowCount: 0, // 📖 No longer used — kept for backward compatibility. Warning now shows every time terminal is too small.
     // 📖 Settings screen state (P key opens it)
     settingsOpen: false,          // 📖 Whether settings overlay is active
     settingsCursor: 0,            // 📖 Which provider row is selected in settings
@@ -434,6 +436,15 @@ export async function runApp(cliArgs, config) {
     toolInstallPromptModel: null,
     toolInstallPromptPlan: null,
     toolInstallPromptErrorMsg: null,
+    // 📖 Incompatible model fallback overlay — shown when user presses Enter on a red-highlighted model.
+    // 📖 Offers two options: switch to a compatible tool, or pick a similar SWE-scored model.
+    incompatibleFallbackOpen: false,
+    incompatibleFallbackCursor: 0,
+    incompatibleFallbackScrollOffset: 0,
+    incompatibleFallbackModel: null,        // 📖 The incompatible model the user tried to launch
+    incompatibleFallbackTools: [],           // 📖 Compatible tools for the selected model
+    incompatibleFallbackSimilarModels: [],   // 📖 Similar SWE models compatible with current tool
+    incompatibleFallbackSection: 'tools',    // 📖 'tools' or 'models' — which section cursor is in
     // 📖 Smart Recommend overlay state (Q key opens it)
     recommendOpen: false,         // 📖 Whether the recommend overlay is active
     recommendPhase: 'questionnaire', // 📖 'questionnaire'|'analyzing'|'results' — current phase
@@ -472,7 +483,6 @@ export async function runApp(cliArgs, config) {
       if (prevCols >= WIDTH_WARNING_MIN_COLS || state.widthWarningDismissed) {
         state.widthWarningStartedAt = Date.now()
         state.widthWarningDismissed = false
-        state.widthWarningShowCount++ // 📖 Increment counter when showing the warning again
       } else if (!state.widthWarningStartedAt) {
         state.widthWarningStartedAt = Date.now()
       }
@@ -684,7 +694,11 @@ export async function runApp(cliArgs, config) {
         r.hidden = false
         return
       }
-      const unconfiguredHide = state.hideUnconfiguredModels && !getApiKey(state.config, r.providerKey)
+      // 📖 CLI-only tools (rovo, gemini) and Zen models don't need traditional API keys —
+      // 📖 they authenticate via their own CLI login flow, so "configured only" should never hide them.
+      const providerMeta = PROVIDER_METADATA[r.providerKey]
+      const noKeyNeeded = providerMeta?.cliOnly || providerMeta?.zenOnly
+      const unconfiguredHide = state.hideUnconfiguredModels && !noKeyNeeded && !getApiKey(state.config, r.providerKey)
       if (unconfiguredHide) {
         r.hidden = true
         return
@@ -800,6 +814,7 @@ export async function runApp(cliArgs, config) {
     startOpenCode,
     startExternalTool,
     getToolModeOrder,
+    getToolMeta,
     getToolInstallPlan,
     isToolInstalled,
     installToolWithPlan,
@@ -862,7 +877,7 @@ 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 && !state.commandPaletteOpen) {
+    if (!state.settingsOpen && !state.installEndpointsOpen && !state.toolInstallPromptOpen && !state.incompatibleFallbackOpen && !state.recommendOpen && !state.feedbackOpen && !state.changelogOpen && !state.commandPaletteOpen) {
       const visible = state.results.filter(r => !r.hidden)
       state.visibleSorted = sortResultsWithPinnedFavorites(visible, state.sortColumn, state.sortDirection, {
         pinFavorites: state.favoritesPinnedAndSticky,
@@ -945,6 +960,8 @@ export async function runApp(cliArgs, config) {
         ? overlays.renderInstallEndpoints()
       : state.toolInstallPromptOpen
         ? overlays.renderToolInstallPrompt()
+      : state.incompatibleFallbackOpen
+        ? overlays.renderIncompatibleFallback()
       : state.commandPaletteOpen
         ? tableContent + overlays.renderCommandPalette()
       : state.recommendOpen
@@ -975,7 +992,7 @@ export async function runApp(cliArgs, config) {
     pinFavorites: state.favoritesPinnedAndSticky,
   })
 
-  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.favoritesPinnedAndSticky, state.customTextFilter))
+      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.favoritesPinnedAndSticky, state.customTextFilter))
   if (process.stdout.isTTY) {
     process.stdout.flush && process.stdout.flush()
   }

package/src/command-palette.js

@@ -28,13 +28,15 @@ const TOOL_MODE_DESCRIPTIONS = {
   qwen: 'Launch Qwen Code using the selected provider model.',
   openhands: 'Launch OpenHands with the selected model endpoint.',
   amp: 'Launch Amp with this model as active target.',
+  rovo: 'Rovo Dev CLI model (launch with Rovo tool only).',
+  gemini: 'Gemini CLI model (launch with Gemini tool only).',
 }
 
 const TOOL_MODE_COMMANDS = TOOL_MODE_ORDER.map((toolMode) => {
   const meta = TOOL_METADATA[toolMode] || { label: toolMode, emoji: '🧰' }
   return {
     id: `action-set-tool-${toolMode}`,
-    label: meta.label,
+    label: `${meta.emoji} ${meta.label}`,
     toolMode,
     icon: meta.emoji,
     description: TOOL_MODE_DESCRIPTIONS[toolMode] || 'Set this as the active launch target.',

package/src/endpoint-installer.js

@@ -48,7 +48,8 @@ import { getApiKey, saveConfig } from './config.js'
 import { ENV_VAR_NAMES, PROVIDER_METADATA } from './provider-metadata.js'
 import { getToolMeta } from './tool-metadata.js'
 
-const DIRECT_INSTALL_UNSUPPORTED_PROVIDERS = new Set(['replicate', 'zai'])
+// 📖 CLI-only providers (rovo, gemini) and Zen-only (opencode-zen) cannot be installed into other tools.
+const DIRECT_INSTALL_UNSUPPORTED_PROVIDERS = new Set(['replicate', 'zai', 'rovo', 'gemini', 'opencode-zen'])
 // 📖 Install Endpoints only lists tools whose persisted config shape is actually supported here.
 // 📖 Claude Code, Codex, and Gemini stay out while their dedicated bridges are being rebuilt.
 const INSTALL_TARGET_MODES = ['opencode', 'opencode-desktop', 'openclaw', 'crush', 'goose', 'pi', 'aider', 'qwen', 'openhands', 'amp']

package/src/key-handler.js

@@ -28,6 +28,7 @@
  */
 
 import { loadChangelog } from './changelog-loader.js'
+import { getToolMeta, isModelCompatibleWithTool, getCompatibleTools, findSimilarCompatibleModels } from './tool-metadata.js'
 import { loadConfig, replaceConfigContents } from './config.js'
 import { cleanupLegacyProxyArtifacts } from './legacy-proxy-cleanup.js'
 import { cycleThemeSetting, detectActiveTheme } from './theme.js'
@@ -247,9 +248,61 @@ export function createKeyHandler(ctx) {
     }
     console.log()
 
-    // 📖 OpenClaw manages API keys inside its own config file. All other tools
-    // 📖 still need a provider key to be useful, so keep the existing warning.
-    if (state.mode !== 'openclaw') {
+    // 📖 CLI-only tool compatibility checks:
+    // 📖 Case A: Active tool mode is CLI-only (rovo/gemini) but selected model doesn't belong to it
+    // 📖 Case B: Selected model belongs to a CLI-only provider but active mode is something else
+    // 📖 Case C: Selected model is from opencode-zen but active mode is not opencode/opencode-desktop
+    const activeMeta = getToolMeta(state.mode)
+    const isActiveModeCliOnly = activeMeta.cliOnly === true
+    const isModelFromCliOnly = selected.providerKey === 'rovo' || selected.providerKey === 'gemini'
+    const isModelFromZen = selected.providerKey === 'opencode-zen'
+    const modelBelongsToActiveMode = selected.providerKey === state.mode
+
+    // 📖 Case A: User is in Rovo/Gemini mode but selected a model from a different provider
+    if (isActiveModeCliOnly && !modelBelongsToActiveMode) {
+      const availableModels = MODELS.filter(m => m[5] === state.mode)
+      console.log(chalk.yellow(`  ⚠ ${activeMeta.label} can only launch its own models.`))
+      console.log(chalk.yellow(`  "${selected.label}" is not a ${activeMeta.label} model.`))
+      console.log()
+      if (availableModels.length > 0) {
+        console.log(chalk.cyan(`  Available ${activeMeta.label} models:`))
+        for (const m of availableModels) {
+          console.log(chalk.white(`    • ${m[1]} (${m[2]} tier, ${m[3]} SWE, ${m[4]} ctx)`))
+        }
+        console.log()
+      }
+      console.log(chalk.dim(`  Switch to another tool mode with Z, or select a ${activeMeta.label} model.`))
+      console.log()
+      process.exit(0)
+    }
+
+    // 📖 Case B: Selected model is from a CLI-only provider but active mode is different
+    if (isModelFromCliOnly && !modelBelongsToActiveMode) {
+      const modelMeta = getToolMeta(selected.providerKey)
+      console.log(chalk.yellow(`  ⚠ ${selected.label} is a ${modelMeta.label}-exclusive model.`))
+      console.log(chalk.yellow(`  Your current tool is: ${activeMeta.label}`))
+      console.log()
+      console.log(chalk.cyan(`  Switching to ${modelMeta.label} and launching...`))
+      setToolMode(selected.providerKey)
+      console.log(chalk.green(`  ✓ Switched to ${modelMeta.label}`))
+      console.log()
+    }
+
+    // 📖 Case C: Zen model selected but active mode is not OpenCode CLI / OpenCode Desktop
+    // 📖 Auto-switch to OpenCode CLI since Zen models only run on OpenCode
+    if (isModelFromZen && state.mode !== 'opencode' && state.mode !== 'opencode-desktop') {
+      console.log(chalk.yellow(`  ⚠ ${selected.label} is an OpenCode Zen model.`))
+      console.log(chalk.yellow(`  Zen models only run on OpenCode CLI or OpenCode Desktop.`))
+      console.log(chalk.yellow(`  Your current tool is: ${activeMeta.label}`))
+      console.log()
+      console.log(chalk.cyan(`  Switching to OpenCode CLI and launching...`))
+      setToolMode('opencode')
+      console.log(chalk.green(`  ✓ Switched to OpenCode CLI`))
+      console.log()
+    }
+
+    // 📖 OpenClaw, CLI-only tools, and Zen models manage auth differently — skip API key warning for them.
+    if (state.mode !== 'openclaw' && !isModelFromCliOnly && !isModelFromZen) {
       const selectedApiKey = getApiKey(state.config, selected.providerKey)
       if (!selectedApiKey) {
         console.log(chalk.yellow(`  Warning: No API key configured for ${selected.providerKey}.`))
@@ -259,6 +312,41 @@ export function createKeyHandler(ctx) {
       }
     }
 
+    // 📖 CLI-only tool auto-install check — verify the CLI binary is available before launch.
+    const toolModeForProvider = selected.providerKey
+    if (isModelFromCliOnly && !isToolInstalled(toolModeForProvider)) {
+      const installPlan = getToolInstallPlan(toolModeForProvider)
+      if (installPlan.supported) {
+        console.log()
+        console.log(chalk.yellow(`  ⚠ ${getToolMeta(toolModeForProvider).label} is not installed.`))
+        console.log(chalk.dim(`  ${installPlan.summary}`))
+        if (installPlan.note) console.log(chalk.dim(`  Note: ${installPlan.note}`))
+        console.log()
+        console.log(chalk.cyan(`  📦 Auto-installing ${getToolMeta(toolModeForProvider).label}...`))
+        console.log()
+
+        const installResult = await installToolWithPlan(installPlan)
+        if (!installResult.ok) {
+          console.log(chalk.red(`  X Tool installation failed with exit code ${installResult.exitCode}.`))
+          if (installPlan.docsUrl) console.log(chalk.dim(`  Docs: ${installPlan.docsUrl}`))
+          console.log()
+          process.exit(installResult.exitCode || 1)
+        }
+
+        // 📖 Verify tool is now installed
+        if (!isToolInstalled(toolModeForProvider)) {
+          console.log(chalk.yellow('  ⚠ The installer finished, but the tool is still not reachable from this terminal session.'))
+          console.log(chalk.dim('  Restart your shell or add the tool bin directory to PATH, then retry the launch.'))
+          if (installPlan.docsUrl) console.log(chalk.dim(`  Docs: ${installPlan.docsUrl}`))
+          console.log()
+          process.exit(1)
+        }
+
+        console.log(chalk.green('  ✓ Tool installed successfully. Continuing with the selected model...'))
+        console.log()
+      }
+    }
+
     let exitCode = 0
     if (state.mode === 'openclaw') {
       exitCode = await startOpenClaw(userSelected, state.config, { launchCli: true })
@@ -1200,6 +1288,85 @@ export function createKeyHandler(ctx) {
       return
     }
 
+    // 📖 Incompatible fallback overlay: ↑↓ navigate across tool + model sections, Enter confirms, Esc cancels.
+    // 📖 Cursor is a flat index: 0..N-1 = compatible tools, N..N+M-1 = similar models.
+    if (state.incompatibleFallbackOpen) {
+      if (key.ctrl && key.name === 'c') { exit(0); return }
+
+      const tools = state.incompatibleFallbackTools || []
+      const similarModels = state.incompatibleFallbackSimilarModels || []
+      const totalItems = tools.length + similarModels.length
+
+      if (key.name === 'escape') {
+        // 📖 Close the overlay and go back to the main table
+        state.incompatibleFallbackOpen = false
+        state.incompatibleFallbackCursor = 0
+        state.incompatibleFallbackScrollOffset = 0
+        state.incompatibleFallbackModel = null
+        state.incompatibleFallbackTools = []
+        state.incompatibleFallbackSimilarModels = []
+        state.incompatibleFallbackSection = 'tools'
+        return
+      }
+
+      if (key.name === 'up' && totalItems > 0) {
+        state.incompatibleFallbackCursor = state.incompatibleFallbackCursor > 0
+          ? state.incompatibleFallbackCursor - 1
+          : totalItems - 1
+        state.incompatibleFallbackSection = state.incompatibleFallbackCursor < tools.length ? 'tools' : 'models'
+        return
+      }
+
+      if (key.name === 'down' && totalItems > 0) {
+        state.incompatibleFallbackCursor = state.incompatibleFallbackCursor < totalItems - 1
+          ? state.incompatibleFallbackCursor + 1
+          : 0
+        state.incompatibleFallbackSection = state.incompatibleFallbackCursor < tools.length ? 'tools' : 'models'
+        return
+      }
+
+      if (key.name === 'return' && totalItems > 0) {
+        const cursor = state.incompatibleFallbackCursor
+        const fallbackModel = state.incompatibleFallbackModel
+
+        // 📖 Close overlay state first
+        state.incompatibleFallbackOpen = false
+        state.incompatibleFallbackCursor = 0
+        state.incompatibleFallbackScrollOffset = 0
+        state.incompatibleFallbackModel = null
+        state.incompatibleFallbackTools = []
+        state.incompatibleFallbackSimilarModels = []
+        state.incompatibleFallbackSection = 'tools'
+
+        if (cursor < tools.length) {
+          // 📖 Section 1: Switch to the selected compatible tool, then launch the original model
+          const selectedToolKey = tools[cursor]
+          setToolMode(selectedToolKey)
+          // 📖 Find the full result object for the original model to pass to launchSelectedModel
+          const fullModel = state.results.find(
+            r => r.providerKey === fallbackModel.providerKey && r.modelId === fallbackModel.modelId
+          )
+          if (fullModel) {
+            await launchSelectedModel(fullModel)
+          }
+        } else {
+          // 📖 Section 2: Launch the selected similar model instead
+          const modelIdx = cursor - tools.length
+          const selectedSimilar = similarModels[modelIdx]
+          if (selectedSimilar) {
+            const fullModel = state.results.find(
+              r => r.providerKey === selectedSimilar.providerKey && r.modelId === selectedSimilar.modelId
+            )
+            if (fullModel) {
+              await launchSelectedModel(fullModel)
+            }
+          }
+        }
+      }
+
+      return
+    }
+
     // 📖 Feedback overlay: intercept ALL keys while overlay is active.
     // 📖 Enter → send to Discord, Esc → cancel, Backspace → delete char, printable → append to buffer.
     if (state.feedbackOpen) {
@@ -1809,8 +1976,6 @@ export function createKeyHandler(ctx) {
 
     // 📖 Profile system removed - API keys now persist permanently across all sessions
 
-    // 📖 Profile system removed - API keys now persist permanently across all sessions
-
     // 📖 Shift+R: reset all UI view settings to defaults (tier, sort, provider) and clear persisted config
     if (key.name === 'r' && key.shift) {
       resetViewSettings()
@@ -1944,6 +2109,33 @@ export function createKeyHandler(ctx) {
       // 📖 Use the cached visible+sorted array — guaranteed to match what's on screen
       const selected = state.visibleSorted[state.cursor]
       if (!selected) return // 📖 Guard: empty visible list (all filtered out)
+
+      // 📖 Incompatibility intercept — if the model can't run on the active tool,
+      // 📖 show the fallback overlay instead of launching. Lets user switch tool or pick similar model.
+      if (!isModelCompatibleWithTool(selected.providerKey, state.mode)) {
+        const compatTools = getCompatibleTools(selected.providerKey)
+        const similarModels = findSimilarCompatibleModels(
+          selected.sweScore || '-',
+          state.mode,
+          state.results.filter(r => r.providerKey !== selected.providerKey || r.modelId !== selected.modelId),
+          3
+        )
+        state.incompatibleFallbackOpen = true
+        state.incompatibleFallbackCursor = 0
+        state.incompatibleFallbackScrollOffset = 0
+        state.incompatibleFallbackModel = {
+          modelId: selected.modelId,
+          label: selected.label,
+          tier: selected.tier,
+          providerKey: selected.providerKey,
+          sweScore: selected.sweScore || '-',
+        }
+        state.incompatibleFallbackTools = compatTools
+        state.incompatibleFallbackSimilarModels = similarModels
+        state.incompatibleFallbackSection = 'tools'
+        return
+      }
+
       if (shouldCheckMissingTool(state.mode) && !isToolInstalled(state.mode)) {
         state.toolInstallPromptOpen = true
         state.toolInstallPromptCursor = 0

package/src/overlays.js

@@ -764,7 +764,7 @@ export function createOverlayRenderers(state, deps) {
     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('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('Z')}  Cycle tool mode  ${hint('(📦 OpenCode → 📦 Desktop → 🦞 OpenClaw → 💘 Crush → 🪿 Goose → π Pi → 🛠 Aider → 🐉 Qwen → 🤲 OpenHands → ⚡ Amp → 🦘 Rovo → ♊ Gemini)')}`)
     lines.push(`  ${key('F')}  Toggle favorite on selected row  ${hint('(⭐ persisted across sessions)')}`)
     lines.push(`  ${key('Y')}  Toggle favorites mode  ${hint('(Pinned + always visible ↔ Normal filter/sort behavior)')}`)
     lines.push(`  ${key('X')}  Clear active text filter  ${hint('(remove custom query applied from ⚡️ Command Palette)')}`)
@@ -1217,6 +1217,102 @@ export function createOverlayRenderers(state, deps) {
     if (state.recommendPingTimer) { clearInterval(state.recommendPingTimer); state.recommendPingTimer = null }
   }
 
+  // ─── Incompatible fallback overlay ─────────────────────────────────────────
+  // 📖 renderIncompatibleFallback shows when user presses Enter on a model that
+  // 📖 is NOT compatible with the active tool. Two sections:
+  // 📖   Section 1: "Switch to a compatible tool" — lists tools the model CAN run on
+  // 📖   Section 2: "Use a similar model" — lists SWE-similar models compatible with current tool
+  // 📖 Cursor navigates a flat list across both sections. Enter executes, Esc cancels.
+  function renderIncompatibleFallback() {
+    const EL = '\x1b[K'
+    const lines = []
+    const cursorLineByRow = {}
+
+    const model = state.incompatibleFallbackModel
+    const tools = state.incompatibleFallbackTools || []
+    const similarModels = state.incompatibleFallbackSimilarModels || []
+    const totalItems = tools.length + similarModels.length
+    const activeMeta = getToolMeta(state.mode)
+
+    lines.push(`  ${chalk.cyanBright('🚀')} ${chalk.bold.cyanBright('free-coding-models')}`)
+    lines.push(`  ${chalk.bold('⚠️  Incompatible Model')}`)
+    lines.push('')
+
+    if (!model) {
+      lines.push(chalk.red('  No model data available.'))
+      lines.push('')
+      lines.push(chalk.dim('  Esc Close'))
+    } else {
+      // 📖 Header: explain why it's incompatible
+      const tierFn = TIER_COLOR[model.tier] ?? ((text) => themeColors.text(text))
+      lines.push(`  ${themeColors.textBold(model.label)}  ${tierFn(model.tier)}`)
+      lines.push(chalk.dim(`  This model cannot run on ${activeMeta.emoji} ${activeMeta.label}.`))
+      lines.push('')
+
+      // 📖 Section 1: Switch to a compatible tool
+      if (tools.length > 0) {
+        lines.push(`  ${themeColors.textBold('Switch to a compatible tool:')}`)
+        lines.push('')
+
+        for (let i = 0; i < tools.length; i++) {
+          const toolKey = tools[i]
+          const meta = getToolMeta(toolKey)
+          const [r, g, b] = meta.color || [200, 200, 200]
+          const coloredLabel = chalk.rgb(r, g, b)(`${meta.emoji} ${meta.label}`)
+          const isCursor = state.incompatibleFallbackCursor === i
+          const bullet = isCursor ? chalk.bold.cyan('  ❯ ') : chalk.dim('    ')
+          const row = `${bullet}${coloredLabel}`
+          cursorLineByRow[i] = lines.length
+          lines.push(isCursor ? themeColors.bgCursorInstall(row) : row)
+        }
+        lines.push('')
+      }
+
+      // 📖 Section 2: Use a similar model
+      if (similarModels.length > 0) {
+        lines.push(`  ${themeColors.textBold('Or pick a similar model for')} ${activeMeta.emoji} ${themeColors.textBold(activeMeta.label + ':')}`)
+        lines.push('')
+
+        for (let i = 0; i < similarModels.length; i++) {
+          const sm = similarModels[i]
+          const flatIdx = tools.length + i
+          const tierFnSm = TIER_COLOR[sm.tier] ?? ((text) => themeColors.text(text))
+          const isCursor = state.incompatibleFallbackCursor === flatIdx
+          const bullet = isCursor ? chalk.bold.cyan('  ❯ ') : chalk.dim('    ')
+          const sweLabel = sm.sweScore !== '-' ? `SWE ${sm.sweScore}` : 'SWE —'
+          const row = `${bullet}${themeColors.textBold(sm.label)}  ${tierFnSm(sm.tier)}  ${chalk.dim(sweLabel)}`
+          cursorLineByRow[flatIdx] = lines.length
+          lines.push(isCursor ? themeColors.bgCursorInstall(row) : row)
+        }
+        lines.push('')
+      }
+
+      if (totalItems === 0) {
+        lines.push(chalk.yellow('  No compatible tools or similar models found.'))
+        lines.push('')
+      }
+
+      lines.push(chalk.dim('  ↑↓ Navigate  •  Enter Confirm  •  Esc Cancel'))
+    }
+
+    lines.push('')
+
+    // 📖 Scroll management — same pattern as other overlays
+    const targetLine = cursorLineByRow[state.incompatibleFallbackCursor] ?? 0
+    state.incompatibleFallbackScrollOffset = keepOverlayTargetVisible(
+      state.incompatibleFallbackScrollOffset,
+      targetLine,
+      lines.length,
+      state.terminalRows
+    )
+    const { visible, offset } = sliceOverlayLines(lines, state.incompatibleFallbackScrollOffset, state.terminalRows)
+    state.incompatibleFallbackScrollOffset = offset
+
+    const tintedLines = tintOverlayLines(visible, themeColors.overlayBgSettings, state.terminalCols)
+    const cleared = tintedLines.map(l => l + EL)
+    return cleared.join('\n')
+  }
+
   return {
     renderSettings,
     renderInstallEndpoints,
@@ -1226,6 +1322,7 @@ export function createOverlayRenderers(state, deps) {
     renderRecommend,
     renderFeedback,
     renderChangelog,
+    renderIncompatibleFallback,
     startRecommendAnalysis,
     stopRecommendAnalysis,
   }

package/src/provider-metadata.js

@@ -58,6 +58,7 @@ export const ENV_VAR_NAMES = {
   cloudflare: 'CLOUDFLARE_API_TOKEN',
   perplexity: 'PERPLEXITY_API_KEY',
   zai:        'ZAI_API_KEY',
+  gemini:     'GEMINI_API_KEY',
 }
 
 // 📖 OPENCODE_MODEL_MAP: sparse table of model IDs that differ between sources.js and OpenCode's
@@ -225,4 +226,28 @@ export const PROVIDER_METADATA = {
     signupHint: 'Install @mariozechner/pi-coding-agent and set ANTHROPIC_API_KEY',
     rateLimits: 'Depends on provider subscription (e.g., Anthropic, OpenAI)',
   },
+  rovo: {
+    label: 'Rovo Dev CLI',
+    color: chalk.rgb(148, 163, 184), // slate blue
+    signupUrl: 'https://www.atlassian.com/rovo',
+    signupHint: 'Install ACLI and run: acli rovodev auth login',
+    rateLimits: 'Free tier: 5M tokens/day (beta, requires Atlassian account)',
+    cliOnly: true,
+  },
+  gemini: {
+    label: 'Gemini CLI',
+    color: chalk.rgb(66, 165, 245), // blue
+    signupUrl: 'https://github.com/google-gemini/gemini-cli',
+    signupHint: 'Install: npm install -g @google/gemini-cli',
+    rateLimits: 'Free tier: 1,000 req/day (personal Google account, no credit card)',
+    cliOnly: true,
+  },
+  'opencode-zen': {
+    label: 'OpenCode Zen',
+    color: chalk.rgb(139, 92, 246), // violet — distinctive from other providers
+    signupUrl: 'https://opencode.ai/auth',
+    signupHint: 'Login at opencode.ai/auth to get your Zen API key',
+    rateLimits: 'Free tier models — requires OpenCode Zen API key',
+    zenOnly: true,
+  },
 }

package/src/render-helpers.js

@@ -36,6 +36,7 @@
  *   - chalk: Terminal colors and formatting
  *   - ../src/constants.js: OVERLAY_PANEL_WIDTH, TABLE_FIXED_LINES
  *   - ../src/utils.js: sortResults
+ *   - ../src/tool-metadata.js: isModelCompatibleWithTool (for compatible-first partition)
  *
  *   ⚙️ Configuration:
  *   - OVERLAY_PANEL_WIDTH: Fixed width for overlay panels (from constants.js)
@@ -184,7 +185,6 @@ export function sortResultsWithPinnedFavorites(results, sortColumn, sortDirectio
     )
     return [...recommendedRows, ...nonRecommendedRows]
   }
-
   const recommendedRows = results
     .filter((r) => r.isRecommended && !r.isFavorite)
     .sort((a, b) => (b.recommendScore || 0) - (a.recommendScore || 0))

package/src/render-table.js

@@ -50,7 +50,7 @@ import { TIER_COLOR } from './tier-colors.js'
 import { getAvg, getVerdict, getUptime, getStabilityScore, getVersionStatusInfo } from './utils.js'
 import { usagePlaceholderForProvider } from './ping.js'
 import { calculateViewport, sortResultsWithPinnedFavorites, padEndDisplay, displayWidth } from './render-helpers.js'
-import { getToolMeta } from './tool-metadata.js'
+import { getToolMeta, TOOL_METADATA, TOOL_MODE_ORDER, COMPAT_COLUMN_SLOTS, getCompatibleTools, isModelCompatibleWithTool } from './tool-metadata.js'
 import { getColumnSpacing } from './ui-config.js'
 
 const require = createRequire(import.meta.url)
@@ -109,9 +109,12 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
 
   // 📖 Tool badge keeps the active launch target visible in the header, so the
   // 📖 footer no longer needs a redundant Enter action or mode toggle reminder.
+  // 📖 Tool name is colored with its unique tool color for quick recognition.
   const toolMeta = getToolMeta(mode)
   const toolBadgeColor = mode === 'openclaw' ? themeColors.warningBold : themeColors.accentBold
-  const modeBadge = toolBadgeColor(' [ ') + themeColors.hotkey('Z') + toolBadgeColor(` Tool : ${toolMeta.label} ]`)
+  const toolColor = toolMeta.color ? chalk.rgb(...toolMeta.color) : toolBadgeColor
+  const modeBadge = toolBadgeColor(' [ ') + themeColors.hotkey('Z') + toolBadgeColor(' Tool : ') + toolColor.bold(`${toolMeta.emoji} ${toolMeta.label}`) + toolBadgeColor(' ]')
+
   const activeHeaderBadge = (text, bg) => themeColors.badge(text, bg, getReadableTextRgb(bg))
   const versionStatus = getVersionStatusInfo(settingsUpdateState, settingsUpdateLatestVersion, startupLatestVersion, versionAlertsEnabled)
 
@@ -157,6 +160,7 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
   const W_STATUS = 18
   const W_VERDICT = 14
   const W_UPTIME = 6
+  const W_COMPAT = 22 // 📖 "Compatible with" column — 11 emoji slots (10×2 + 1×1 for π + 1 padding)
   // const W_TOKENS = 7 // Used column removed
   // const W_USAGE = 7 // Usage column removed
   const MIN_TABLE_WIDTH = WIDTH_WARNING_MIN_COLS
@@ -176,6 +180,7 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
   let showUptime = true
   let showTier = true
   let showStability = true
+  let showCompat = true // 📖 "Compatible with" column — hidden on narrow terminals
   let isCompact = false
 
   if (terminalCols > 0) {
@@ -187,6 +192,7 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
       cols.push(W_SWE, W_CTX, W_MODEL, wSource, wPing, wAvg, wStatus, W_VERDICT)
       if (showStability) cols.push(wStab)
       if (showUptime) cols.push(W_UPTIME)
+      if (showCompat) cols.push(W_COMPAT)
       return ROW_MARGIN + cols.reduce((a, b) => a + b, 0) + (cols.length - 1) * SEP_W
     }
 
@@ -200,6 +206,7 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
       wStatus = 13   // Health truncated after 6 chars + '…'
     }
     // 📖 Steps 2–5: Progressive column hiding (least useful first)
+    if (calcWidth() > terminalCols) showCompat = false
     if (calcWidth() > terminalCols) showRank = false
     if (calcWidth() > terminalCols) showUptime = false
     if (calcWidth() > terminalCols) showTier = false
@@ -208,7 +215,7 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
   const warningDurationMs = 2_000
   const elapsed = widthWarningStartedAt ? Math.max(0, Date.now() - widthWarningStartedAt) : warningDurationMs
   const remainingMs = Math.max(0, warningDurationMs - elapsed)
-  const showWidthWarning = terminalCols > 0 && terminalCols < MIN_TABLE_WIDTH && !widthWarningDismissed && widthWarningShowCount < 2 && remainingMs > 0
+  const showWidthWarning = terminalCols > 0 && terminalCols < MIN_TABLE_WIDTH && !widthWarningDismissed && remainingMs > 0
 
   if (showWidthWarning) {
     const lines = []
@@ -319,6 +326,14 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
     const padding = ' '.repeat(Math.max(0, W_UPTIME - plain.length))
     return themeColors.hotkey('U') + themeColors.dim('p%' + padding)
   })()
+  // 📖 "Compatible with" column header — show all tool emojis in their colors as the header
+  const compatHeaderEmojis = COMPAT_COLUMN_SLOTS.map(slot => {
+    return chalk.rgb(...slot.color)(slot.emoji)
+  }).join('')
+  // 📖 padEndDisplay accounts for emoji widths (most are 2-wide, π is 1-wide)
+  const compatHeaderRaw = COMPAT_COLUMN_SLOTS.reduce((w, slot) => w + displayWidth(slot.emoji), 0)
+  const compatHeaderPad = Math.max(0, W_COMPAT - compatHeaderRaw)
+  const compatH_c = compatHeaderEmojis + ' '.repeat(compatHeaderPad)
   // 📖 Usage column removed from UI – no header or separator for it.
   // 📖 Header row: conditionally include columns based on responsive visibility
   const headerParts = []
@@ -327,6 +342,7 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
   headerParts.push(sweH_c, ctxH_c, modelH_c, originH_c, pingH_c, avgH_c, healthH_c, verdictH_c)
   if (showStability) headerParts.push(stabH_c)
   if (showUptime) headerParts.push(uptimeH_c)
+  if (showCompat) headerParts.push(compatH_c)
   lines.push('  ' + headerParts.join(COL_SEP))
 
 
@@ -585,6 +601,31 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
     const sourceCursorText = providerDisplay.padEnd(wSource)
     const sourceCell = isCursor ? themeColors.provider(r.providerKey, sourceCursorText, { bold: true }) : source
 
+    // 📖 "Compatible with" column — show colored emojis for compatible tools
+    // 📖 Each slot in COMPAT_COLUMN_SLOTS maps to one or more tool keys.
+    // 📖 OpenCode CLI + Desktop are merged into a single 📦 slot.
+    let compatCell = ''
+    if (showCompat) {
+      const compatTools = getCompatibleTools(r.providerKey)
+      let compatDisplayWidth = 0
+      const emojiCells = COMPAT_COLUMN_SLOTS.map(slot => {
+        const isCompat = slot.toolKeys.some(tk => compatTools.includes(tk))
+        const ew = displayWidth(slot.emoji)
+        compatDisplayWidth += isCompat ? ew : ew
+        if (isCompat) {
+          return chalk.rgb(...slot.color)(slot.emoji)
+        }
+        // 📖 Replace incompatible emoji with dim spaces matching its display width
+        return themeColors.dim(' '.repeat(ew))
+      }).join('')
+      // 📖 Pad to W_COMPAT — account for actual emoji display widths
+      const extraPad = Math.max(0, W_COMPAT - compatDisplayWidth)
+      compatCell = emojiCells + ' '.repeat(extraPad)
+    }
+
+    // 📖 Check if this model is incompatible with the active tool mode
+    const isIncompatible = !isModelCompatibleWithTool(r.providerKey, mode)
+
     // 📖 Usage column removed from UI – no usage data displayed.
     // (We keep the logic but do not render it.)
     const usageCell = ''
@@ -596,10 +637,15 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
     rowParts.push(sweCell, ctxCell, nameCell, sourceCell, pingCell, avgCell, status, speedCell)
     if (showStability) rowParts.push(stabCell)
     if (showUptime) rowParts.push(uptimeCell)
+    if (showCompat) rowParts.push(compatCell)
     const row = '  ' + rowParts.join(COL_SEP)
 
     if (isCursor) {
       lines.push(themeColors.bgModelCursor(row))
+    } else if (isIncompatible) {
+      // 📖 Dark red background for models incompatible with the active tool mode.
+      // 📖 This visually warns the user that selecting this model won't work with their current tool.
+      lines.push(chalk.bgRgb(60, 15, 15).rgb(180, 130, 130)(row))
     } else if (r.isRecommended) {
       // 📖 Medium green background for recommended models (distinguishable from favorites)
       lines.push(themeColors.bgModelRecommended(row))

package/src/theme.js

@@ -141,6 +141,9 @@ const PROVIDER_PALETTES = {
     qwen: [255, 213, 128],
     zai: [150, 208, 255],
     iflow: [211, 229, 101],
+    rovo: [148, 163, 184],
+    gemini: [66, 165, 245],
+    'opencode-zen': [185, 146, 255],
   },
   light: {
     nvidia: [0, 126, 73],
@@ -163,6 +166,9 @@ const PROVIDER_PALETTES = {
     qwen: [132, 89, 0],
     zai: [0, 104, 171],
     iflow: [107, 130, 0],
+    rovo: [90, 100, 126],
+    gemini: [15, 97, 175],
+    'opencode-zen': [108, 58, 183],
   },
 }
 

package/src/tool-bootstrap.js

@@ -217,6 +217,28 @@ export const TOOL_BOOTSTRAP_METADATA = {
       },
     },
   },
+  rovo: {
+    binary: 'acli',
+    docsUrl: 'https://support.atlassian.com/rovo/docs/install-and-run-rovo-dev-cli-on-your-device/',
+    install: {
+      default: {
+        shellCommand: 'npm install -g acli',
+        summary: 'Rovo Dev CLI requires ACLI installation. Visit the documentation for platform-specific instructions.',
+        note: 'Rovo is an Atlassian tool that requires an Atlassian account with Rovo Dev activated.',
+      },
+    },
+  },
+  gemini: {
+    binary: 'gemini',
+    docsUrl: 'https://github.com/google-gemini/gemini-cli',
+    install: {
+      default: {
+        shellCommand: 'npm install -g @google/gemini-cli',
+        summary: 'Install Gemini CLI globally via npm.',
+        note: 'After installation, run `gemini` to authenticate with your Google account.',
+      },
+    },
+  },
 }
 
 export function getToolBootstrapMeta(mode) {

package/src/tool-launchers.js

@@ -41,7 +41,7 @@ import { sources } from '../sources.js'
 import { PROVIDER_COLOR } from './render-table.js'
 import { getApiKey } from './config.js'
 import { ENV_VAR_NAMES, isWindows } from './provider-metadata.js'
-import { getToolMeta } from './tool-metadata.js'
+import { getToolMeta, TOOL_METADATA } from './tool-metadata.js'
 import { PROVIDER_METADATA } from './provider-metadata.js'
 import { resolveToolBinaryPath } from './tool-bootstrap.js'
 
@@ -378,6 +378,57 @@ function writeOpenHandsEnv(model, apiKey, baseUrl, paths = getDefaultToolPaths()
   return { filePath, backupPath }
 }
 
+/**
+ * 📖 writeRovoConfig - Configure Rovo Dev CLI model selection
+ *
+ * Rovo Dev CLI uses ~/.rovodev/config.yml for configuration.
+ * We write the model ID to the config file before launching.
+ *
+ * @param {Object} model - Selected model with modelId
+ * @param {string} configPath - Path to Rovo config file
+ * @returns {{ filePath: string, backupPath: string | null }}
+ */
+function writeRovoConfig(model, configPath = join(homedir(), '.rovodev', 'config.yml')) {
+  const backupPath = backupIfExists(configPath)
+  const config = {
+    agent: {
+      modelId: model.modelId,
+    },
+  }
+
+  ensureDir(configPath)
+  writeFileSync(configPath, `agent:\n  modelId: "${model.modelId}"\n`)
+  return { filePath: configPath, backupPath }
+}
+
+/**
+ * 📖 buildGeminiEnv - Build environment variables for Gemini CLI
+ *
+ * Gemini CLI supports OpenAI-compatible APIs via environment variables:
+ * - GEMINI_API_BASE_URL: Custom API endpoint
+ * - GEMINI_API_KEY: API key for custom endpoint
+ *
+ * @param {Object} model - Selected model with providerKey
+ * @param {Object} config - Full app config
+ * @param {Object} options - Env options
+ * @returns {NodeJS.ProcessEnv}
+ */
+function buildGeminiEnv(model, config, options = {}) {
+  const providerKey = model.providerKey || 'gemini'
+  const apiKey = getApiKey(config, providerKey)
+  const baseUrl = getProviderBaseUrl(providerKey)
+
+  const env = cloneInheritedEnv(process.env, SANITIZED_TOOL_ENV_KEYS)
+
+  // If we have a custom API key and base URL, configure OpenAI-compatible mode
+  if (apiKey && baseUrl && options.includeProviderEnv) {
+    env.GEMINI_API_BASE_URL = baseUrl
+    env.GEMINI_API_KEY = apiKey
+  }
+
+  return env
+}
+
 function printConfigArtifacts(toolName, artifacts = []) {
   for (const artifact of artifacts) {
     if (!artifact?.path) continue
@@ -420,7 +471,9 @@ export function prepareExternalToolLaunch(mode, model, config, options = {}) {
     inheritedEnv: options.inheritedEnv,
   })
 
-  if (!apiKey && mode !== 'amp') {
+  const isCliOnlyTool = TOOL_METADATA[mode]?.cliOnly === true
+
+  if (!apiKey && mode !== 'amp' && !isCliOnlyTool) {
     const providerRgb = PROVIDER_COLOR[model.providerKey] ?? [105, 190, 245]
     const providerName = sources[model.providerKey]?.name || model.providerKey
     const coloredProviderName = chalk.bold.rgb(...providerRgb)(providerName)
@@ -544,6 +597,34 @@ export function prepareExternalToolLaunch(mode, model, config, options = {}) {
     }
   }
 
+  if (mode === 'rovo') {
+    const result = writeRovoConfig(model, join(homedir(), '.rovodev', 'config.yml'), paths)
+    console.log(chalk.dim(`  📖 Rovo Dev CLI configured with model: ${model.modelId}`))
+    return {
+      command: 'acli',
+      args: ['rovodev', 'run'],
+      env,
+      apiKey: null,
+      baseUrl: null,
+      meta,
+      configArtifacts: [{ path: result.filePath, backupPath: result.backupPath, label: 'config' }],
+    }
+  }
+
+  if (mode === 'gemini') {
+    const geminiEnv = buildGeminiEnv(model, config, { includeProviderEnv: options.includeProviderEnv })
+    console.log(chalk.dim(`  📖 Gemini CLI will use model: ${model.modelId}`))
+    return {
+      command: 'gemini',
+      args: [],
+      env: { ...env, ...geminiEnv },
+      apiKey: geminiEnv.GEMINI_API_KEY || null,
+      baseUrl: geminiEnv.GEMINI_API_BASE_URL || null,
+      meta,
+      configArtifacts: [],
+    }
+  }
+
   return {
     blocked: true,
     exitCode: 1,
@@ -598,6 +679,16 @@ export async function startExternalTool(mode, model, config) {
     return spawnCommand(resolveLaunchCommand(mode, launchPlan.command), launchPlan.args, launchPlan.env)
   }
 
+  if (mode === 'rovo') {
+    console.log(chalk.dim(`  📖 Launching Rovo Dev CLI in interactive mode...`))
+    return spawnCommand(resolveLaunchCommand(mode, launchPlan.command), launchPlan.args, launchPlan.env)
+  }
+
+  if (mode === 'gemini') {
+    console.log(chalk.dim(`  📖 Launching Gemini CLI...`))
+    return spawnCommand(resolveLaunchCommand(mode, launchPlan.command), launchPlan.args, launchPlan.env)
+  }
+
   console.log(chalk.red(`  X Unsupported external tool mode: ${mode}`))
   return 1
 }

package/src/tool-metadata.js

@@ -19,21 +19,44 @@
  *   → `getToolMeta` — return display metadata for one mode
  *   → `getToolModeOrder` — stable mode cycle order for the `Z` hotkey
  *
- * @exports TOOL_METADATA, TOOL_MODE_ORDER, getToolMeta, getToolModeOrder
+ * @exports TOOL_METADATA, TOOL_MODE_ORDER, COMPAT_COLUMN_SLOTS, getToolMeta, getToolModeOrder
  */
+// 📖 Each tool has a unique `color` RGB tuple used for the "Compatible with" column
+// 📖 and for coloring the tool name in the Z cycle header badge.
+// 📖 `emoji` is the unique icon shown everywhere (header badge, compat column, palette, overlays).
+// 📖 OpenCode CLI and Desktop share 📦 — they are the same platform, split only for launch logic.
 export const TOOL_METADATA = {
-  opencode: { label: 'OpenCode CLI', emoji: '💻', flag: '--opencode' },
-  'opencode-desktop': { label: 'OpenCode Desktop', emoji: '🖥', flag: '--opencode-desktop' },
-  openclaw: { label: 'OpenClaw', emoji: '🦞', flag: '--openclaw' },
-  crush: { label: 'Crush', emoji: '💘', flag: '--crush' },
-  goose: { label: 'Goose', emoji: '🪿', flag: '--goose' },
-  pi: { label: 'Pi', emoji: 'π', flag: '--pi' },
-  aider: { label: 'Aider', emoji: '🛠', flag: '--aider' },
-  qwen: { label: 'Qwen Code', emoji: '🌊', flag: '--qwen' },
-  openhands: { label: 'OpenHands', emoji: '🤲', flag: '--openhands' },
-  amp: { label: 'Amp', emoji: '⚡', flag: '--amp' },
+  opencode:          { label: 'OpenCode CLI',     emoji: '📦', flag: '--opencode',         color: [110, 214, 255] },
+  'opencode-desktop': { label: 'OpenCode Desktop', emoji: '📦', flag: '--opencode-desktop', color: [149, 205, 255] },
+  openclaw:          { label: 'OpenClaw',          emoji: '🦞', flag: '--openclaw',         color: [255, 129, 129] },
+  crush:             { label: 'Crush',             emoji: '💘', flag: '--crush',            color: [255, 168, 209] },
+  goose:             { label: 'Goose',             emoji: '🪿', flag: '--goose',            color: [132, 235, 168] },
+  pi:                { label: 'Pi',                emoji: 'π',  flag: '--pi',               color: [173, 216, 230] },
+  aider:             { label: 'Aider',             emoji: '🛠', flag: '--aider',            color: [255, 208, 102] },
+  qwen:              { label: 'Qwen Code',         emoji: '🐉', flag: '--qwen',             color: [255, 213, 128] },
+  openhands:         { label: 'OpenHands',         emoji: '🤲', flag: '--openhands',        color: [228, 191, 239] },
+  amp:               { label: 'Amp',               emoji: '⚡', flag: '--amp',              color: [255, 232, 98] },
+  rovo:              { label: 'Rovo Dev CLI',      emoji: '🦘', flag: '--rovo',             color: [148, 163, 184], cliOnly: true },
+  gemini:            { label: 'Gemini CLI',        emoji: '♊', flag: '--gemini',           color: [66, 165, 245],  cliOnly: true },
 }
 
+// 📖 Deduplicated emoji order for the "Compatible with" column.
+// 📖 OpenCode CLI + Desktop are merged into a single 📦 slot since they share compatibility.
+// 📖 Each slot maps to one or more toolKeys for compatibility checking.
+export const COMPAT_COLUMN_SLOTS = [
+  { emoji: '📦', toolKeys: ['opencode', 'opencode-desktop'], color: [110, 214, 255] },
+  { emoji: '🦞', toolKeys: ['openclaw'],                     color: [255, 129, 129] },
+  { emoji: '💘', toolKeys: ['crush'],                        color: [255, 168, 209] },
+  { emoji: '🪿', toolKeys: ['goose'],                        color: [132, 235, 168] },
+  { emoji: 'π',  toolKeys: ['pi'],                           color: [173, 216, 230] },
+  { emoji: '🛠', toolKeys: ['aider'],                        color: [255, 208, 102] },
+  { emoji: '🐉', toolKeys: ['qwen'],                         color: [255, 213, 128] },
+  { emoji: '🤲', toolKeys: ['openhands'],                    color: [228, 191, 239] },
+  { emoji: '⚡', toolKeys: ['amp'],                          color: [255, 232, 98] },
+  { emoji: '🦘', toolKeys: ['rovo'],                         color: [148, 163, 184] },
+  { emoji: '♊', toolKeys: ['gemini'],                       color: [66, 165, 245] },
+]
+
 export const TOOL_MODE_ORDER = [
   'opencode',
   'opencode-desktop',
@@ -45,6 +68,8 @@ export const TOOL_MODE_ORDER = [
   'qwen',
   'openhands',
   'amp',
+  'rovo',
+  'gemini',
 ]
 
 export function getToolMeta(mode) {
@@ -54,3 +79,61 @@ export function getToolMeta(mode) {
 export function getToolModeOrder() {
   return [...TOOL_MODE_ORDER]
 }
+
+// 📖 Regular tools: all tools EXCEPT rovo, gemini (which are CLI-only exclusives).
+// 📖 Used as the default compatible set for normal provider models.
+const REGULAR_TOOLS = Object.keys(TOOL_METADATA).filter(k => !TOOL_METADATA[k].cliOnly)
+
+// 📖 Zen-only tools: OpenCode Zen models can ONLY run on OpenCode CLI / OpenCode Desktop.
+const ZEN_COMPATIBLE_TOOLS = ['opencode', 'opencode-desktop']
+
+/**
+ * 📖 Returns the list of tool keys a model is compatible with.
+ *   - Rovo models → only 'rovo'
+ *   - Gemini models → only 'gemini'
+ *   - OpenCode Zen models → only 'opencode', 'opencode-desktop'
+ *   - Regular models → all non-cliOnly tools
+ * @param {string} providerKey — the source key from sources.js (e.g. 'nvidia', 'rovo', 'opencode-zen')
+ * @returns {string[]} — array of compatible tool keys
+ */
+export function getCompatibleTools(providerKey) {
+  if (providerKey === 'rovo') return ['rovo']
+  if (providerKey === 'gemini') return ['gemini']
+  if (providerKey === 'opencode-zen') return ZEN_COMPATIBLE_TOOLS
+  return REGULAR_TOOLS
+}
+
+/**
+ * 📖 Checks whether a model from the given provider can run on the specified tool mode.
+ * @param {string} providerKey — source key
+ * @param {string} toolMode — active tool mode
+ * @returns {boolean}
+ */
+export function isModelCompatibleWithTool(providerKey, toolMode) {
+  return getCompatibleTools(providerKey).includes(toolMode)
+}
+
+/**
+ * 📖 Finds compatible models with a similar SWE score to the selected one.
+ * 📖 Used by the incompatibility fallback overlay to suggest alternatives.
+ * @param {string} selectedSwe — SWE score string like '72.0%' or '-'
+ * @param {string} toolMode — current active tool mode
+ * @param {Array} allResults — the state.results array (each has .providerKey, .modelId, .label, .tier, .sweScore)
+ * @param {number} [maxResults=3] — max suggestions to return
+ * @returns {{ modelId: string, label: string, tier: string, sweScore: string, providerKey: string, sweDelta: number }[]}
+ */
+export function findSimilarCompatibleModels(selectedSwe, toolMode, allResults, maxResults = 3) {
+  const targetSwe = parseFloat(selectedSwe) || 0
+  return allResults
+    .filter(r => !r.hidden && isModelCompatibleWithTool(r.providerKey, toolMode))
+    .map(r => ({
+      modelId: r.modelId,
+      label: r.label,
+      tier: r.tier,
+      sweScore: r.sweScore || '-',
+      providerKey: r.providerKey,
+      sweDelta: Math.abs((parseFloat(r.sweScore) || 0) - targetSwe),
+    }))
+    .sort((a, b) => a.sweDelta - b.sweDelta)
+    .slice(0, maxResults)
+}

package/src/utils.js

@@ -454,6 +454,8 @@ export function parseArgs(argv) {
   const openHandsMode = flags.includes('--openhands')
   const ampMode = flags.includes('--amp')
   const piMode = flags.includes('--pi')
+  const rovoMode = flags.includes('--rovo')
+  const geminiMode = flags.includes('--gemini')
   const noTelemetry = flags.includes('--no-telemetry')
   const jsonMode = flags.includes('--json')
   const helpMode = flags.includes('--help') || flags.includes('-h')
@@ -490,6 +492,8 @@ export function parseArgs(argv) {
     openHandsMode,
     ampMode,
     piMode,
+    rovoMode,
+    geminiMode,
     noTelemetry,
     jsonMode,
     helpMode,