free-coding-models 0.3.23 → 0.3.25

package/src/render-table.js

@@ -50,12 +50,47 @@ 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, isModelCompatibleWithTool } from './tool-metadata.js'
 import { getColumnSpacing } from './ui-config.js'
 
 const require = createRequire(import.meta.url)
 const { version: LOCAL_VERSION } = require('../package.json')
 
+// 📖 Mouse support: column boundary map updated every frame by renderTable().
+// 📖 Each entry maps a column name to its display X-start and X-end (1-based, inclusive).
+// 📖 headerRow is the 1-based terminal row of the column header line.
+// 📖 firstModelRow/lastModelRow are the 1-based terminal rows of the first/last visible model row.
+// 📖 Exported so the mouse handler can translate click coordinates into column/row targets.
+let _lastLayout = {
+  columns: [],       // 📖 Array of { name, xStart, xEnd } in display order
+  headerRow: 0,      // 📖 1-based terminal row of the column headers
+  firstModelRow: 0,  // 📖 1-based terminal row of the first visible model
+  lastModelRow: 0,   // 📖 1-based terminal row of the last visible model
+  viewportStartIdx: 0, // 📖 index into sorted[] of the first visible model
+  viewportEndIdx: 0,   // 📖 index into sorted[] past the last visible model
+  hasAboveIndicator: false, // 📖 whether "... N more above ..." is shown
+  hasBelowIndicator: false, // 📖 whether "... N more below ..." is shown
+  footerHotkeys: [],  // 📖 Array of { key, row, xStart, xEnd } for footer click zones
+}
+export function getLastLayout() { return _lastLayout }
+
+// 📖 Column name → sort key mapping for mouse click-to-sort on header row
+const COLUMN_SORT_MAP = {
+  rank: 'rank',
+  tier: null, // 📖 Tier column click cycles tier filter rather than sorting
+  swe: 'swe',
+  ctx: 'ctx',
+  model: 'model',
+  source: 'origin',
+  ping: 'ping',
+  avg: 'avg',
+  health: 'condition',
+  verdict: 'verdict',
+  stability: 'stability',
+  uptime: 'uptime',
+}
+export { COLUMN_SORT_MAP }
+
 // 📖 Provider column palette: soft pastel rainbow so each provider stays easy
 // 📖 to spot without turning the table into a harsh neon wall.
 // 📖 Exported for use in overlays (settings screen) and logs.
@@ -109,9 +144,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 +195,7 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
   const W_STATUS = 18
   const W_VERDICT = 14
   const W_UPTIME = 6
+
   // const W_TOKENS = 7 // Used column removed
   // const W_USAGE = 7 // Usage column removed
   const MIN_TABLE_WIDTH = WIDTH_WARNING_MIN_COLS
@@ -205,10 +244,38 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
     if (calcWidth() > terminalCols) showTier = false
     if (calcWidth() > terminalCols) showStability = false
   }
+
+  // 📖 Mouse support: compute column boundaries from the resolved responsive widths.
+  // 📖 This builds an ordered array of { name, xStart, xEnd } (1-based display columns)
+  // 📖 matching exactly what renderTable paints so click-to-sort hits the right column.
+  {
+    const colDefs = []
+    if (showRank) colDefs.push({ name: 'rank', width: W_RANK })
+    if (showTier) colDefs.push({ name: 'tier', width: W_TIER })
+    colDefs.push({ name: 'swe', width: W_SWE })
+    colDefs.push({ name: 'ctx', width: W_CTX })
+    colDefs.push({ name: 'model', width: W_MODEL })
+    colDefs.push({ name: 'source', width: wSource })
+    colDefs.push({ name: 'ping', width: wPing })
+    colDefs.push({ name: 'avg', width: wAvg })
+    colDefs.push({ name: 'health', width: wStatus })
+    colDefs.push({ name: 'verdict', width: W_VERDICT })
+    if (showStability) colDefs.push({ name: 'stability', width: wStab })
+    if (showUptime) colDefs.push({ name: 'uptime', width: W_UPTIME })
+    let x = ROW_MARGIN + 1 // 📖 1-based: first column starts after the 2-char left margin
+    const columns = []
+    for (let i = 0; i < colDefs.length; i++) {
+      const { name, width } = colDefs[i]
+      const xEnd = x + width - 1
+      columns.push({ name, xStart: x, xEnd })
+      x = xEnd + 1 + SEP_W // 📖 skip past the ' │ ' separator
+    }
+    _lastLayout.columns = columns
+  }
   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 = []
@@ -261,8 +328,8 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
   const tierH    = 'Tier'
   const originH  = 'Provider'
   const modelH   = 'Model'
-  const sweH     = sortColumn === 'swe' ? dir + ' SWE%' : 'SWE%'
-  const ctxH     = sortColumn === 'ctx' ? dir + ' CTX' : 'CTX'
+  const sweH     = sortColumn === 'swe' ? (dir + 'SWE%') : 'SWE%'
+  const ctxH     = sortColumn === 'ctx' ? (dir + 'CTX') : 'CTX'
   // 📖 Compact labels: 'Lat. P' / 'Avg. P' / 'StaB.' to save horizontal space
   const pingLabel = isCompact ? 'Lat. P' : 'Latest Ping'
   const avgLabel  = isCompact ? 'Avg. P' : 'Avg Ping'
@@ -271,8 +338,10 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
   const avgH     = sortColumn === 'avg' ? dir + ' ' + avgLabel : avgLabel
   const healthH  = sortColumn === 'condition' ? dir + ' Health' : 'Health'
   const verdictH = sortColumn === 'verdict' ? dir + ' Verdict' : 'Verdict'
-  const stabH    = sortColumn === 'stability' ? dir + ' ' + stabLabel : stabLabel
-  const uptimeH  = sortColumn === 'uptime' ? dir + ' Up%' : 'Up%'
+  // 📖 Stability: in non-compact the arrow eats 2 chars ('↑ '), so truncate to fit wStab.
+  // 📖 Compact is fine because '↑ StaB.' (7) < wStab (8).
+  const stabH    = sortColumn === 'stability' ? (dir + (isCompact ? ' ' + stabLabel : 'Stability')) : stabLabel
+  const uptimeH  = sortColumn === 'uptime' ? (dir + 'Up%') : 'Up%'
 
   // 📖 Helper to colorize first letter for keyboard shortcuts
   // 📖 IMPORTANT: Pad PLAIN TEXT first, then apply colors to avoid alignment issues
@@ -319,6 +388,7 @@ 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)
   })()
+
   // 📖 Usage column removed from UI – no header or separator for it.
   // 📖 Header row: conditionally include columns based on responsive visibility
   const headerParts = []
@@ -329,6 +399,10 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
   if (showUptime) headerParts.push(uptimeH_c)
   lines.push('  ' + headerParts.join(COL_SEP))
 
+  // 📖 Mouse support: the column header row is the last line we just pushed.
+  // 📖 Terminal rows are 1-based, so line index (lines.length-1) → terminal row lines.length.
+  _lastLayout.headerRow = lines.length
+
 
 
   if (sorted.length === 0) {
@@ -360,6 +434,14 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
     lines.push(themeColors.dim(`  ... ${vp.startIdx} more above ...`))
   }
 
+  // 📖 Mouse support: record where model rows begin in the terminal (1-based).
+  // 📖 The next line pushed will be the first visible model row.
+  const _firstModelLineIdx = lines.length  // 📖 0-based index into lines[]
+  _lastLayout.viewportStartIdx = vp.startIdx
+  _lastLayout.viewportEndIdx = vp.endIdx
+  _lastLayout.hasAboveIndicator = vp.hasAbove
+  _lastLayout.hasBelowIndicator = vp.hasBelow
+
   for (let i = vp.startIdx; i < vp.endIdx; i++) {
     const r = sorted[i]
     const tierFn = TIER_COLOR[r.tier] ?? ((text) => themeColors.text(text))
@@ -585,6 +667,9 @@ 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
 
+    // 📖 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 = ''
@@ -600,6 +685,10 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
 
     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))
@@ -610,6 +699,11 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
     }
   }
 
+  // 📖 Mouse support: record the 1-based terminal row range of model data rows.
+  // 📖 _firstModelLineIdx was captured before the loop; lines.length is now past the last model row.
+  _lastLayout.firstModelRow = _firstModelLineIdx + 1  // 📖 convert 0-based line index → 1-based terminal row
+  _lastLayout.lastModelRow = lines.length              // 📖 last pushed line is at lines.length (1-based)
+
   if (vp.hasBelow) {
     lines.push(themeColors.dim(`  ... ${sorted.length - vp.endIdx} more below ...`))
   }
@@ -624,7 +718,40 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
   const activeHotkey = (keyLabel, text, bg) => themeColors.badge(`${keyLabel}${text}`, bg, getReadableTextRgb(bg))
   const favoritesModeBg = favoritesPinnedAndSticky ? [157, 122, 48] : [95, 95, 95]
   const favoritesModeLabel = favoritesPinnedAndSticky ? ' Favorites Pinned' : ' Favorites Normal'
+
+  // 📖 Mouse support: build footer hotkey zones alongside the footer lines.
+  // 📖 Each zone records { key, row (1-based terminal row), xStart, xEnd (1-based display cols) }.
+  // 📖 We accumulate display position as we build each footer line's parts.
+  const footerHotkeys = []
+
   // 📖 Line 1: core navigation + filtering shortcuts
+  // 📖 Build as parts array so we can compute click zones and still join for display.
+  {
+    const parts = [
+      { text: '  ', key: null },
+      { text: 'F Toggle Favorite', key: 'f' },
+      { text: '  •  ', key: null },
+      { text: 'Y' + favoritesModeLabel, key: 'y' },
+      { text: '  •  ', key: null },
+      { text: tierFilterMode > 0 ? `T Tier (${activeTierLabel})` : 'T Tier', key: 't' },
+      { text: '  •  ', key: null },
+      { text: originFilterMode > 0 ? `D Provider (${activeOriginLabel})` : 'D Provider', key: 'd' },
+      { text: '  •  ', key: null },
+      { text: 'E Show only configured models', key: 'e' },
+      { text: '  •  ', key: null },
+      { text: 'P Settings', key: 'p' },
+      { text: '  •  ', key: null },
+      { text: 'K Help', key: 'k' },
+    ]
+    const footerRow1 = lines.length + 1 // 📖 1-based terminal row (line hasn't been pushed yet)
+    let xPos = 1
+    for (const part of parts) {
+      const w = displayWidth(part.text)
+      if (part.key) footerHotkeys.push({ key: part.key, row: footerRow1, xStart: xPos, xEnd: xPos + w - 1 })
+      xPos += w
+    }
+  }
+
   lines.push(
     '  ' + hotkey('F', ' Toggle Favorite') +
     themeColors.dim(`  •  `) +
@@ -638,12 +765,35 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
       ? activeHotkey('D', ` Provider (${activeOriginLabel})`, PROVIDER_COLOR[[null, ...Object.keys(sources)][originFilterMode]] || [255, 255, 255])
       : hotkey('D', ' Provider')) +
     themeColors.dim(`  •  `) +
-    (hideUnconfiguredModels ? activeHotkey('E', ' Configured Models Only', configuredBadgeBg) : hotkey('E', ' Configured Models Only')) +
+    (hideUnconfiguredModels ? activeHotkey('E', ' Show only configured models', configuredBadgeBg) : hotkey('E', ' Show only configured models')) +
     themeColors.dim(`  •  `) +
     hotkey('P', ' Settings') +
     themeColors.dim(`  •  `) +
     hotkey('K', ' Help')
   )
+
+  // 📖 Line 2: command palette, recommend, feedback, theme
+  {
+    const cpText = ' NEW ! CTRL+P ⚡️ Command Palette '
+    const parts = [
+      { text: '  ', key: null },
+      { text: cpText, key: 'ctrl+p' },
+      { text: '  •  ', key: null },
+      { text: 'Q Smart Recommend', key: 'q' },
+      { text: '  •  ', key: null },
+      { text: 'G Theme', key: 'g' },
+      { text: '  •  ', key: null },
+      { text: 'I Feedback, bugs & requests', key: 'i' },
+    ]
+    const footerRow2 = lines.length + 1
+    let xPos = 1
+    for (const part of parts) {
+      const w = displayWidth(part.text)
+      if (part.key) footerHotkeys.push({ key: part.key, row: footerRow2, xStart: xPos, xEnd: xPos + w - 1 })
+      xPos += w
+    }
+  }
+
   // 📖 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 ')
@@ -699,6 +849,29 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
     filterBadge = chalk.bgYellow.black.bold(` ${filterPrefix}${visibleFilter}${filterSuffix} `)
   }
 
+  // 📖 Mouse support: track last footer line hotkey zones
+  {
+    const lastFooterRow = lines.length + 1 // 📖 1-based terminal row (line about to be pushed)
+    const parts = [
+      { text: '  ', key: null },
+      { text: 'N Changelog', key: 'n' },
+    ]
+    if (hasCustomFilter) {
+      parts.push({ text: '  •  ', key: null })
+      // 📖 X key clears filter — compute width from rendered badge text
+      const badgePlain = `X Disable filter: "${customTextFilter.trim().replace(/\s+/g, ' ')}"`
+      parts.push({ text: ` ${badgePlain} `, key: 'x' })
+    }
+    let xPos = 1
+    for (const part of parts) {
+      const w = displayWidth(part.text)
+      if (part.key) footerHotkeys.push({ key: part.key, row: lastFooterRow, xStart: xPos, xEnd: xPos + w - 1 })
+      xPos += w
+    }
+  }
+
+  _lastLayout.footerHotkeys = footerHotkeys
+
   lines.push(
     '  ' + themeColors.hotkey('N') + themeColors.dim(' Changelog') +
     (filterBadge

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,