free-coding-models 0.3.25 → 0.3.26

package/CHANGELOG.md

@@ -1,11 +1,56 @@
 # Changelog
 ---
 
+## [0.3.26] - 2026-03-27
+
+### Added
+- **Groq**: Added Compound + Compound Mini; fixed Llama 4 Scout context (10M)
+- **OpenRouter**: Added MiniMax M2.5, Nemotron 3 Super, Hermes 3 405B, Gemma 3n E4B
+- **HuggingFace**: Replaced invalid DeepSeek-V3-Coder + outdated starcoder2-15b with DeepSeek V3 0324 + Qwen2.5 Coder 32B
+- **Replicate**: Replaced CodeLlama 70B (2023) with DeepSeek V3 0324 + Llama 3.3 70B
+- **Cloudflare**: Added Kimi K2.5, GLM-4.7-Flash, Llama 4 Scout, Nemotron 3 Super, Qwen3 30B MoE
+- **Scaleway**: Added Qwen3.5 400B VLM + Mistral Large 675B
+- **DeepInfra**: Replaced Mixtral Code with Nemotron 3 Super + DeepSeek V3 0324 + Qwen3 235B
+- **Fireworks**: Added Llama 4 Maverick + Qwen3 235B
+- **Hyperbolic**: Added Qwen3 80B Thinking variant
+- **Together AI**: Added Qwen3.5 400B VLM, MiniMax M2.5, GLM-5
+
+### Changed
+- **Rovo Dev CLI**: Updated Sonnet 4 → Sonnet 4.6, added Opus 4.6
+- **Groq**: Removed 4 deprecated models (R1 Distill 70B, QwQ 32B, Kimi K2, Maverick)
+- **OpenRouter**: Updated context sizes for multiple models
+
 ## [0.3.25] - 2026-03-19
 
+### Added
+- **Installed Models Manager** — View, launch, and disable models configured in external tools (Goose, Crush, Aider, Qwen, Pi, OpenHands, Amp)
+  - Access via Command Palette (Ctrl+P) → "Installed models"
+  - Scans all supported tool configs automatically on opening
+  - Displays all models per tool (e.g., Crush shows both large and small models)
+  - Actions: Launch (Enter), Disable (D) with backup, Reinstall (R)
+  - Soft delete: Comments out model entries and saves backups to ~/.free-coding-models-backups.json
+- **Full mouse support for the TUI** — Click, right-click, double-click, and scroll work throughout the interface
+  - **Click column headers** — Sort by any column (click Rank, Tier, SWE%, CTX, Model, Provider, etc.)
+  - **Click model rows** — Move cursor to any model (left-click)
+  - **Right-click model rows** — Toggle favorite (same as F key)
+  - **Double-click model rows** — Select model and launch (same as Enter)
+  - **Mouse wheel** — Scroll through the main table, overlays (Settings, Help, Changelog), and command palette results
+  - **Click CLI Tools header** — Cycle through tool modes (same as Z key)
+  - **Click Tier header** — Cycle through tier filters (same as T key)
+  - **Click footer hotkeys** — Trigger any visible hotkey from the footer
+  - **Command palette click** — Click inside to select items, double-click to confirm; click outside to close
+  - **Recommend questionnaire click** — Click on option rows to select, double-click to confirm
+- **Mouse unit tests** — 46 new tests covering SGR sequence parsing, double-click detection, modifiers, and COLUMN_SORT_MAP validation
+
 ### 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
+- **CLI Tools column redesigned** — Renamed from "Compatible with" to "CLI Tools", with left-aligned emoji display (compatible tools packed left instead of fixed slot positions)
+- **Sort arrow overflow fixed** — SWE%, CTX, Stability, and Uptime columns now properly fit within their widths when sorted (arrow now `↑SWE%` instead of `↑ SWE%`)
+- **Mouse sequence suppression** — SGR mouse sequences no longer leak into keypress handlers (prevents spurious sort/filter triggers when clicking)
+
+### Fixed
+- **Command palette scroll leak** — Mouse wheel no longer injects raw SGR sequence bytes into the command palette text input
+- **Double-action on model click** — Clicking a model row now only moves the cursor; it no longer simultaneously triggers column sorting
+- **Mouse event listener order** — Fixed race condition where readline emitted keypress events before mouse data was processed
 
 ## [0.3.24] - 2026-03-19
 

package/README.md

@@ -229,6 +229,8 @@ When a tool mode is active (via `Z`), models incompatible with that tool are hig
 
 ## ⌨️ TUI Keys
 
+### Keyboard
+
 | Key | Action |
 |-----|--------|
 | `↑↓` | Navigate models |
@@ -251,6 +253,22 @@ When a tool mode is active (via `Z`), models incompatible with that tool are hig
 | `K` | Help overlay |
 | `Ctrl+C` | Exit |
 
+### Mouse
+
+| Action | Result |
+|--------|--------|
+| **Click column header** | Sort by that column |
+| **Click Tier header** | Cycle tier filter |
+| **Click CLI Tools header** | Cycle tool mode |
+| **Click model row** | Move cursor to model |
+| **Double-click model row** | Select and launch model |
+| **Right-click model row** | Toggle favorite |
+| **Scroll wheel** | Navigate table / overlays / palette |
+| **Click footer hotkey** | Trigger that action |
+| **Click command palette item** | Select item (double-click to confirm) |
+| **Click recommend option** | Select option (double-click to confirm) |
+| **Click outside modal** | Close command palette |
+
 → **[Stability score & column reference](./docs/stability.md)**
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "free-coding-models",
-  "version": "0.3.25",
+  "version": "0.3.26",
   "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

@@ -99,15 +99,13 @@ export const nvidiaNim = [
 // 📖 Free API keys available at https://console.groq.com/keys
 export const groq = [
   ['llama-3.3-70b-versatile',              'Llama 3.3 70B',      'A-', '39.5%', '128k'],
-  ['meta-llama/llama-4-scout-17b-16e-preview', 'Llama 4 Scout',  'A',  '44.0%', '10M'],
-  ['meta-llama/llama-4-maverick-17b-128e-preview', 'Llama 4 Maverick', 'S', '62.0%', '1M'],
-  ['deepseek-r1-distill-llama-70b',        'R1 Distill 70B',     'A',  '43.9%', '128k'],
-  ['qwen-qwq-32b',                         'QwQ 32B',            'A+', '50.0%', '131k'],
-  ['moonshotai/kimi-k2-instruct',          'Kimi K2 Instruct',   'S',  '65.8%', '131k'],
+  ['meta-llama/llama-4-scout-17b-16e-preview', 'Llama 4 Scout',  'A',  '44.0%', '131k'],
   ['llama-3.1-8b-instant',                 'Llama 3.1 8B',       'B',  '28.8%', '128k'],
   ['openai/gpt-oss-120b',                  'GPT OSS 120B',       'S',  '60.0%', '128k'],
   ['openai/gpt-oss-20b',                   'GPT OSS 20B',        'A',  '42.0%', '128k'],
   ['qwen/qwen3-32b',                       'Qwen3 32B',          'A+', '50.0%', '131k'],
+  ['groq/compound',                        'Groq Compound',      'A',  '45.0%', '131k'],
+  ['groq/compound-mini',                   'Groq Compound Mini', 'B+', '32.0%', '131k'],
 ]
 
 // 📖 Cerebras source - https://cloud.cerebras.ai
@@ -158,36 +156,43 @@ export const sambanova = [
 // 📖 API keys at https://openrouter.ai/keys
 export const openrouter = [
   ['qwen/qwen3-coder:free',                    'Qwen3 Coder 480B',   'S+', '70.6%', '262k'],
-  ['z-ai/glm-4.5-air:free',                    'GLM 4.5 Air',        'S+', '72.0%', '128k'],
-  ['google/gemma-3-27b-it:free',               'Gemma 3 27B',        'B',  '22.0%', '128k'],
+  ['minimax/minimax-m2.5:free',                'MiniMax M2.5',      'S+', '74.0%', '197k'],
+  ['z-ai/glm-4.5-air:free',                    'GLM 4.5 Air',        'S+', '72.0%', '131k'],
   ['stepfun/step-3.5-flash:free',              'Step 3.5 Flash',     'S+', '74.4%', '256k'],
-  ['qwen/qwen3-next-80b-a3b-instruct:free',    'Qwen3 80B Instruct', 'S',  '65.0%', '128k'],
-  ['openai/gpt-oss-120b:free',                 'GPT OSS 120B',       'S',  '60.0%', '128k'],
-  ['openai/gpt-oss-20b:free',                  'GPT OSS 20B',        'A',  '42.0%', '128k'],
+  ['nvidia/nemotron-3-super-120b-a12b:free',    'Nemotron 3 Super',  'A+', '56.0%', '262k'],
+  ['qwen/qwen3-next-80b-a3b-instruct:free',    'Qwen3 80B Instruct', 'S',  '65.0%', '131k'],
+  ['nousresearch/hermes-3-llama-3.1-405b:free',  'Hermes 3 405B',    'A',  '44.0%', '131k'],
+  ['openai/gpt-oss-120b:free',                 'GPT OSS 120B',       'S',  '60.0%', '131k'],
+  ['openai/gpt-oss-20b:free',                  'GPT OSS 20B',        'A',  '42.0%', '131k'],
   ['nvidia/nemotron-3-nano-30b-a3b:free',      'Nemotron Nano 30B',  'A',  '43.0%', '128k'],
-  ['meta-llama/llama-3.3-70b-instruct:free',   'Llama 3.3 70B',      'A-', '39.5%', '128k'],
+  ['meta-llama/llama-3.3-70b-instruct:free',   'Llama 3.3 70B',      'A-', '39.5%', '131k'],
   ['mistralai/mistral-small-3.1-24b-instruct:free', 'Mistral Small 3.1', 'B+', '30.0%', '128k'],
-  ['google/gemma-3-12b-it:free',               'Gemma 3 12B',        'C',  '15.0%', '128k'],
+  ['google/gemma-3-27b-it:free',               'Gemma 3 27B',        'B',  '22.0%', '131k'],
+  ['google/gemma-3-12b-it:free',               'Gemma 3 12B',        'C',  '15.0%', '131k'],
+  ['google/gemma-3n-e4b-it:free',              'Gemma 3n E4B',       'C',  '10.0%', '8k'],
 ]
 
 // 📖 Hugging Face Inference source - https://huggingface.co
 // 📖 OpenAI-compatible endpoint via router.huggingface.co/v1
 // 📖 Free monthly credits on developer accounts (~$0.10) — token at https://huggingface.co/settings/tokens
 export const huggingface = [
-  ['deepseek-ai/DeepSeek-V3-Coder',            'DeepSeek V3 Coder',  'S',  '62.0%', '128k'],
-  ['bigcode/starcoder2-15b',                   'StarCoder2 15B',     'B',  '25.0%', '16k'],
+  ['deepseek-ai/DeepSeek-V3-0324',             'DeepSeek V3 0324',   'S',  '62.0%', '128k'],
+  ['Qwen/Qwen2.5-Coder-32B-Instruct',          'Qwen2.5 Coder 32B',  'A',  '46.0%', '32k'],
 ]
 
 // 📖 Replicate source - https://replicate.com
 // 📖 Uses predictions endpoint (not OpenAI chat-completions) with token auth
 export const replicate = [
-  ['codellama/CodeLlama-70b-Instruct-hf',      'CodeLlama 70B',      'A-', '39.0%', '16k'],
+  ['deepseek-ai/DeepSeek-V3-0324',             'DeepSeek V3 0324',   'S',  '62.0%', '128k'],
+  ['meta/llama-3.3-70b-instruct',              'Llama 3.3 70B',      'A-', '39.5%', '128k'],
 ]
 
 // 📖 DeepInfra source - https://deepinfra.com
 // 📖 OpenAI-compatible endpoint: https://api.deepinfra.com/v1/openai/chat/completions
 export const deepinfra = [
-  ['mistralai/Mixtral-8x22B-Instruct-v0.1',    'Mixtral Code',       'B+', '32.0%', '64k'],
+  ['nvidia/Nemotron-3-Super',                  'Nemotron 3 Super',   'A+', '56.0%', '128k'],
+  ['deepseek-ai/DeepSeek-V3-0324',             'DeepSeek V3 0324',   'S',  '62.0%', '128k'],
+  ['Qwen/Qwen3-235B-A22B',                     'Qwen3 235B',         'S+', '70.0%', '128k'],
   ['meta-llama/Meta-Llama-3.1-70B-Instruct',   'Llama 3.1 70B',      'A-', '39.5%', '128k'],
 ]
 
@@ -197,6 +202,8 @@ export const deepinfra = [
 export const fireworks = [
   ['accounts/fireworks/models/deepseek-v3',    'DeepSeek V3',        'S',  '62.0%', '128k'],
   ['accounts/fireworks/models/deepseek-r1',    'DeepSeek R1',        'S',  '61.0%', '128k'],
+  ['accounts/fireworks/models/llama4-maverick-instruct-basic', 'Llama 4 Maverick', 'S', '62.0%', '1M'],
+  ['accounts/fireworks/models/qwen3-235b-a22b', 'Qwen3 235B',      'S+', '70.0%', '128k'],
 ]
 
 // 📖 Mistral Codestral source - https://codestral.mistral.ai
@@ -215,6 +222,7 @@ export const hyperbolic = [
   ['openai/gpt-oss-120b',                      'GPT OSS 120B',       'S',  '60.0%', '128k'],
   ['Qwen/Qwen3-235B-A22B',                     'Qwen3 235B',         'S+', '70.0%', '128k'],
   ['qwen/qwen3-next-80b-a3b-instruct',         'Qwen3 80B Instruct', 'S',  '65.0%', '128k'],
+  ['Qwen/Qwen3-Next-80B-A3B-Thinking',         'Qwen3 80B Thinking', 'S',  '68.0%', '128k'],
   ['deepseek-ai/DeepSeek-V3-0324',             'DeepSeek V3 0324',   'S',  '62.0%', '128k'],
   ['Qwen/Qwen2.5-Coder-32B-Instruct',          'Qwen2.5 Coder 32B',  'A',  '46.0%', '32k'],
   ['meta-llama/Llama-3.3-70B-Instruct',        'Llama 3.3 70B',      'A-', '39.5%', '128k'],
@@ -224,9 +232,10 @@ export const hyperbolic = [
 // 📖 Scaleway source - https://console.scaleway.com
 // 📖 1M free tokens — API keys at https://console.scaleway.com/iam/api-keys
 export const scaleway = [
-  ['devstral-2-123b-instruct-2512',            'Devstral 2 123B',    'S+', '72.2%', '256k'],
+  ['devstral-2-123b-instruct-2512',            'Devstral 2 123B',     'S+', '72.2%', '256k'],
+  ['qwen3.5-397b-a17b',                      'Qwen3.5 400B VLM',   'S',  '68.0%', '250k'],
+  ['mistral/mistral-large-3-675b-instruct-2512', 'Mistral Large 675B',  'A+', '58.0%', '250k'],
   ['qwen3-235b-a22b-instruct-2507',            'Qwen3 235B',         'S+', '70.0%', '128k'],
-  ['gpt-oss-120b',                             'GPT OSS 120B',       'S',  '60.0%', '128k'],
   ['qwen3-coder-30b-a3b-instruct',             'Qwen3 Coder 30B',    'A+', '55.0%', '32k'],
   ['llama-3.3-70b-instruct',                   'Llama 3.3 70B',      'A-', '39.5%', '128k'],
   ['deepseek-r1-distill-llama-70b',            'R1 Distill 70B',     'A',  '43.9%', '128k'],
@@ -272,6 +281,9 @@ export const siliconflow = [
 // 📖 Credits/promotions vary by account and region; verify current quota in console.
 export const together = [
   ['moonshotai/Kimi-K2.5',                     'Kimi K2.5',          'S+', '76.8%', '128k'],
+  ['Qwen/Qwen3.5-397B-A17B',                    'Qwen3.5 400B VLM',   'S',  '68.0%', '250k'],
+  ['MiniMaxAI/MiniMax-M2.5',                    'MiniMax M2.5',       'S+', '80.2%', '200k'],
+  ['zai-org/GLM-5',                             'GLM-5',              'S+', '77.8%', '128k'],
   ['Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8',  'Qwen3 Coder 480B',   'S+', '70.6%', '256k'],
   ['deepseek-ai/DeepSeek-V3.1',                'DeepSeek V3.1',      'S',  '62.0%', '128k'],
   ['deepseek-ai/DeepSeek-R1',                  'DeepSeek R1',        'S',  '61.0%', '128k'],
@@ -285,7 +297,12 @@ export const together = [
 // 📖 https://api.cloudflare.com/client/v4/accounts/{account_id}/ai/v1/chat/completions
 // 📖 Free plan includes daily neuron quota and provider-level request limits.
 export const cloudflare = [
+  ['@cf/moonshotai/kimi-k2.5',                'Kimi K2.5',         'S+', '76.8%', '256k'],
+  ['@cf/zhipu/glm-4.7-flash',               'GLM-4.7-Flash',     'S',  '59.2%', '131k'],
   ['@cf/openai/gpt-oss-120b',                  'GPT OSS 120B',       'S',  '60.0%', '128k'],
+  ['@cf/meta/llama-4-scout-17b-16e-instruct',  'Llama 4 Scout',    'A',  '44.0%', '131k'],
+  ['@cf/nvidia/nemotron-3-120b-a12b',           'Nemotron 3 Super', 'A+', '56.0%', '128k'],
+  ['@cf/qwen/qwen3-30b-a3b-fp8',               'Qwen3 30B MoE',    'A',  '45.0%', '128k'],
   ['@cf/qwen/qwen2.5-coder-32b-instruct',      'Qwen2.5 Coder 32B',  'A',  '46.0%', '32k'],
   ['@cf/deepseek-ai/deepseek-r1-distill-qwen-32b', 'R1 Distill 32B', 'A',  '43.9%', '128k'],
   ['@cf/openai/gpt-oss-20b',                   'GPT OSS 20B',        'A',  '42.0%', '128k'],
@@ -350,7 +367,8 @@ export const iflow = [
 // 📖 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'],
+  ['anthropic/claude-sonnet-4.6',       'Claude Sonnet 4.6',    'S+', '75.0%', '200k'],
+  ['anthropic/claude-opus-4.6',         'Claude Opus 4.6',      'S+', '80.0%', '200k'],
 ]
 
 // 📖 Gemini CLI source - https://github.com/google-gemini/gemini-cli

package/src/app.js

@@ -471,6 +471,12 @@ export async function runApp(cliArgs, config) {
     changelogPhase: 'index',      // 📖 'index' (all versions) | 'details' (specific version)
     changelogCursor: 0,           // 📖 Selected row in index phase
     changelogSelectedVersion: null, // 📖 Which version to show details for
+    // 📖 Installed Models overlay state (Command Palette → Installed models)
+    installedModelsOpen: false,   // 📖 Whether the installed models overlay is active
+    installedModelsCursor: 0,     // 📖 Selected row (tool or model)
+    installedModelsScrollOffset: 0, // 📖 Vertical scroll offset for overlay viewport
+    installedModelsData: [],       // 📖 Cached scan results
+    installedModelsErrorMsg: null, // 📖 Error or status message
     // 📖 Custom text filter (Ctrl+P palette → type text → Enter). Ephemeral — not saved to config.
     customTextFilter: null,       // 📖 Active free-text filter string (null = off). Matches model name, ctx, provider key/name.
   }
@@ -951,7 +957,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.incompatibleFallbackOpen && !state.recommendOpen && !state.feedbackOpen && !state.changelogOpen && !state.commandPaletteOpen) {
+    if (!state.settingsOpen && !state.installEndpointsOpen && !state.toolInstallPromptOpen && !state.incompatibleFallbackOpen && !state.recommendOpen && !state.feedbackOpen && !state.changelogOpen && !state.installedModelsOpen && !state.commandPaletteOpen) {
       const visible = state.results.filter(r => !r.hidden)
       state.visibleSorted = sortResultsWithPinnedFavorites(visible, state.sortColumn, state.sortDirection, {
         pinFavorites: state.favoritesPinnedAndSticky,
@@ -1034,6 +1040,8 @@ export async function runApp(cliArgs, config) {
         ? overlays.renderInstallEndpoints()
       : state.toolInstallPromptOpen
         ? overlays.renderToolInstallPrompt()
+      : state.installedModelsOpen
+        ? overlays.renderInstalledModels()
       : state.incompatibleFallbackOpen
         ? overlays.renderIncompatibleFallback()
       : state.commandPaletteOpen

package/src/command-palette.js

@@ -203,6 +203,7 @@ const BASE_COMMAND_TREE = [
   { id: 'open-feedback', label: 'Feedback', shortcut: 'I', icon: '📝', type: 'page', description: 'Report bugs or requests', keywords: ['feedback', 'bug', 'request'] },
   { id: 'open-recommend', label: 'Smart recommend', shortcut: 'Q', icon: '🎯', type: 'page', description: 'Find best model for task', keywords: ['recommend', 'best model'] },
   { id: 'open-install-endpoints', label: 'Install endpoints', icon: '🔌', type: 'page', description: 'Install provider catalogs', keywords: ['install', 'endpoints', 'providers'] },
+  { id: 'open-installed-models', label: 'Installed models', icon: '🗂️', type: 'page', description: 'View models configured in tools', keywords: ['installed', 'models', 'configured', 'tools', 'manager', 'goose', 'crush', 'aider'] },
 ]
 
 /**

package/src/installed-models-manager.js

@@ -0,0 +1,636 @@
+/**
+ * @file src/installed-models-manager.js
+ * @description Scan, parse, and manage models configured in external tool configs.
+ *
+ * @details
+ *   📖 This module provides functions to:
+ *   - Scan all supported tool configs for installed models
+ *   - Parse tool-specific config files (YAML, JSON)
+ *   - Soft-delete models with backup to ~/.free-coding-models-backups.json
+ *   - Launch tools with selected models
+ *   - Reinstall FCM endpoints for providers
+ *
+ *   📖 Supported tools:
+ *   - Goose (~/.config/goose/config.yaml + custom_providers/*.json)
+ *   - Crush (~/.config/crush/crush.json)
+ *   - Aider (~/.aider.conf.yml)
+ *   - Qwen (~/.qwen/settings.json)
+ *   - Pi (~/.pi/agent/models.json + settings.json)
+ *   - OpenHands (~/.fcm-openhands-env)
+ *   - Amp (~/.config/amp/settings.json)
+ *
+ *   📖 Backup system:
+ *   - Disabled models are saved to ~/.free-coding-models-backups.json
+ * - Each entry includes: toolMode, modelId, originalConfig, configPath, disabledAt
+ *
+ * @functions
+ *   → scanAllToolConfigs — Scan all tool configs and return structured results
+ *   → parseToolConfig — Parse a specific tool's config file
+ *   → parseGooseConfig — Parse Goose YAML config
+ *   → parseCrushConfig — Parse Crush JSON config
+ *   → parseAiderConfig — Parse Aider YAML config
+ *   → parseQwenConfig — Parse Qwen JSON config
+ *   → parsePiConfig — Parse Pi JSON configs
+ *   → parseOpenHandsConfig — Parse OpenHands env file
+ *   → parseAmpConfig — Parse Amp JSON config
+ *   → softDeleteModel — Remove model from config with backup
+ *   → launchToolWithModel — Launch tool with specific model
+ *   → reinstallEndpoint — Reinstall FCM endpoint for provider
+ *
+ * @exports scanAllToolConfigs, softDeleteModel, launchToolWithModel, reinstallEndpoint
+ *
+ * @see src/tool-launchers.js — for launch functions
+ * @see src/endpoint-installer.js — for reinstall logic
+ */
+
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join, dirname } from 'node:path'
+import { sources } from '../sources.js'
+
+const BACKUP_PATH = join(homedir(), '.free-coding-models-backups.json')
+
+/**
+ * 📖 Get tool config paths
+ */
+function getToolConfigPaths(homeDir = homedir()) {
+  return {
+    goose: join(homeDir, '.config', 'goose', 'config.yaml'),
+    crush: join(homeDir, '.config', 'crush', 'crush.json'),
+    aider: join(homeDir, '.aider.conf.yml'),
+    qwen: join(homeDir, '.qwen', 'settings.json'),
+    piModels: join(homeDir, '.pi', 'agent', 'models.json'),
+    piSettings: join(homeDir, '.pi', 'agent', 'settings.json'),
+    openHands: join(homeDir, '.fcm-openhands-env'),
+    amp: join(homeDir, '.config', 'amp', 'settings.json'),
+  }
+}
+
+/**
+ * 📖 Simple YAML parser for Goose and Aider configs
+ * Handles basic key: value and multiline strings
+ */
+function parseSimpleYaml(filePath) {
+  if (!existsSync(filePath)) return null
+  try {
+    const content = readFileSync(filePath, 'utf8')
+    const result = {}
+    let currentKey = null
+
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim()
+      if (!trimmed || trimmed.startsWith('#')) continue
+
+      const colonIndex = trimmed.indexOf(':')
+      if (colonIndex === -1) {
+        if (currentKey && result[currentKey] !== undefined) {
+          result[currentKey] += '\n' + trimmed
+        }
+        continue
+      }
+
+      currentKey = trimmed.slice(0, colonIndex).trim()
+      const value = trimmed.slice(colonIndex + 1).trim()
+
+      if (value === '' || value === '|') {
+        result[currentKey] = ''
+      } else if (value.startsWith('"') || value.startsWith("'")) {
+        result[currentKey] = value.slice(1, -1)
+      } else {
+        result[currentKey] = value
+      }
+    }
+
+    return result
+  } catch (err) {
+    return null
+  }
+}
+
+/**
+ * 📖 Parse Goose config for GOOSE_MODEL
+ */
+function parseGooseConfig(paths = getToolConfigPaths()) {
+  const configPath = paths.goose
+  if (!existsSync(configPath)) {
+    return { isValid: false, models: [], configPath }
+  }
+
+  try {
+    const yaml = parseSimpleYaml(configPath)
+    if (!yaml) {
+      return { isValid: false, models: [], configPath }
+    }
+
+    const gooseModel = yaml['GOOSE_MODEL']
+    const gooseProvider = yaml['GOOSE_PROVIDER']
+
+    const models = []
+    if (gooseModel) {
+      models.push({
+        modelId: gooseModel,
+        label: gooseModel,
+        tier: '-',
+        sweScore: '-',
+        providerKey: 'external',
+        isExternal: true,
+        canLaunch: true,
+      })
+    }
+
+    return {
+      isValid: true,
+      hasManagedMarker: yaml['GOOSE_PROVIDER']?.startsWith('fcm-'),
+      models,
+      configPath,
+    }
+  } catch (err) {
+    return { isValid: false, models: [], configPath }
+  }
+}
+
+/**
+ * 📖 Parse Crush config for models.large/small
+ */
+function parseCrushConfig(paths = getToolConfigPaths()) {
+  const configPath = paths.crush
+  if (!existsSync(configPath)) {
+    return { isValid: false, models: [], configPath }
+  }
+
+  try {
+    const content = readFileSync(configPath, 'utf8')
+    const config = JSON.parse(content)
+
+    const models = []
+// Extract models from providers section
+      if (config.providers) {
+        for (const providerKey in config.providers) {
+          const provider = config.providers[providerKey]
+          if (provider.models) {
+            for (const model of provider.models) {
+              models.push({
+                modelId: model.id,
+                label: model.name || model.id,
+                tier: '-',
+                sweScore: '-',
+                providerKey: 'external',
+                isExternal: true,
+                canLaunch: true,
+              })
+            }
+          }
+        }
+      }
+
+      // Extract models from models section (large/small)
+      if (config.models?.large?.model) {
+        models.push({
+          modelId: config.models.large.model,
+          label: `${config.models.large.model} (large)`,
+          tier: '-',
+          sweScore: '-',
+          providerKey: 'external',
+          isExternal: true,
+          canLaunch: true,
+        })
+      }
+      if (config.models?.small?.model) {
+        models.push({
+          modelId: config.models.small.model,
+          label: `${config.models.small.model} (small)`,
+          tier: '-',
+          sweScore: '-',
+          providerKey: 'external',
+          isExternal: true,
+          canLaunch: true,
+        })
+      }
+      if (config.models?.small?.model) {
+        models.push({
+          modelId: config.models.small.model + '-small',
+          label: `${config.models.small.model} (small)`,
+          tier: '-',
+          sweScore: '-',
+          providerKey: 'external',
+          isExternal: true,
+          canLaunch: true,
+        })
+      }
+
+    return {
+      isValid: true,
+      hasManagedMarker: config.providers?.freeCodingModels !== undefined,
+      models,
+      configPath,
+    }
+  } catch (err) {
+    return { isValid: false, models: [], configPath }
+  }
+}
+
+/**
+ * 📖 Parse Aider config for model
+ */
+function parseAiderConfig(paths = getToolConfigPaths()) {
+  const configPath = paths.aider
+  if (!existsSync(configPath)) {
+    return { isValid: false, models: [], configPath }
+  }
+
+  try {
+    const yaml = parseSimpleYaml(configPath)
+    if (!yaml) {
+      return { isValid: false, models: [], configPath }
+    }
+
+    const models = []
+    const aiderModel = yaml['model']
+    if (aiderModel) {
+      const modelId = aiderModel.startsWith('openai/') ? aiderModel.slice(7) : aiderModel
+      models.push({
+        modelId,
+        label: modelId,
+        tier: '-',
+        sweScore: '-',
+        providerKey: 'external',
+        isExternal: true,
+        canLaunch: true,
+      })
+    }
+
+    return {
+      isValid: true,
+      hasManagedMarker: yaml['openai-api-base']?.includes('build.nvidia.com') || false,
+      models,
+      configPath,
+    }
+  } catch (err) {
+    return { isValid: false, models: [], configPath }
+  }
+}
+
+/**
+ * 📖 Parse Qwen config for model
+ */
+function parseQwenConfig(paths = getToolConfigPaths()) {
+  const configPath = paths.qwen
+  if (!existsSync(configPath)) {
+    return { isValid: false, models: [], configPath }
+  }
+
+  try {
+    const content = readFileSync(configPath, 'utf8')
+    const config = JSON.parse(content)
+
+    const models = []
+    if (config.model) {
+      models.push({
+        modelId: config.model,
+        label: config.model,
+        tier: '-',
+        sweScore: '-',
+        providerKey: 'external',
+        isExternal: true,
+        canLaunch: true,
+      })
+    }
+
+    return {
+      isValid: true,
+      hasManagedMarker: Array.isArray(config.modelProviders?.openai) && config.modelProviders.openai.length > 0,
+      models,
+      configPath,
+    }
+  } catch (err) {
+    return { isValid: false, models: [], configPath }
+  }
+}
+
+/**
+ * 📖 Parse Pi configs for defaultModel
+ */
+function parsePiConfig(paths = getToolConfigPaths()) {
+  const settingsPath = paths.piSettings
+  if (!existsSync(settingsPath)) {
+    return { isValid: false, models: [], configPath: settingsPath }
+  }
+
+  try {
+    const content = readFileSync(settingsPath, 'utf8')
+    const config = JSON.parse(content)
+
+    const models = []
+    if (config.defaultModel && config.defaultProvider) {
+      models.push({
+        modelId: config.defaultModel,
+        label: config.defaultModel,
+        tier: '-',
+        sweScore: '-',
+        providerKey: 'external',
+        isExternal: true,
+        canLaunch: true,
+      })
+    }
+
+    return {
+      isValid: true,
+      hasManagedMarker: config.defaultProvider === 'freeCodingModels',
+      models,
+      configPath: settingsPath,
+    }
+  } catch (err) {
+    return { isValid: false, models: [], configPath: settingsPath }
+  }
+}
+
+/**
+ * 📖 Parse OpenHands env file for LLM_MODEL
+ */
+function parseOpenHandsConfig(paths = getToolConfigPaths()) {
+  const configPath = paths.openHands
+  if (!existsSync(configPath)) {
+    return { isValid: false, models: [], configPath }
+  }
+
+  try {
+    const content = readFileSync(configPath, 'utf8')
+    const models = []
+
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim()
+      if (trimmed.startsWith('export LLM_MODEL="') || trimmed.startsWith('export LLM_MODEL=\'')) {
+        const match = trimmed.match(/export LLM_MODEL=(["'])(.*?)\1/)
+        if (match) {
+          models.push({
+            modelId: match[2],
+            label: match[2],
+            tier: '-',
+            sweScore: '-',
+            providerKey: 'external',
+            isExternal: true,
+            canLaunch: true,
+          })
+        }
+      }
+    }
+
+    return {
+      isValid: true,
+      hasManagedMarker: content.includes('Managed by free-coding-models'),
+      models,
+      configPath,
+    }
+  } catch (err) {
+    return { isValid: false, models: [], configPath }
+  }
+}
+
+/**
+ * 📖 Parse Amp config for amp.model
+ */
+function parseAmpConfig(paths = getToolConfigPaths()) {
+  const configPath = paths.amp
+  if (!existsSync(configPath)) {
+    return { isValid: false, models: [], configPath }
+  }
+
+  try {
+    const content = readFileSync(configPath, 'utf8')
+    const config = JSON.parse(content)
+
+    const models = []
+    if (config['amp.model']) {
+      models.push({
+        modelId: config['amp.model'],
+        label: config['amp.model'],
+        tier: '-',
+        sweScore: '-',
+        providerKey: 'external',
+        isExternal: true,
+        canLaunch: true,
+      })
+    }
+
+    return {
+      isValid: true,
+      hasManagedMarker: config['amp.url']?.includes('build.nvidia.com') || false,
+      models,
+      configPath,
+    }
+  } catch (err) {
+    return { isValid: false, models: [], configPath }
+  }
+}
+
+/**
+ * 📖 Enhance model with metadata from sources.js
+ */
+function enhanceModelMetadata(model) {
+  const modelId = model.modelId
+
+  for (const providerKey in sources) {
+    const provider = sources[providerKey]
+    for (const m of provider.models) {
+      if (m[0] === modelId) {
+        return {
+          ...model,
+          label: m[1],
+          tier: m[2],
+          sweScore: m[3],
+          providerKey,
+          isExternal: false,
+        }
+      }
+    }
+  }
+
+  return model
+}
+
+/**
+ * 📖 Parse a specific tool's config
+ */
+export function parseToolConfig(toolMode, paths = getToolConfigPaths()) {
+  switch (toolMode) {
+    case 'goose':
+      return parseGooseConfig(paths)
+    case 'crush':
+      return parseCrushConfig(paths)
+    case 'aider':
+      return parseAiderConfig(paths)
+    case 'qwen':
+      return parseQwenConfig(paths)
+    case 'pi':
+      return parsePiConfig(paths)
+    case 'openhands':
+      return parseOpenHandsConfig(paths)
+    case 'amp':
+      return parseAmpConfig(paths)
+    default:
+      return { isValid: false, models: [], configPath: '' }
+  }
+}
+
+/**
+ * 📖 Scan all tool configs and return structured results
+ */
+export function scanAllToolConfigs(paths = getToolConfigPaths()) {
+  const toolModes = ['goose', 'crush', 'aider', 'qwen', 'pi', 'openhands', 'amp']
+
+  return toolModes.map((toolMode) => {
+    const result = parseToolConfig(toolMode, paths)
+
+    return {
+      toolMode,
+      toolLabel: toolMode.charAt(0).toUpperCase() + toolMode.slice(1),
+      toolEmoji: getToolEmoji(toolMode),
+      ...result,
+      models: result.models.map(enhanceModelMetadata),
+    }
+  })
+}
+
+/**
+ * 📖 Get tool emoji
+ */
+function getToolEmoji(toolMode) {
+  const emojis = {
+    goose: '🪿',
+    crush: '💘',
+    aider: '🛠',
+    qwen: '🐉',
+    pi: 'π',
+    openhands: '🤲',
+    amp: '⚡',
+  }
+  return emojis[toolMode] || '🧰'
+}
+
+/**
+ * 📖 Load backups from ~/.free-coding-models-backups.json
+ */
+function loadBackups() {
+  if (!existsSync(BACKUP_PATH)) {
+    return { disabledModels: [] }
+  }
+  try {
+    const content = readFileSync(BACKUP_PATH, 'utf8')
+    return JSON.parse(content)
+  } catch (err) {
+    return { disabledModels: [] }
+  }
+}
+
+/**
+ * 📖 Save backups to ~/.free-coding-models-backups.json
+ */
+function saveBackups(backups) {
+  const dir = dirname(BACKUP_PATH)
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true })
+  }
+  writeFileSync(BACKUP_PATH, JSON.stringify(backups, null, 2))
+}
+
+/**
+ * 📖 Soft-delete a model from tool config with backup
+ */
+export function softDeleteModel(toolMode, modelId, paths = getToolConfigPaths()) {
+  const configPath = paths[toolMode === 'pi' ? 'piSettings' : toolMode]
+  if (!existsSync(configPath)) {
+    return { success: false, error: 'Config file not found' }
+  }
+
+  try {
+    let originalContent = readFileSync(configPath, 'utf8')
+    let newContent = originalContent
+    let modified = false
+
+    switch (toolMode) {
+      case 'goose':
+        if (originalContent.includes(`GOOSE_MODEL: ${modelId}`)) {
+          newContent = originalContent.replace(/^GOOSE_MODEL:.*$/m, '# GOOSE_MODEL: (disabled by FCM)\n# GOOSE_MODEL: ' + modelId)
+          modified = true
+        }
+        break
+
+      case 'crush':
+        const crushConfig = JSON.parse(originalContent)
+        if (crushConfig.models?.large?.model === modelId || crushConfig.models?.small?.model === modelId) {
+          if (crushConfig.models?.large?.model === modelId) {
+            delete crushConfig.models.large
+          }
+          if (crushConfig.models?.small?.model === modelId) {
+            delete crushConfig.models.small
+          }
+          newContent = JSON.stringify(crushConfig, null, 2)
+          modified = true
+        }
+        break
+
+      case 'aider':
+        if (originalContent.includes(`model: openai/${modelId}`)) {
+          newContent = originalContent.replace(/^model:.*$/m, '# model: (disabled by FCM)\n# model: openai/' + modelId)
+          modified = true
+        }
+        break
+
+      case 'qwen':
+        const qwenConfig = JSON.parse(originalContent)
+        if (qwenConfig.model === modelId) {
+          delete qwenConfig.model
+          newContent = JSON.stringify(qwenConfig, null, 2)
+          modified = true
+        }
+        break
+
+      case 'pi':
+        const piConfig = JSON.parse(originalContent)
+        if (piConfig.defaultModel === modelId) {
+          delete piConfig.defaultModel
+          newContent = JSON.stringify(piConfig, null, 2)
+          modified = true
+        }
+        break
+
+      case 'openhands':
+        if (originalContent.includes(`export LLM_MODEL="${modelId}"`) || originalContent.includes(`export LLM_MODEL='${modelId}'`)) {
+          newContent = originalContent.replace(/^export LLM_MODEL=.*$/m, '# export LLM_MODEL: (disabled by FCM)\n# export LLM_MODEL="' + modelId + '"')
+          modified = true
+        }
+        break
+
+      case 'amp':
+        const ampConfig = JSON.parse(originalContent)
+        if (ampConfig['amp.model'] === modelId) {
+          delete ampConfig['amp.model']
+          newContent = JSON.stringify(ampConfig, null, 2)
+          modified = true
+        }
+        break
+    }
+
+    if (!modified) {
+      return { success: false, error: 'Model not found in config' }
+    }
+
+    writeFileSync(configPath, newContent)
+
+    const backups = loadBackups()
+    backups.disabledModels.push({
+      id: `${toolMode}-${modelId}-${new Date().toISOString()}`,
+      toolMode,
+      modelId,
+      originalConfig: originalContent,
+      configPath,
+      disabledAt: new Date().toISOString(),
+      reason: 'user_deleted',
+    })
+    saveBackups(backups)
+
+    return { success: true }
+  } catch (err) {
+    return { success: false, error: err.message }
+  }
+}

package/src/key-handler.js

@@ -35,6 +35,8 @@ 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'
+import { scanAllToolConfigs, softDeleteModel } from './installed-models-manager.js'
+import { startExternalTool } from './tool-launchers.js'
 
 // 📖 Some providers need an explicit probe model because the first catalog entry
 // 📖 is not guaranteed to be accepted by their chat endpoint.
@@ -687,6 +689,21 @@ export function createKeyHandler(ctx) {
     state.changelogSelectedVersion = null
   }
 
+  function openInstalledModelsOverlay() {
+    state.installedModelsOpen = true
+    state.installedModelsCursor = 0
+    state.installedModelsScrollOffset = 0
+    state.installedModelsErrorMsg = 'Scanning...'
+
+    try {
+      const results = scanAllToolConfigs()
+      state.installedModelsData = results
+      state.installedModelsErrorMsg = null
+    } catch (err) {
+      state.installedModelsErrorMsg = err.message || 'Failed to scan tool configs'
+    }
+  }
+
   function cycleToolMode() {
     const modeOrder = getToolModeOrder()
     const currentIndex = modeOrder.indexOf(state.mode)
@@ -774,6 +791,7 @@ export function createKeyHandler(ctx) {
     return state.settingsOpen
       || state.installEndpointsOpen
       || state.toolInstallPromptOpen
+      || state.installedModelsOpen
       || state.recommendOpen
       || state.feedbackOpen
       || state.helpVisible
@@ -943,6 +961,7 @@ export function createKeyHandler(ctx) {
       case 'open-feedback': return openFeedbackOverlay()
       case 'open-recommend': return openRecommendOverlay()
       case 'open-install-endpoints': return openInstallEndpointsOverlay()
+      case 'open-installed-models': return openInstalledModelsOverlay()
       case 'action-cycle-theme': return cycleGlobalTheme()
       case 'action-cycle-tool-mode': return cycleToolMode()
       case 'action-cycle-ping-mode': {
@@ -1289,6 +1308,104 @@ export function createKeyHandler(ctx) {
       return
     }
 
+    // ─── Installed Models overlay keyboard handling ───────────────────────────
+    if (state.installedModelsOpen) {
+      if (key.ctrl && key.name === 'c') { exit(0); return }
+
+      const scanResults = state.installedModelsData || []
+      let maxIndex = 0
+      for (const toolResult of scanResults) {
+        maxIndex += 1
+        maxIndex += toolResult.models.length
+      }
+      if (maxIndex > 0) maxIndex--
+
+      const pageStep = Math.max(1, (state.terminalRows || 1) - 4)
+
+      if (key.name === 'up' || (key.shift && key.name === 'tab')) {
+        state.installedModelsCursor = Math.max(0, state.installedModelsCursor - 1)
+        return
+      }
+      if (key.name === 'down' || key.name === 'tab') {
+        state.installedModelsCursor = Math.min(maxIndex, state.installedModelsCursor + 1)
+        return
+      }
+      if (key.name === 'pageup') {
+        state.installedModelsCursor = Math.max(0, state.installedModelsCursor - pageStep)
+        return
+      }
+      if (key.name === 'pagedown') {
+        state.installedModelsCursor = Math.min(maxIndex, state.installedModelsCursor + pageStep)
+        return
+      }
+      if (key.name === 'home') {
+        state.installedModelsCursor = 0
+        return
+      }
+      if (key.name === 'end') {
+        state.installedModelsCursor = maxIndex
+        return
+      }
+
+      if (key.name === 'escape') {
+        state.installedModelsOpen = false
+        state.installedModelsCursor = 0
+        return
+      }
+
+      if (key.name === 'return') {
+        let currentIdx = 0
+        for (const toolResult of scanResults) {
+          if (currentIdx === state.installedModelsCursor) {
+            return
+          }
+          currentIdx++
+          for (const model of toolResult.models) {
+            if (currentIdx === state.installedModelsCursor) {
+              const selectedModel = {
+                modelId: model.modelId,
+                providerKey: model.providerKey,
+                label: model.label,
+              }
+
+              state.installedModelsOpen = false
+              await startExternalTool(toolResult.toolMode, selectedModel, state.config)
+              return
+            }
+            currentIdx++
+          }
+        }
+      }
+
+      if (key.name === 'd') {
+        let currentIdx = 0
+        for (const toolResult of scanResults) {
+          currentIdx++
+          for (const model of toolResult.models) {
+            if (currentIdx === state.installedModelsCursor) {
+              softDeleteModel(toolResult.toolMode, model.modelId)
+                .then((result) => {
+                  if (result.success) {
+                    openInstalledModelsOverlay()
+                  } else {
+                    state.installedModelsErrorMsg = `Failed to disable: ${result.error}`
+                    setTimeout(() => { state.installedModelsErrorMsg = null }, 3000)
+                  }
+                })
+                .catch((err) => {
+                  state.installedModelsErrorMsg = `Failed to disable: ${err.message}`
+                  setTimeout(() => { state.installedModelsErrorMsg = null }, 3000)
+                })
+              return
+            }
+            currentIdx++
+          }
+        }
+      }
+
+      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) {
@@ -2327,6 +2444,22 @@ export function createMouseEventHandler(ctx) {
         }
         return
       }
+      if (state.installedModelsOpen) {
+        const scanResults = state.installedModelsData || []
+        let maxIndex = 0
+        for (const toolResult of scanResults) {
+          maxIndex += 1
+          maxIndex += toolResult.models.length
+        }
+        if (maxIndex > 0) maxIndex--
+
+        if (evt.type === 'scroll-up') {
+          state.installedModelsCursor = Math.max(0, (state.installedModelsCursor || 0) - 1)
+        } else {
+          state.installedModelsCursor = Math.min(maxIndex, (state.installedModelsCursor || 0) + 1)
+        }
+        return
+      }
 
       // 📖 Main table scroll: move cursor up/down with wrap-around
       const count = state.visibleSorted.length
@@ -2402,6 +2535,11 @@ export function createMouseEventHandler(ctx) {
       return
     }
 
+    if (state.installedModelsOpen) {
+      state.installedModelsOpen = false
+      return
+    }
+
     if (state.incompatibleFallbackOpen) {
       // 📖 Incompatible fallback: click closes
       state.incompatibleFallbackOpen = false

package/src/overlays.js

@@ -479,6 +479,114 @@ export function createOverlayRenderers(state, deps) {
     return cleared.join('\n')
   }
 
+  // ─── Installed Models Manager overlay renderer ─────────────────────────────
+  // 📖 renderInstalledModels displays all models configured in external tools
+  // 📖 Shows tool configs, model lists, and provides actions (Launch, Disable, Reinstall)
+  function renderInstalledModels() {
+    const EL = '\x1b[K'
+    const lines = []
+    const cursorLineByRow = {}
+
+    lines.push('')
+    lines.push(`  ${themeColors.accent('🚀')} ${themeColors.accentBold('free-coding-models')} ${themeColors.dim(`v${LOCAL_VERSION}`)}`)
+    lines.push(`  ${themeColors.textBold('🗂️  Installed Models Manager')}`)
+    lines.push('')
+    lines.push(themeColors.dim('  — models configured in your tools'))
+
+    if (state.installedModelsErrorMsg) {
+      lines.push(`  ${themeColors.warning(state.installedModelsErrorMsg)}`)
+    }
+
+    if (state.installedModelsErrorMsg === 'Scanning...') {
+      lines.push(themeColors.dim('  Scanning tool configs, please wait...'))
+      const targetLine = 5
+      state.installedModelsScrollOffset = keepOverlayTargetVisible(
+        state.installedModelsScrollOffset,
+        targetLine,
+        lines.length,
+        state.terminalRows
+      )
+      const { visible, offset } = sliceOverlayLines(lines, state.installedModelsScrollOffset, state.terminalRows)
+      state.installedModelsScrollOffset = offset
+
+      overlayLayout.installedModelsCursorToLine = cursorLineByRow
+      overlayLayout.installedModelsScrollOffset = offset
+
+      const tintedLines = tintOverlayLines(visible, themeColors.overlayBgSettings, state.terminalCols)
+      const cleared = tintedLines.map((l) => l + EL)
+      return cleared.join('\n')
+    }
+
+    lines.push('')
+
+    const scanResults = state.installedModelsData || []
+
+    if (scanResults.length === 0) {
+      lines.push(themeColors.dim('  No tool configs found.'))
+      lines.push(themeColors.dim('  Install a tool (Goose, Crush, Aider, etc.) to get started.'))
+    } else {
+      let globalIdx = 0
+
+      for (const toolResult of scanResults) {
+        const { toolMode, toolLabel, toolEmoji, configPath, isValid, hasManagedMarker, models } = toolResult
+
+        lines.push('')
+        const isCursor = globalIdx === state.installedModelsCursor
+
+        const statusIcon = isValid ? themeColors.successBold('✅') : themeColors.errorBold('⚠️')
+        const toolHeader = `${bullet(isCursor)}${toolEmoji} ${themeColors.textBold(toolLabel)} ${statusIcon}`
+        cursorLineByRow[globalIdx++] = lines.length
+        lines.push(isCursor ? themeColors.bgCursor(toolHeader) : toolHeader)
+
+        const configShortPath = configPath.replace(process.env.HOME || homedir(), '~')
+        lines.push(`     ${themeColors.dim(configShortPath)}`)
+
+        if (!isValid) {
+          lines.push(themeColors.dim('     ⚠️  Config invalid or missing'))
+        } else if (models.length === 0) {
+          lines.push(themeColors.dim('     No models configured'))
+        } else {
+          const managedBadge = hasManagedMarker ? themeColors.info('• Managed by FCM') : themeColors.dim('• External config')
+          lines.push(`     ${themeColors.success(`${models.length} model${models.length > 1 ? 's' : ''} configured`)}  ${managedBadge}`)
+
+          for (const model of models) {
+            const isModelCursor = globalIdx === state.installedModelsCursor
+            const tierBadge = model.tier !== '-' ? themeColors.info(model.tier.padEnd(2)) : themeColors.dim('  ')
+            const externalBadge = model.isExternal ? themeColors.dim('[external]') : ''
+
+            const modelRow = `     • ${model.label} ${tierBadge} ${externalBadge}`
+            cursorLineByRow[globalIdx++] = lines.length
+            lines.push(isModelCursor ? themeColors.bgCursor(modelRow) : modelRow)
+
+            if (isModelCursor) {
+              lines.push(`        ${themeColors.dim('[Enter] Launch  [D] Disable')}`)
+            }
+          }
+        }
+      }
+    }
+
+    lines.push('')
+    lines.push(themeColors.dim('  ↑↓ Navigate  Enter=Launch  D=Disable  Esc=Close'))
+
+    const targetLine = cursorLineByRow[state.installedModelsCursor] ?? 0
+    state.installedModelsScrollOffset = keepOverlayTargetVisible(
+      state.installedModelsScrollOffset,
+      targetLine,
+      lines.length,
+      state.terminalRows
+    )
+    const { visible, offset } = sliceOverlayLines(lines, state.installedModelsScrollOffset, state.terminalRows)
+    state.installedModelsScrollOffset = offset
+
+    overlayLayout.installedModelsCursorToLine = cursorLineByRow
+    overlayLayout.installedModelsScrollOffset = offset
+
+    const tintedLines = tintOverlayLines(visible, themeColors.overlayBgSettings, state.terminalCols)
+    const cleared = tintedLines.map((l) => l + EL)
+    return cleared.join('\n')
+  }
+
   // ─── Missing-tool install confirmation overlay ────────────────────────────
   // 📖 renderToolInstallPrompt keeps the user inside the TUI long enough to
   // 📖 confirm the auto-install, then the key handler exits the alt screen and
@@ -1381,6 +1489,7 @@ export function createOverlayRenderers(state, deps) {
     renderRecommend,
     renderFeedback,
     renderChangelog,
+    renderInstalledModels,
     renderIncompatibleFallback,
     startRecommendAnalysis,
     stopRecommendAnalysis,