free-coding-models 0.3.24 → 0.3.25

package/CHANGELOG.md

@@ -1,6 +1,12 @@
 # Changelog
 ---
 
+## [0.3.25] - 2026-03-19
+
+### Changed
+- **Removed "CLI Tools" column** — The compat emoji column has been removed from the TUI table, freeing ~22 characters of horizontal space for other columns
+- **Cleaner table layout** — Responsive column hiding no longer needs to drop the compat column first on narrow terminals
+
 ## [0.3.24] - 2026-03-19
 
 ### Added

package/README.md

@@ -214,7 +214,7 @@ To use Zen models: sign up at [opencode.ai/auth](https://opencode.ai/auth) and e
 
 ### 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.
+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 |
 |------------|-----------------|
@@ -268,7 +268,7 @@ The TUI shows a **"Compatible with"** column displaying colored emojis for each
 - **⚡️ 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
+- **Tool compatibility matrix** — 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

package/package.json

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

package/src/app.js

@@ -119,7 +119,8 @@ import { renderTable, PROVIDER_COLOR } from '../src/render-table.js'
 import { setOpenCodeModelData, startOpenCode, startOpenCodeDesktop } from '../src/opencode.js'
 import { startOpenClaw } from '../src/openclaw.js'
 import { createOverlayRenderers } from '../src/overlays.js'
-import { createKeyHandler } from '../src/key-handler.js'
+import { createKeyHandler, createMouseEventHandler } from '../src/key-handler.js'
+import { createMouseHandler, containsMouseSequence } from '../src/mouse.js'
 import { getToolModeOrder, getToolMeta } from '../src/tool-metadata.js'
 import { startExternalTool } from '../src/tool-launchers.js'
 import { getToolInstallPlan, installToolWithPlan, isToolInstalled } from '../src/tool-bootstrap.js'
@@ -495,6 +496,7 @@ export async function runApp(cliArgs, config) {
 
   let ticker = null
   let onKeyPress = null
+  let onMouseData = null  // 📖 Mouse data listener — set after createMouseEventHandler
   let pingModel = null
 
   const scheduleNextPing = () => {
@@ -736,6 +738,7 @@ export async function runApp(cliArgs, config) {
     if (ticker) clearInterval(ticker)
     clearTimeout(state.pingIntervalObj)
     if (onKeyPress) process.stdin.removeListener('keypress', onKeyPress)
+    if (onMouseData) process.stdin.removeListener('data', onMouseData)
     if (process.stdin.isTTY && resetRawMode) process.stdin.setRawMode(false)
     process.stdin.pause()
     process.stdout.write(ALT_LEAVE)
@@ -837,6 +840,38 @@ export async function runApp(cliArgs, config) {
     readline,
   })
 
+  // 📖 Mouse event handler: translates parsed mouse events into TUI actions (sort, cursor, scroll).
+  const onMouseEvent = createMouseEventHandler({
+    state,
+    adjustScrollOffset,
+    applyTierFilter,
+    TIER_CYCLE,
+    ORIGIN_CYCLE,
+    noteUserActivity,
+    sortResultsWithPinnedFavorites,
+    saveConfig,
+    overlayLayout: overlays.overlayLayout, // 📖 Overlay cursor-to-line maps for click handling
+    // 📖 Favorite toggle — right-click on model rows
+    toggleFavoriteModel,
+    syncFavoriteFlags,
+    toFavoriteKey,
+    // 📖 Tool mode cycling — compat header click
+    cycleToolMode: () => {
+      // 📖 Inline cycle matching the Z-key handler in createKeyHandler
+      const modeOrder = getToolModeOrder()
+      const currentIndex = modeOrder.indexOf(state.mode)
+      const nextIndex = (currentIndex + 1) % modeOrder.length
+      state.mode = modeOrder[nextIndex]
+      if (!state.config.settings || typeof state.config.settings !== 'object') state.config.settings = {}
+      state.config.settings.preferredToolMode = state.mode
+      saveConfig(state.config)
+    },
+  })
+
+  // 📖 Wire the raw stdin data listener for mouse events.
+  // 📖 createMouseHandler returns a function that parses SGR sequences and calls onMouseEvent.
+  onMouseData = createMouseHandler({ onMouseEvent })
+
   // Apply CLI --tier filter if provided
   if (cliArgs.tierFilter) {
     const allowed = TIER_LETTER_MAP[cliArgs.tierFilter]
@@ -858,8 +893,35 @@ export async function runApp(cliArgs, config) {
     process.stdin.setRawMode(true)
   }
 
+  // 📖 Mouse sequence suppression: readline.emitKeypressEvents() registers its own
+  // 📖 internal `data` listener that parses bytes and fires `keypress` events.
+  // 📖 When a mouse SGR sequence like \x1b[<0;35;20m arrives, readline fragments it
+  // 📖 and emits individual keypress events for chars like 'm', '0', ';' etc.
+  // 📖 The 'm' at the end of a release event maps to the Model sort hotkey!
+  // 📖
+  // 📖 Fix: use prependListener to register a `data` handler BEFORE readline's,
+  // 📖 so we can set a suppression flag before any keypress events fire.
+  // 📖 The flag is cleared on the next tick via setImmediate after all synchronous
+  // 📖 keypress emissions from readline have completed.
+  let _suppressMouseKeypresses = false
+
+  process.stdin.prependListener('data', (data) => {
+    const str = typeof data === 'string' ? data : data.toString('utf8')
+    if (str.includes('\x1b[<')) {
+      _suppressMouseKeypresses = true
+      // 📖 Reset after current tick — all synchronous keypress events from this data
+      // 📖 chunk will have fired by then.
+      setImmediate(() => { _suppressMouseKeypresses = false })
+    }
+  })
+
   process.stdin.on('keypress', async (str, key) => {
     try {
+      // 📖 Skip keypress events that originate from mouse escape sequences.
+      // 📖 readline may partially parse SGR mouse sequences as garbage keypresses.
+      if (str && containsMouseSequence(str)) return
+      // 📖 Suppress fragmented mouse bytes that readline emits as individual keypresses.
+      if (_suppressMouseKeypresses) return
       await onKeyPress(str, key);
     } catch (err) {
       process.stdout.write(ALT_LEAVE);
@@ -869,6 +931,18 @@ export async function runApp(cliArgs, config) {
       process.exit(1);
     }
   })
+
+  // 📖 Mouse data listener: parses SGR mouse escape sequences from raw stdin
+  // 📖 and dispatches structured events (click, scroll, double-click) to the mouse handler.
+  process.stdin.on('data', (data) => {
+    try {
+      if (onMouseData) onMouseData(data)
+    } catch (err) {
+      // 📖 Mouse errors are non-fatal — log and continue so the TUI doesn't crash.
+      // 📖 This could happen on terminals that send unexpected mouse sequences.
+    }
+  })
+
   process.on('SIGCONT', noteUserActivity)
 
   // 📖 Animation loop: render settings overlay, recommend overlay, help overlay, feature request overlay, bug report overlay, changelog overlay, OR main table

package/src/constants.js

@@ -47,8 +47,11 @@ import chalk from 'chalk'
 // 📖 \x1b[H      = cursor to top
 // 📖 \x1b[?7l disables auto-wrap so wide rows clip at the right edge instead of
 // 📖 wrapping to the next line (which would double the row height and overflow).
-export const ALT_ENTER = '\x1b[?1049h\x1b[?25l\x1b[?7l'
-export const ALT_LEAVE = '\x1b[?7h\x1b[?1049l\x1b[?25h'
+// 📖 Mouse tracking sequences are appended/prepended so clicks and scroll work in the TUI.
+import { MOUSE_ENABLE, MOUSE_DISABLE } from './mouse.js'
+
+export const ALT_ENTER = '\x1b[?1049h\x1b[?25l\x1b[?7l' + MOUSE_ENABLE
+export const ALT_LEAVE = MOUSE_DISABLE + '\x1b[?7h\x1b[?1049l\x1b[?25h'
 export const ALT_HOME  = '\x1b[H'
 
 // 📖 Timing constants — control how fast the health-check loop runs.

package/src/key-handler.js

@@ -31,6 +31,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 { getLastLayout, COLUMN_SORT_MAP } from './render-table.js'
 import { cycleThemeSetting, detectActiveTheme } from './theme.js'
 import { buildCommandPaletteTree, flattenCommandTree, filterCommandPaletteEntries } from './command-palette.js'
 import { WIDTH_WARNING_MIN_COLS } from './constants.js'
@@ -2157,3 +2158,412 @@ export function createKeyHandler(ctx) {
     }
   }
 }
+
+/**
+ * 📖 createMouseEventHandler: Factory that returns a handler for structured mouse events.
+ * 📖 Works alongside the keypress handler — shares the same state and action functions.
+ *
+ * 📖 Supported interactions:
+ *   - Click on header row column → sort by that column (or cycle tier filter for Tier column)
+ *   - Click on model row → move cursor to that row
+ *   - Double-click on model row → select the model (Enter)
+ *   - Scroll up/down → navigate cursor up/down (with wrap-around)
+ *   - Scroll in overlays → scroll overlay content
+ *
+ * @param {object} ctx — same context object passed to createKeyHandler
+ * @returns {function} — callback for onMouseEvent in createMouseHandler()
+ */
+export function createMouseEventHandler(ctx) {
+  const {
+    state,
+    adjustScrollOffset,
+    applyTierFilter,
+    TIER_CYCLE,
+    noteUserActivity,
+    sortResultsWithPinnedFavorites,
+    saveConfig,
+    overlayLayout,
+    // 📖 Favorite toggle deps — used by right-click on model rows
+    toggleFavoriteModel,
+    syncFavoriteFlags,
+    toFavoriteKey,
+    // 📖 Tool mode cycling — used by compat column header click
+    cycleToolMode,
+  } = ctx
+
+  // 📖 Shared helper: set the sort column, toggling direction if same column clicked twice.
+  function setSortColumnFromClick(col) {
+    if (state.sortColumn === col) {
+      state.sortDirection = state.sortDirection === 'asc' ? 'desc' : 'asc'
+    } else {
+      state.sortColumn = col
+      state.sortDirection = 'asc'
+    }
+    // 📖 Recompute visible sorted list to reflect new sort order
+    const visible = state.results.filter(r => !r.hidden)
+    state.visibleSorted = sortResultsWithPinnedFavorites(visible, state.sortColumn, state.sortDirection, {
+      pinFavorites: state.favoritesPinnedAndSticky,
+    })
+  }
+
+  // 📖 Shared helper: persist UI settings after mouse-triggered changes
+  function persistUiSettings() {
+    if (!state.config) return
+    if (!state.config.settings || typeof state.config.settings !== 'object') state.config.settings = {}
+    state.config.settings.sortColumn = state.sortColumn
+    state.config.settings.sortDirection = state.sortDirection
+    state.config.settings.tierFilter = TIER_CYCLE[state.tierFilterMode] || null
+  }
+
+  // 📖 Shared helper: toggle favorite on a specific model row index.
+  // 📖 Mirrors the keyboard F-key handler but operates at a given index.
+  function toggleFavoriteAtRow(modelIdx) {
+    const selected = state.visibleSorted[modelIdx]
+    if (!selected) return
+    const wasFavorite = selected.isFavorite
+    toggleFavoriteModel(state.config, selected.providerKey, selected.modelId)
+    syncFavoriteFlags(state.results, state.config)
+    applyTierFilter()
+    const visible = state.results.filter(r => !r.hidden)
+    state.visibleSorted = sortResultsWithPinnedFavorites(visible, state.sortColumn, state.sortDirection, {
+      pinFavorites: state.favoritesPinnedAndSticky,
+    })
+    // 📖 If we unfavorited while pinned mode is on, reset cursor to top
+    if (wasFavorite && state.favoritesPinnedAndSticky) {
+      state.cursor = 0
+      state.scrollOffset = 0
+      return
+    }
+    // 📖 Otherwise, track the model's new position after re-sort
+    const selectedKey = toFavoriteKey(selected.providerKey, selected.modelId)
+    const newCursor = state.visibleSorted.findIndex(r => toFavoriteKey(r.providerKey, r.modelId) === selectedKey)
+    if (newCursor >= 0) state.cursor = newCursor
+    adjustScrollOffset(state)
+  }
+
+  // 📖 Shared helper: map a terminal row (1-based) to a cursor index using
+  // 📖 an overlay's cursorLineByRow map and scroll offset.
+  // 📖 Returns the cursor index, or -1 if no match.
+  function overlayRowToCursor(y, cursorToLineMap, scrollOffset) {
+    // 📖 Terminal row Y (1-based) → line index in the overlay lines array.
+    // 📖 sliceOverlayLines shows lines from [scrollOffset .. scrollOffset + terminalRows).
+    // 📖 Terminal row 1 = line[scrollOffset], row 2 = line[scrollOffset+1], etc.
+    const lineIdx = (y - 1) + scrollOffset
+    for (const [cursorStr, lineNum] of Object.entries(cursorToLineMap)) {
+      if (lineNum === lineIdx) return parseInt(cursorStr, 10)
+    }
+    return -1
+  }
+
+  return (evt) => {
+    noteUserActivity()
+    const layout = getLastLayout()
+
+    // ── Scroll events ──────────────────────────────────────────────────
+    if (evt.type === 'scroll-up' || evt.type === 'scroll-down') {
+      // 📖 Overlay scroll: if any overlay is open, scroll its content
+      if (state.helpVisible) {
+        const step = evt.type === 'scroll-up' ? -3 : 3
+        state.helpScrollOffset = Math.max(0, (state.helpScrollOffset || 0) + step)
+        return
+      }
+      if (state.changelogOpen) {
+        const step = evt.type === 'scroll-up' ? -3 : 3
+        state.changelogScrollOffset = Math.max(0, (state.changelogScrollOffset || 0) + step)
+        return
+      }
+      if (state.settingsOpen) {
+        // 📖 Settings overlay uses cursor navigation, not scroll offset.
+        // 📖 Move settingsCursor up/down instead of scrolling.
+        if (evt.type === 'scroll-up') {
+          state.settingsCursor = Math.max(0, (state.settingsCursor || 0) - 1)
+        } else {
+          const max = overlayLayout?.settingsMaxRow ?? 99
+          state.settingsCursor = Math.min(max, (state.settingsCursor || 0) + 1)
+        }
+        return
+      }
+      if (state.recommendOpen) {
+        // 📖 Recommend questionnaire phase: scroll moves cursor through options
+        if (state.recommendPhase === 'questionnaire') {
+          const step = evt.type === 'scroll-up' ? -1 : 1
+          state.recommendCursor = Math.max(0, (state.recommendCursor || 0) + step)
+        } else {
+          const step = evt.type === 'scroll-up' ? -1 : 1
+          state.recommendScrollOffset = Math.max(0, (state.recommendScrollOffset || 0) + step)
+        }
+        return
+      }
+      if (state.feedbackOpen) {
+        // 📖 Feedback overlay doesn't scroll — ignore
+        return
+      }
+      if (state.commandPaletteOpen) {
+        // 📖 Command palette: scroll the results list
+        const count = state.commandPaletteResults?.length || 0
+        if (count === 0) return
+        if (evt.type === 'scroll-up') {
+          state.commandPaletteCursor = state.commandPaletteCursor > 0 ? state.commandPaletteCursor - 1 : count - 1
+        } else {
+          state.commandPaletteCursor = state.commandPaletteCursor < count - 1 ? state.commandPaletteCursor + 1 : 0
+        }
+        return
+      }
+      if (state.installEndpointsOpen) {
+        // 📖 Install endpoints: move cursor up/down
+        if (evt.type === 'scroll-up') {
+          state.installEndpointsCursor = Math.max(0, (state.installEndpointsCursor || 0) - 1)
+        } else {
+          state.installEndpointsCursor = (state.installEndpointsCursor || 0) + 1
+        }
+        return
+      }
+      if (state.toolInstallPromptOpen) {
+        // 📖 Tool install prompt: move cursor up/down
+        if (evt.type === 'scroll-up') {
+          state.toolInstallPromptCursor = Math.max(0, (state.toolInstallPromptCursor || 0) - 1)
+        } else {
+          state.toolInstallPromptCursor = (state.toolInstallPromptCursor || 0) + 1
+        }
+        return
+      }
+
+      // 📖 Main table scroll: move cursor up/down with wrap-around
+      const count = state.visibleSorted.length
+      if (count === 0) return
+      if (evt.type === 'scroll-up') {
+        state.cursor = state.cursor > 0 ? state.cursor - 1 : count - 1
+      } else {
+        state.cursor = state.cursor < count - 1 ? state.cursor + 1 : 0
+      }
+      adjustScrollOffset(state)
+      return
+    }
+
+    // ── Click / double-click events ────────────────────────────────────
+    if (evt.type !== 'click' && evt.type !== 'double-click') return
+
+    const { x, y } = evt
+
+    // ── Overlay click handling ─────────────────────────────────────────
+    // 📖 When an overlay is open, handle clicks inside it or close it.
+    // 📖 Priority order matches the rendering priority in app.js.
+
+    if (state.commandPaletteOpen) {
+      // 📖 Command palette is a floating modal — detect clicks inside vs outside.
+      const cp = overlayLayout
+      const insideModal = cp &&
+        x >= (cp.commandPaletteLeft || 0) && x <= (cp.commandPaletteRight || 0) &&
+        y >= (cp.commandPaletteTop || 0) && y <= (cp.commandPaletteBottom || 0)
+
+      if (insideModal) {
+        // 📖 Check if click is in the body area (result rows)
+        const bodyStart = cp.commandPaletteBodyStartRow || 0
+        const bodyEnd = bodyStart + (cp.commandPaletteBodyRows || 0) - 1
+        if (y >= bodyStart && y <= bodyEnd) {
+          // 📖 Map terminal row → cursor index via the cursorToLine map + scroll offset
+          const cursorIdx = overlayRowToCursor(
+            y - bodyStart + 1, // 📖 Normalize: row within body → 1-based for overlayRowToCursor
+            cp.commandPaletteCursorToLine,
+            cp.commandPaletteScrollOffset
+          )
+          if (cursorIdx >= 0) {
+            state.commandPaletteCursor = cursorIdx
+            if (evt.type === 'double-click') {
+              // 📖 Double-click executes the selected command (same as Enter)
+              process.stdin.emit('keypress', '\r', { name: 'return', ctrl: false, meta: false, shift: false })
+            }
+            return
+          }
+        }
+        // 📖 Click inside modal but not on a result row — ignore (don't close)
+        return
+      }
+
+      // 📖 Click outside the modal → close (Escape equivalent)
+      state.commandPaletteOpen = false
+      state.commandPaletteFrozenTable = null
+      state.commandPaletteQuery = ''
+      state.commandPaletteCursor = 0
+      state.commandPaletteScrollOffset = 0
+      state.commandPaletteResults = []
+      return
+    }
+
+    if (state.installEndpointsOpen) {
+      // 📖 Install endpoints overlay: click closes (Escape equivalent)
+      state.installEndpointsOpen = false
+      return
+    }
+
+    if (state.toolInstallPromptOpen) {
+      // 📖 Tool install prompt: click closes (Escape equivalent)
+      state.toolInstallPromptOpen = false
+      return
+    }
+
+    if (state.incompatibleFallbackOpen) {
+      // 📖 Incompatible fallback: click closes
+      state.incompatibleFallbackOpen = false
+      return
+    }
+
+    if (state.feedbackOpen) {
+      // 📖 Feedback overlay: click anywhere closes (no scroll, no cursor)
+      state.feedbackOpen = false
+      state.feedbackInput = ''
+      return
+    }
+
+    if (state.helpVisible) {
+      // 📖 Help overlay: click anywhere closes (same as K or Escape)
+      state.helpVisible = false
+      return
+    }
+
+    if (state.changelogOpen) {
+      // 📖 Changelog overlay: click on a version row selects it, otherwise close.
+      if (overlayLayout && state.changelogPhase === 'index') {
+        const cursorIdx = overlayRowToCursor(
+          y,
+          overlayLayout.changelogCursorToLine,
+          overlayLayout.changelogScrollOffset
+        )
+        if (cursorIdx >= 0) {
+          state.changelogCursor = cursorIdx
+          // 📖 Double-click opens the selected version's details (same as Enter)
+          if (evt.type === 'double-click') {
+            process.stdin.emit('keypress', '\r', { name: 'return', ctrl: false, meta: false, shift: false })
+          }
+          return
+        }
+      }
+      // 📖 Click outside version list → close (Escape equivalent)
+      // 📖 In details phase, click anywhere goes back (same as B key)
+      if (state.changelogPhase === 'details') {
+        state.changelogPhase = 'index'
+        state.changelogScrollOffset = 0
+      } else {
+        state.changelogOpen = false
+      }
+      return
+    }
+
+    if (state.recommendOpen) {
+      if (state.recommendPhase === 'questionnaire' && overlayLayout?.recommendOptionRows) {
+        // 📖 Map click Y to the specific questionnaire option row
+        const optRows = overlayLayout.recommendOptionRows
+        for (const [idxStr, row] of Object.entries(optRows)) {
+          if (y === row) {
+            state.recommendCursor = parseInt(idxStr, 10)
+            if (evt.type === 'double-click') {
+              // 📖 Double-click confirms the option (same as Enter)
+              process.stdin.emit('keypress', '\r', { name: 'return', ctrl: false, meta: false, shift: false })
+            }
+            return
+          }
+        }
+        // 📖 Click outside option rows in questionnaire — ignore (don't close)
+        return
+      }
+      // 📖 Result phase: click closes. Analyzing phase: click does nothing.
+      if (state.recommendPhase === 'results') {
+        state.recommendOpen = false
+        state.recommendPhase = null
+        state.recommendResults = []
+        state.recommendScrollOffset = 0
+      }
+      return
+    }
+
+    if (state.settingsOpen) {
+      // 📖 Settings overlay: click on a provider/maintenance row moves cursor there.
+      // 📖 Don't handle clicks during edit/add-key mode (keyboard is primary).
+      if (state.settingsEditMode || state.settingsAddKeyMode) return
+
+      if (overlayLayout) {
+        const cursorIdx = overlayRowToCursor(
+          y,
+          overlayLayout.settingsCursorToLine,
+          overlayLayout.settingsScrollOffset
+        )
+        if (cursorIdx >= 0 && cursorIdx <= (overlayLayout.settingsMaxRow || 99)) {
+          state.settingsCursor = cursorIdx
+          // 📖 Double-click triggers the Enter action (edit key / toggle / run action)
+          if (evt.type === 'double-click') {
+            process.stdin.emit('keypress', '\r', { name: 'return', ctrl: false, meta: false, shift: false })
+          }
+          return
+        }
+      }
+      // 📖 Click outside any recognized row does nothing in Settings
+      // 📖 (user can Escape or press P to close)
+      return
+    }
+
+    // ── Main table click handling ──────────────────────────────────────
+    // 📖 No overlay is open — clicks go to the main table.
+
+    // 📖 Check if click is on the column header row → trigger sort
+    if (y === layout.headerRow) {
+      const col = layout.columns.find(c => x >= c.xStart && x <= c.xEnd)
+      if (col) {
+        const sortKey = COLUMN_SORT_MAP[col.name]
+        if (sortKey) {
+          setSortColumnFromClick(sortKey)
+          persistUiSettings()
+        } else if (col.name === 'tier') {
+          // 📖 Clicking the Tier header cycles the tier filter (same as T key)
+          state.tierFilterMode = (state.tierFilterMode + 1) % TIER_CYCLE.length
+          applyTierFilter()
+          const visible = state.results.filter(r => !r.hidden)
+          state.visibleSorted = sortResultsWithPinnedFavorites(visible, state.sortColumn, state.sortDirection, {
+            pinFavorites: state.favoritesPinnedAndSticky,
+          })
+          state.cursor = 0
+          state.scrollOffset = 0
+          persistUiSettings()
+        }
+      }
+      return
+    }
+
+    // 📖 Check if click is on a model row → move cursor (or select on double-click)
+    // 📖 Right-click toggles favorite on that row (same as F key)
+    if (y >= layout.firstModelRow && y <= layout.lastModelRow) {
+      const rowOffset = y - layout.firstModelRow
+      const modelIdx = layout.viewportStartIdx + rowOffset
+      if (modelIdx >= layout.viewportStartIdx && modelIdx < layout.viewportEndIdx) {
+        state.cursor = modelIdx
+        adjustScrollOffset(state)
+
+        if (evt.button === 'right') {
+          // 📖 Right-click: toggle favorite on this model row
+          toggleFavoriteAtRow(modelIdx)
+        } else if (evt.type === 'double-click') {
+          // 📖 Double-click triggers the Enter action (select model).
+          process.stdin.emit('keypress', '\r', { name: 'return', ctrl: false, meta: false, shift: false })
+        }
+      }
+      return
+    }
+
+    // ── Footer hotkey click zones ──────────────────────────────────────
+    // 📖 Check if click lands on a footer hotkey zone and emit the corresponding keypress.
+    if (layout.footerHotkeys && layout.footerHotkeys.length > 0) {
+      const zone = layout.footerHotkeys.find(z => y === z.row && x >= z.xStart && x <= z.xEnd)
+      if (zone) {
+        // 📖 Map the footer zone key to a synthetic keypress.
+        // 📖 Most are single-character keys; special cases like ctrl+p need special handling.
+        if (zone.key === 'ctrl+p') {
+          process.stdin.emit('keypress', '\x10', { name: 'p', ctrl: true, meta: false, shift: false })
+        } else {
+          process.stdin.emit('keypress', zone.key, { name: zone.key, ctrl: false, meta: false, shift: false })
+        }
+        return
+      }
+    }
+
+    // 📖 Clicks outside any recognized zone are silently ignored.
+  }
+}

package/src/mouse.js

@@ -0,0 +1,186 @@
+/**
+ * @file mouse.js
+ * @description Terminal mouse tracking infrastructure for the TUI.
+ *
+ * @details
+ *   Provides SGR (mode 1006) mouse event parsing and tracking enable/disable sequences.
+ *   SGR mode is preferred over X10/normal because it supports coordinates > 223
+ *   and distinguishes press vs release events cleanly.
+ *
+ *   Mouse events arrive as raw escape sequences on stdin when tracking is enabled:
+ *     Press:   \x1b[<Btn;X;YM
+ *     Release: \x1b[<Btn;X;Ym
+ *
+ *   Button encoding (Btn field):
+ *     0 = left click, 1 = middle click, 2 = right click
+ *     32 = left drag, 33 = middle drag, 34 = right drag
+ *     64 = scroll up, 65 = scroll down
+ *     +4 = Shift held, +8 = Meta/Alt held, +16 = Control held
+ *
+ *   Coordinates are 1-based in SGR mode (col 1, row 1 = top-left).
+ *
+ *   ⚙️ Key configuration:
+ *   - MOUSE_ENABLE: appended to ALT_ENTER to start mouse tracking on TUI init
+ *   - MOUSE_DISABLE: prepended to ALT_LEAVE to stop mouse tracking on TUI exit
+ *   - DOUBLE_CLICK_MS: maximum gap between two clicks to count as double-click
+ *
+ * @functions
+ *   → parseMouseEvent(data)      — Parse raw stdin buffer into structured mouse event
+ *   → createMouseHandler(opts)   — Create a stdin 'data' listener that emits mouse events
+ *
+ * @exports
+ *   MOUSE_ENABLE, MOUSE_DISABLE,
+ *   parseMouseEvent, createMouseHandler
+ *
+ * @see src/app.js          — wires the mouse data listener alongside keypress
+ * @see src/key-handler.js  — receives parsed mouse events for UI actions
+ * @see src/constants.js    — ALT_ENTER / ALT_LEAVE include mouse sequences
+ */
+
+// 📖 SGR mouse mode (1006) sends coordinates as decimal numbers terminated by M/m,
+// 📖 supporting terminals wider than 223 columns (unlike X10 mode).
+// 📖 Mode 1000 = basic button tracking (press + release).
+// 📖 Mode 1002 = button-event tracking (adds drag reporting).
+// 📖 Mode 1003 = any-event tracking (adds mouse movement) — intentionally NOT used
+// 📖 because movement floods stdin and we don't need hover.
+export const MOUSE_ENABLE  = '\x1b[?1000h\x1b[?1002h\x1b[?1006h'
+export const MOUSE_DISABLE = '\x1b[?1006l\x1b[?1002l\x1b[?1000l'
+
+// 📖 Double-click detection window in milliseconds.
+const DOUBLE_CLICK_MS = 400
+
+// 📖 Regex to match SGR mouse sequences: \x1b[<Btn;Col;Row[Mm]
+// 📖 Groups: 1=button, 2=column(x), 3=row(y), 4=M(press)|m(release)
+const SGR_MOUSE_RE = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/g
+
+/**
+ * 📖 parseMouseEvents: Extract all SGR mouse events from a raw stdin data chunk.
+ * 📖 A single data chunk can contain multiple mouse events (e.g. rapid scrolling).
+ * @param {string|Buffer} data — raw stdin data
+ * @returns {Array<{button: number, x: number, y: number, type: string, shift: boolean, meta: boolean, ctrl: boolean}>}
+ */
+export function parseMouseEvents(data) {
+  const str = typeof data === 'string' ? data : data.toString('utf8')
+  const events = []
+  let match
+
+  // 📖 Reset regex lastIndex for reuse
+  SGR_MOUSE_RE.lastIndex = 0
+
+  while ((match = SGR_MOUSE_RE.exec(str)) !== null) {
+    const rawBtn = parseInt(match[1], 10)
+    const x = parseInt(match[2], 10) // 📖 1-based column
+    const y = parseInt(match[3], 10) // 📖 1-based row
+    const isRelease = match[4] === 'm'
+
+    // 📖 Extract modifier keys from the button field
+    const shift = !!(rawBtn & 4)
+    const meta  = !!(rawBtn & 8)
+    const ctrl  = !!(rawBtn & 16)
+
+    // 📖 Strip modifier bits to get the base button
+    const baseBtn = rawBtn & ~(4 | 8 | 16)
+
+    let type, button
+
+    if (baseBtn === 64) {
+      type = 'scroll-up'
+      button = 'scroll-up'
+    } else if (baseBtn === 65) {
+      type = 'scroll-down'
+      button = 'scroll-down'
+    } else if (baseBtn >= 32 && baseBtn <= 34) {
+      type = 'drag'
+      button = baseBtn === 32 ? 'left' : baseBtn === 33 ? 'middle' : 'right'
+    } else if (isRelease) {
+      type = 'release'
+      button = baseBtn === 0 ? 'left' : baseBtn === 1 ? 'middle' : 'right'
+    } else {
+      type = 'press'
+      button = baseBtn === 0 ? 'left' : baseBtn === 1 ? 'middle' : 'right'
+    }
+
+    events.push({ type, button, x, y, shift, meta, ctrl })
+  }
+
+  return events
+}
+
+/**
+ * 📖 containsMouseSequence: Quick check if a data chunk contains any SGR mouse sequence.
+ * 📖 Used to prevent the keypress handler from processing mouse data as keypresses.
+ * @param {string|Buffer} data
+ * @returns {boolean}
+ */
+export function containsMouseSequence(data) {
+  const str = typeof data === 'string' ? data : data.toString('utf8')
+  return str.includes('\x1b[<')
+}
+
+/**
+ * 📖 createMouseHandler: Factory that returns a stdin 'data' callback for mouse events.
+ * 📖 Handles double-click detection internally by tracking the last click position/time.
+ *
+ * @param {object} opts
+ * @param {function} opts.onMouseEvent — callback receiving structured mouse events:
+ *   { type: 'click'|'double-click'|'scroll-up'|'scroll-down'|'drag', button, x, y, shift, meta, ctrl }
+ * @returns {function} — attach to process.stdin.on('data', returnedFn)
+ */
+export function createMouseHandler({ onMouseEvent }) {
+  // 📖 Double-click tracking state
+  let lastClickX = -1
+  let lastClickY = -1
+  let lastClickTime = 0
+
+  return (data) => {
+    const str = typeof data === 'string' ? data : data.toString('utf8')
+
+    // 📖 Only process data that contains mouse sequences
+    if (!str.includes('\x1b[<')) return
+
+    const events = parseMouseEvents(str)
+
+    for (const evt of events) {
+      // 📖 Scroll events are emitted immediately (no press/release distinction)
+      if (evt.type === 'scroll-up' || evt.type === 'scroll-down') {
+        onMouseEvent(evt)
+        continue
+      }
+
+      // 📖 Drag events forwarded as-is
+      if (evt.type === 'drag') {
+        onMouseEvent(evt)
+        continue
+      }
+
+      // 📖 Only emit click on release (not press) to match expected click semantics.
+      // 📖 This prevents double-firing and feels more natural to the user.
+      if (evt.type === 'release' && evt.button === 'left') {
+        const now = Date.now()
+        const isDoubleClick =
+          (now - lastClickTime) < DOUBLE_CLICK_MS &&
+          evt.x === lastClickX &&
+          evt.y === lastClickY
+
+        if (isDoubleClick) {
+          onMouseEvent({ ...evt, type: 'double-click' })
+          // 📖 Reset so a third click doesn't count as another double-click
+          lastClickTime = 0
+          lastClickX = -1
+          lastClickY = -1
+        } else {
+          onMouseEvent({ ...evt, type: 'click' })
+          lastClickTime = now
+          lastClickX = evt.x
+          lastClickY = evt.y
+        }
+        continue
+      }
+
+      // 📖 Right-click and middle-click: emit on release
+      if (evt.type === 'release') {
+        onMouseEvent({ ...evt, type: 'click' })
+      }
+    }
+  }
+}

package/src/overlays.js

@@ -14,7 +14,7 @@
  *   📖 Feedback overlay (I key) combines feature requests + bug reports in one left-aligned input
  *
  *   → Functions:
- *   - `createOverlayRenderers` — returns renderer + analysis helpers
+ *   - `createOverlayRenderers` — returns renderer + analysis helpers + overlayLayout
  *
  * @exports { createOverlayRenderers }
  * @see ./key-handler.js — handles keypresses for all overlay interactions
@@ -85,6 +85,29 @@ export function createOverlayRenderers(state, deps) {
     return lines
   }
 
+  // 📖 Overlay layout tracking: records cursor-to-line mappings and scroll offsets
+  // 📖 so the mouse handler can map terminal click coordinates → overlay cursor positions.
+  // 📖 Updated each render frame by the active overlay renderer.
+  const overlayLayout = {
+    settingsCursorToLine: {},   // 📖 cursor index → line index in pre-scroll lines array
+    settingsScrollOffset: 0,   // 📖 current scroll offset applied by sliceOverlayLines
+    settingsMaxRow: 0,         // 📖 maximum valid settingsCursor index
+    installEndpointsCursorToLine: {},
+    installEndpointsScrollOffset: 0,
+    installEndpointsMaxRow: 0,
+    commandPaletteCursorToLine: {},
+    commandPaletteScrollOffset: 0,
+    commandPaletteBodyStartRow: 0, // 📖 1-based terminal row where CP results begin
+    commandPaletteBodyRows: 0,
+    commandPaletteLeft: 0,
+    commandPaletteRight: 0,
+    commandPaletteTop: 0,
+    commandPaletteBottom: 0,
+    changelogCursorToLine: {},
+    changelogScrollOffset: 0,
+    recommendOptionRows: {},       // 📖 option index → 1-based terminal row (questionnaire phase)
+  }
+
   // ─── Settings screen renderer ─────────────────────────────────────────────
   // 📖 renderSettings: Draw the settings overlay in the alt screen buffer.
   // 📖 Shows all providers with their API key (masked) + enabled state.
@@ -287,6 +310,11 @@ export function createOverlayRenderers(state, deps) {
     const { visible, offset } = sliceOverlayLines(lines, state.settingsScrollOffset, state.terminalRows)
     state.settingsScrollOffset = offset
 
+    // 📖 Mouse support: record layout so click handler can map Y → settingsCursor
+    overlayLayout.settingsCursorToLine = { ...cursorLineByRow }
+    overlayLayout.settingsScrollOffset = offset
+    overlayLayout.settingsMaxRow = changelogViewRowIdx
+
     const tintedLines = tintOverlayLines(visible, themeColors.overlayBgSettings, state.terminalCols)
     const cleared = tintedLines.map(l => l + EL)
     return cleared.join('\n')
@@ -684,6 +712,18 @@ export function createOverlayRenderers(state, deps) {
     const top = Math.max(1, Math.floor((terminalRows - panelHeight) / 2) + 1)
     const left = Math.max(1, Math.floor((terminalCols - panelOuterWidth) / 2) + 1)
 
+    // 📖 Mouse support: record CP layout so clicks inside the modal can select items.
+    // 📖 Body rows start after 2 blank-padding lines + headerLines (3).
+    const bodyStartRow = top + 2 + headerLines.length // 📖 1-based terminal row of first body line
+    overlayLayout.commandPaletteCursorToLine = { ...cursorLineByRow }
+    overlayLayout.commandPaletteScrollOffset = state.commandPaletteScrollOffset
+    overlayLayout.commandPaletteBodyStartRow = bodyStartRow
+    overlayLayout.commandPaletteBodyRows = bodyRows
+    overlayLayout.commandPaletteLeft = left
+    overlayLayout.commandPaletteRight = left + panelOuterWidth - 1
+    overlayLayout.commandPaletteTop = top
+    overlayLayout.commandPaletteBottom = top + panelHeight - 1
+
     const tintedLines = paddedPanelLines.map((line) => {
       const padded = padEndDisplay(line, panelOuterWidth)
       return themeColors.overlayBgCommandPalette(padded)
@@ -861,6 +901,10 @@ export function createOverlayRenderers(state, deps) {
         const opt = q.options[i]
         const isCursor = i === state.recommendCursor
         const label = isCursor ? themeColors.textBold(opt.label) : themeColors.text(opt.label)
+        // 📖 Mouse support: record the 1-based terminal row of each option
+        // 📖 lines.length is the 0-based index → +1 = 1-based row
+        overlayLayout.recommendOptionRows = overlayLayout.recommendOptionRows || {}
+        overlayLayout.recommendOptionRows[i] = lines.length + 1
         lines.push(`${bullet(isCursor)}${label}`)
       }
 
@@ -1206,6 +1250,21 @@ export function createOverlayRenderers(state, deps) {
     // 📖 Use scrolling with overlay handler
     const { visible, offset } = sliceOverlayLines(lines, state.changelogScrollOffset, state.terminalRows)
     state.changelogScrollOffset = offset
+
+    // 📖 Mouse support: record changelog layout for click-to-select versions
+    overlayLayout.changelogScrollOffset = offset
+    // 📖 In index phase, version items start at line 4 (header + blank + title + instructions)
+    // 📖 Each version occupies exactly one line. changelogCursorToLine maps cursor → line index.
+    if (state.changelogPhase === 'index') {
+      const map = {}
+      for (let i = 0; i < versionList.length; i++) {
+        map[i] = 4 + i // 📖 3 header-ish lines + 1 blank before version list
+      }
+      overlayLayout.changelogCursorToLine = map
+    } else {
+      overlayLayout.changelogCursorToLine = {}
+    }
+
     const tintedLines = tintOverlayLines(visible, themeColors.overlayBgChangelog, state.terminalCols)
     const cleared = tintedLines.map(l => l + EL)
     return cleared.join('\n')
@@ -1325,5 +1384,6 @@ export function createOverlayRenderers(state, deps) {
     renderIncompatibleFallback,
     startRecommendAnalysis,
     stopRecommendAnalysis,
+    overlayLayout,  // 📖 Mouse support: exposes cursor-to-line maps for click handling
   }
 }

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, TOOL_METADATA, TOOL_MODE_ORDER, COMPAT_COLUMN_SLOTS, getCompatibleTools, isModelCompatibleWithTool } 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.
@@ -160,7 +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_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
@@ -180,7 +215,6 @@ 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) {
@@ -192,7 +226,6 @@ 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
     }
 
@@ -206,12 +239,39 @@ 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
     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)
@@ -268,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'
@@ -278,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
@@ -326,14 +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)
   })()
-  // 📖 "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 = []
@@ -342,9 +397,12 @@ 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))
 
+  // 📖 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) {
@@ -376,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))
@@ -601,28 +667,6 @@ 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)
 
@@ -637,7 +681,6 @@ 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) {
@@ -656,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 ...`))
   }
@@ -670,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(`  •  `) +
@@ -684,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 ')
@@ -745,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