free-coding-models 0.3.80 → 0.4.1

package/README.md

@@ -422,6 +422,8 @@ When a tool mode is active (via `Z`), models incompatible with that tool are hig
 | `X` | Clear active custom text filter |
 | `G` | Cycle global theme (`Auto → Dark → Light`) |
 | `Ctrl+P` | Open ⚡️ command palette (search + run actions) |
+| `Ctrl+A` | Run AI Speed Test for the selected model |
+| `Ctrl+U` | Run Global AI Speed Test (uses real provider requests) |
 | `R/S/C/M/O/L/A/H/V/B/U` | Sort columns |
 | `Shift+U` | Update to latest version (when update available) |
 | `P` | Settings (API keys, providers, updates, theme) |
@@ -456,7 +458,8 @@ When a tool mode is active (via `Z`), models incompatible with that tool are hig
 ## ✨ Features
 
 - **Parallel pings** — all ~165 API/Zen-callable models tested simultaneously via native `fetch` (~170 total cataloged models including CLI-only Gemini rows)
-- **AI benchmark columns** — `Ctrl+A` benchmarks the selected model, `Ctrl+U` benchmarks visible models, and results split cleanly into **AI Latency** plus **TPS**.
+- **AI benchmark columns** — `Ctrl+A` benchmarks the selected model, `Ctrl+U` benchmarks visible models, and results split cleanly into **AI Latency** plus **TPS**. Settings includes an opt-in **Startup AI Speed Scan** toggle to run the global benchmark automatically after launch.
+- **Tiny verdict indicator** — the first `❔` column mirrors the full Verdict as a compact emoji (`🟩`, `🟢`, `🟡`, `🟠`, etc.) and sorts by the same verdict order.
 - **Adaptive monitoring** — 2s burst for 60s → 10s normal → 30s idle
 - **Stability score** — composite 0–100 (p95 latency, jitter, spike rate, uptime)
 - **Smart ranking** — top 3 highlighted 🥇🥈🥉

package/changelog/v0.3.81.md

@@ -0,0 +1,14 @@
+# Changelog v0.3.81 - 2026-05-30
+
+### Added
+- **Tiny verdict indicator column** — Added a first-column `❔` status indicator that shows the current verdict as a compact emoji while keeping the existing `Verdict` column intact for users who already rely on the full text labels.
+- **Clickable verdict shortcut** — The new `❔` column uses the same verdict sort behavior as the existing `Verdict` column, so users can sort by model condition from the far-left edge of the table.
+- **Benchmark retry with blue badge** — Ctrl+A and Ctrl+U now retry failed models up to 3 times with 15s delay. Successful retries show a blue `↻N` badge in AI Latency and TPS columns.
+- **Smart benchmark ordering** — Ctrl+U now tests UP/healthy models first (low ping → high ping), then timeout/noauth/down models last. Fast results appear instantly instead of waiting for slow retries.
+- **Health updates from benchmark** — When a benchmark succeeds or fails, the model's Health column updates in real-time (e.g. a 429 model that responds gets marked UP).
+- **Raw byte fallback for Ctrl+U** — Added `\x15` fallback so Ctrl+U works in Ghostty and other terminals where readline swallows the key event.
+
+### Changed
+- **Clearer verdict emojis** — Updated the TUI verdict icons to use the same compact visual language in both places: `🟩 Perfect`, `🟢 Normal`, `🟡 Spiky`, `🟠 Slow`, `🔴 Very Slow`, `🔥 Overloaded`, `⚠️ Unstable`, `⚫ Not Active`, and `⏳ Pending`.
+- **Benchmark runs on ALL models** — Ctrl+U and Ctrl+A no longer skip models based on health status, TUI filters, or missing provider URLs. Every model gets tested.
+- **Red dash on benchmark error** — Failed benchmarks show a red `—` in AI Latency and TPS columns instead of error codes (which already appear in the Health column).

package/changelog/v0.4.0.md

@@ -0,0 +1,23 @@
+# Changelog v0.4.0 - 2026-05-30
+
+### Added
+- **Startup AI Speed Scan opt-in** — Added a new Settings toggle that can automatically run the global Ctrl+U AI Speed Test after each app launch. It is disabled by default because it uses real provider requests, and first-time onboarding now asks whether users want to enable it.
+- **Tiny verdict indicator column** — Added a compact first-column `❔` verdict indicator so users can scan model condition instantly without reading the full `Verdict` column.
+- **Clickable verdict shortcut** — The new compact verdict column sorts with the same logic as the full `Verdict` column, making the far-left status indicator a fast sorting target.
+- **Benchmark retry badges** — Ctrl+A and Ctrl+U now retry failed benchmark requests up to 3 times with a 15s delay. Successful retries show a blue `↻N` badge beside AI Latency and TPS values so users know the result recovered after transient provider trouble.
+- **Smart global benchmark ordering** — Ctrl+U now tests healthy/UP models first, sorted by low ping, then slower or problematic models afterward. This gives useful benchmark results quickly instead of letting timeouts dominate the start of the run.
+- **Benchmark-driven health updates** — Real AI Speed Test results now update the Health column live. A model that succeeds during benchmarking can recover from stale timeout/down states, while auth/rate-limit/errors are reflected immediately.
+- **Ctrl+U raw-byte fallback** — Added the `\x15` fallback so Global AI Speed Test works in terminals where Node/readline does not report Ctrl+U normally.
+- **Header flash feedback** — Column header clicks now flash the active column, making mouse sorting easier to confirm visually.
+
+### Changed
+- **v0.4.0 supersedes the broken v0.3.81 bump** — This release consolidates all post-v0.3.80 benchmark, verdict, and startup-scan changes into a clean minor release line.
+- **AI Speed Test now benchmarks every model** — Ctrl+A and Ctrl+U no longer skip models just because they are filtered, unhealthy, missing a provider URL, or currently showing an error state. The benchmark path now attempts the real request and lets the result decide.
+- **Benchmark errors are visually cleaner** — Failed benchmarks show a red `—` in AI Latency and TPS instead of duplicating HTTP/error labels in the benchmark columns. Detailed status remains in the Health column.
+- **Clearer verdict emoji language** — Verdict visuals now use a consistent compact mapping: `🟩 Perfect`, `🟢 Normal`, `🟡 Spiky`, `🟠 Slow`, `🔴 Very Slow`, `🔥 Overloaded`, `⚠️ Unstable`, `⚫ Not Active`, and `⏳ Pending`.
+- **Settings and docs mention Global AI Speed Test clearly** — README, Help, and Settings now explain Ctrl+A, Ctrl+U, and the optional startup auto-run behavior more explicitly.
+
+### Fixed
+- **Ctrl+A works on error rows** — The selected-model benchmark can run even when the row currently has an error/timeout/no-key status, so users can retest problematic models directly.
+- **Global benchmark ignores UI filters correctly** — Ctrl+U benchmarks the complete model set instead of accidentally obeying active filters or visible-table state.
+- **Benchmark result display is stable** — Benchmark results now render consistently regardless of Health state, avoiding cases where successful benchmark data was hidden behind stale row status.

package/package.json

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

@@ -337,7 +337,7 @@ export async function runApp(cliArgs, config) {
       status: 'pending',
       pings: [],  // 📖 All ping results (ms or 'TIMEOUT')
       httpCode: null,
-      isPinging: false, // 📖 Per-row live flag so Latest Ping can keep last value and show a spinner during refresh.
+      isPinging: false, // 📖 Per-row live flag so Last Ping can keep last value and show a spinner during refresh.
       hidden: false,  // 📖 Simple flag to hide/show models
     }))
   syncFavoriteFlags(results, config)
@@ -785,6 +785,7 @@ export async function runApp(cliArgs, config) {
       const visible = state.results.filter(r => !r.hidden)
       state.visibleSorted = sortResultsWithPinnedFavorites(visible, state.sortColumn, state.sortDirection, {
         pinFavorites: state.favoritesPinnedAndSticky,
+        benchmarkResults: state.benchmarkResults,
       })
       if (state.cursor >= state.visibleSorted.length) state.cursor = Math.max(0, state.visibleSorted.length - 1)
       adjustScrollOffset(state)
@@ -792,6 +793,11 @@ export async function runApp(cliArgs, config) {
     const tableTerminalRows = state.terminalRows
 
     let tableContent = null
+    // 📖 Clear expired header flash animation
+    if (state.headerFlashColumn && state.frame >= state.headerFlashUntilFrame) {
+      state.headerFlashColumn = null
+    }
+
     // 📖 Build renderTable options once per frame — keeps all call sites in sync
     const tableOpts = {
       results: state.results,
@@ -825,6 +831,7 @@ export async function runApp(cliArgs, config) {
       bestModeOnly: state.bestModeOnly,
       benchmarkResults: state.benchmarkResults,
       benchmarkRunning: state.benchmarkRunning,
+      headerFlashColumn: state.headerFlashColumn,
     }
     if (state.commandPaletteOpen) {
       if (!state.commandPaletteFrozenTable) {
@@ -880,6 +887,7 @@ export async function runApp(cliArgs, config) {
   const initialVisible = state.results.filter(r => !r.hidden)
   state.visibleSorted = sortResultsWithPinnedFavorites(initialVisible, state.sortColumn, state.sortDirection, {
     pinFavorites: state.favoritesPinnedAndSticky,
+    benchmarkResults: state.benchmarkResults,
   })
 
   process.stdout.write(ALT_HOME + renderTable({
@@ -931,6 +939,17 @@ export async function runApp(cliArgs, config) {
     state.recommendScrollOffset = 0
   }
 
+  // 📖 Startup AI Speed Scan: opt-in setting that reuses the Ctrl+U path so the
+  // 📖 automatic launch stays identical to the manual global benchmark behavior.
+  // 📖 1.5s delay ensures the TUI has rendered at least one full frame and the
+  // 📖 keypress handler pipeline is live before we simulate Ctrl+U.
+  const scheduleAiSpeedScanOnStartup = () => {
+    if (state.config.settings?.runAiSpeedTestOnStartup !== true) return
+    setTimeout(() => {
+      onKeyPress?.('\x15', { name: 'u', ctrl: true, meta: false, shift: false })?.catch(() => {})
+    }, 1500)
+  }
+
   // ── Continuous ping loop — ping all models every N seconds forever ──────────
 
   // 📖 Initial ping of all models
@@ -992,6 +1011,7 @@ export async function runApp(cliArgs, config) {
   scheduleNextPing()
 
   await initialPing
+  scheduleAiSpeedScanOnStartup()
 
   // 📖 Save cache after initial pings complete for faster next startup
   saveCache(state.results, state.pingMode)

package/src/benchmark.js

@@ -43,9 +43,16 @@ export const BENCHMARK_MAX_TOKENS = 140
 // 📖 BENCHMARK_TEMPERATURE: Zero temperature for deterministic, reproducible results.
 export const BENCHMARK_TEMPERATURE = 0
 
-// 📖 BENCHMARK_TIMEOUT_MS: How long to wait before treating a benchmark as failed.
+// 📖 BENCHMARK_TIMEOUT_MS: How long to wait before treating a benchmark attempt as timed out.
 export const BENCHMARK_TIMEOUT_MS = 20_000
 
+// 📖 BENCHMARK_MAX_RETRIES: Number of attempts before giving up. Models that are timeout,
+// 📖 429, or temporarily down may succeed on a later attempt — this is the whole point.
+export const BENCHMARK_MAX_RETRIES = 3
+
+// 📖 BENCHMARK_RETRY_DELAY_MS: Wait time between failed attempts so the server can recover.
+export const BENCHMARK_RETRY_DELAY_MS = 15_000
+
 // 📖 estimateTokensFromText: Fallback token counter when the API does not return usage.
 // 📖 Uses a simple heuristic: avg English token ≈ 4 chars. This is explicitly an ESTIMATE
 // 📖 and is labeled as such everywhere it surfaces. Do not use for billing.
@@ -60,26 +67,33 @@ function benchmarkSpinner(frame) {
   return ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'][spinIdx]
 }
 
-// 📖 formatBenchmarkLatency: Turn a raw benchmark result into the AI Latency column value.
-// 📖 Success: "4.3s" / "12s". Error: compact error code. Empty: "—".
+// 📖 retryBadge: compact retry indicator appended to latency when > 0 attempts failed.
+function retryBadge(retries) {
+  return (typeof retries === 'number' && retries > 0) ? `↻${retries}` : ''
+}
+
+// 📖 formatBenchmarkLatency: Returns { text, retryBadge } so the renderer can color
+// 📖 the retry badge independently (blue) vs the latency value (green).
 export function formatBenchmarkLatency(result, { running = false, frame = 0 } = {}) {
-  if (running) return benchmarkSpinner(frame)
-  if (!result) return '—'
-  if (!result.ok) return result.code || 'ERR'
+  if (running) return { text: benchmarkSpinner(frame), retryBadge: '' }
+  if (!result) return { text: '—', retryBadge: '' }
+  if (!result.ok) return { text: result.code || 'ERR', retryBadge: '' }
 
   const totalSeconds = result.totalMs / 1000
-  return totalSeconds >= 10
+  const badge = retryBadge(result.retries)
+  const latency = totalSeconds >= 10
     ? totalSeconds.toFixed(0) + 's'
     : totalSeconds.toFixed(1) + 's'
+  return { text: latency, retryBadge: badge }
 }
 
-// 📖 formatBenchmarkTps: Turn a raw benchmark result into the TPS column value.
-// 📖 Success is the rounded tokens/second number only because the header carries "TPS".
-// 📖 Errors and empty state stay as a dim dash in the table to avoid duplicating codes.
+// 📖 formatBenchmarkTps: Returns { text, retryBadge } so the renderer can color
+// 📖 the retry badge independently (blue) vs the TPS value (green).
 export function formatBenchmarkTps(result, { running = false, frame = 0 } = {}) {
-  if (running) return benchmarkSpinner(frame)
-  if (!result || !result.ok) return '—'
-  return String(Math.round(result.tokensPerSecond ?? 0))
+  if (running) return { text: benchmarkSpinner(frame), retryBadge: '' }
+  if (!result || !result.ok) return { text: '—', retryBadge: '' }
+  const badge = retryBadge(result.retries)
+  return { text: String(Math.round(result.tokensPerSecond ?? 0)), retryBadge: badge }
 }
 
 // 📖 formatBenchmarkResult: legacy combined formatter retained for integrations/tests
@@ -88,7 +102,9 @@ export function formatBenchmarkResult(result, options = {}) {
   if (options.running) return benchmarkSpinner(options.frame ?? 0)
   if (!result) return '—'
   if (!result.ok) return result.code || 'ERR'
-  return `${formatBenchmarkLatency(result)} / ${formatBenchmarkTps(result)} TPS`
+  const lat = formatBenchmarkLatency(result)
+  const tps = formatBenchmarkTps(result)
+  return `${lat.text}${lat.retryBadge} / ${tps.text}${tps.retryBadge} TPS`
 }
 
 // 📖 buildBenchmarkRequest: Build provider-specific benchmark request.
@@ -160,17 +176,8 @@ export function buildBenchmarkRequest(apiKey, modelId, providerKey, url) {
 // 📖     totalMs: 15000,
 // 📖     error: "Request timed out"
 // 📖   }
-export async function benchmarkModel({ apiKey, modelId, providerKey, url, timeoutMs = BENCHMARK_TIMEOUT_MS }) {
-  // 📖 Guard: unsupported providers that don't do chat completions
-  if (providerKey === 'rovo' || providerKey === 'gemini' || providerKey === 'opencode-zen') {
-    return {
-      ok: false,
-      code: 'UNSUPPORTED',
-      totalMs: 0,
-      error: 'Provider does not support chat completions',
-    }
-  }
-
+// 📖 benchmarkSingleAttempt: One HTTP attempt. Extracted so the retry loop stays clean.
+async function benchmarkSingleAttempt({ apiKey, modelId, providerKey, url, timeoutMs }) {
   const ctrl = new AbortController()
   const timer = setTimeout(() => ctrl.abort(), timeoutMs)
   const t0 = performance.now()
@@ -188,14 +195,9 @@ export async function benchmarkModel({ apiKey, modelId, providerKey, url, timeou
 
     // 📖 Parse response body regardless of HTTP status so we can extract partial data
     let bodyText = ''
-    try {
-      bodyText = await resp.text()
-    } catch {}
-
+    try { bodyText = await resp.text() } catch {}
     let data = null
-    try {
-      data = JSON.parse(bodyText)
-    } catch {}
+    try { data = JSON.parse(bodyText) } catch {}
 
     // 📖 Non-2xx: return compact error code
     if (!resp.ok) {
@@ -217,11 +219,9 @@ export async function benchmarkModel({ apiKey, modelId, providerKey, url, timeou
     if (data?.usage?.completion_tokens != null) {
       outputTokens = Number(data.usage.completion_tokens) || 0
     } else {
-      // 📖 FALLBACK: estimate from character count when API omits usage
       outputTokens = estimateTokensFromText(content)
     }
 
-    // 📖 Guard division by zero
     const seconds = totalMs / 1000
     const tokensPerSecond = seconds > 0 ? outputTokens / seconds : 0
 
@@ -245,3 +245,47 @@ export async function benchmarkModel({ apiKey, modelId, providerKey, url, timeou
     clearTimeout(timer)
   }
 }
+
+// 📖 benchmarkModel: Retry wrapper — up to BENCHMARK_MAX_RETRIES attempts with
+// 📖 BENCHMARK_RETRY_DELAY_MS between failures. Models that are timeout, 429, down,
+// 📖 or auth-failing may succeed on a later attempt. The `retries` field in the
+// 📖 result tells the TUI how many attempts were needed (0 = first try, 2 = 3rd try).
+// 📖
+// 📖 Returns on success:
+// 📖   { ok: true, totalMs, outputTokens, tokensPerSecond, answerPreview, retries }
+// 📖
+// 📖 Returns on failure (all attempts exhausted):
+// 📖   { ok: false, code, totalMs, error, retries }
+export async function benchmarkModel({ apiKey, modelId, providerKey, url, timeoutMs = BENCHMARK_TIMEOUT_MS, maxRetries = BENCHMARK_MAX_RETRIES, retryDelayMs = BENCHMARK_RETRY_DELAY_MS }) {
+  // 📖 Guard: unsupported providers that don't do chat completions
+  if (providerKey === 'rovo' || providerKey === 'gemini' || providerKey === 'opencode-zen') {
+    return {
+      ok: false,
+      code: 'UNSUPPORTED',
+      totalMs: 0,
+      error: 'Provider does not support chat completions',
+      retries: 0,
+    }
+  }
+
+  let lastResult = null
+
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    lastResult = await benchmarkSingleAttempt({ apiKey, modelId, providerKey, url, timeoutMs })
+
+    // 📖 Success — return immediately with retry count
+    if (lastResult.ok) {
+      lastResult.retries = attempt
+      return lastResult
+    }
+
+    // 📖 Failed — wait before retrying (skip delay on last attempt)
+    if (attempt < maxRetries - 1) {
+      await new Promise(resolve => setTimeout(resolve, retryDelayMs))
+    }
+  }
+
+  // 📖 All attempts failed — return last error with retry count
+  lastResult.retries = maxRetries - 1
+  return lastResult
+}

package/src/cli-help.js

@@ -27,7 +27,7 @@ const ANALYSIS_FLAGS = [
   { flag: '--tier <S|A|B|C>', description: 'Filter models by tier family' },
   { flag: '--recommend', description: 'Open Smart Recommend immediately on startup' },
   { flag: '--premium', description: 'Start with S-tier filter + verdict sort (you can reset it in-app)' },
-  { flag: '--sort <column>', description: 'Sort by column (rank, tier, origin, model, ping, avg, swe, ctx, condition, verdict, uptime, stability, usage)' },
+  { flag: '--sort <column>', description: 'Sort by column (rank, tier, origin, model, ping, avg, swe, ctx, condition, verdict, uptime, stability, aiLatency, tps)' },
   { flag: '--desc | --asc', description: 'Set sort direction (descending or ascending)' },
   { flag: '--origin <provider>', description: 'Filter models by provider origin' },
   { flag: '--ping-interval <ms>', description: 'Override ping interval in milliseconds' },

package/src/config.js

@@ -242,6 +242,7 @@ function normalizeSettingsSection(settings) {
     ...safeSettings,
     hideUnconfiguredModels: typeof safeSettings.hideUnconfiguredModels === 'boolean' ? safeSettings.hideUnconfiguredModels : true,
     favoritesPinnedAndSticky: typeof safeSettings.favoritesPinnedAndSticky === 'boolean' ? safeSettings.favoritesPinnedAndSticky : false,
+    runAiSpeedTestOnStartup: typeof safeSettings.runAiSpeedTestOnStartup === 'boolean' ? safeSettings.runAiSpeedTestOnStartup : false,
     theme: ['dark', 'light', 'auto'].includes(safeSettings.theme) ? safeSettings.theme : 'auto',
   }
 }
@@ -1007,7 +1008,7 @@ export function isProviderEnabled(config, providerKey) {
 /**
  * 📖 _emptyProfileSettings: Default TUI settings.
  *
- * @returns {{ tierFilter: string|null, sortColumn: string, sortAsc: boolean, pingInterval: number, hideUnconfiguredModels: boolean, favoritesPinnedAndSticky: boolean, preferredToolMode: string, theme: string }}
+ * @returns {{ tierFilter: string|null, sortColumn: string, sortAsc: boolean, pingInterval: number, hideUnconfiguredModels: boolean, favoritesPinnedAndSticky: boolean, runAiSpeedTestOnStartup: boolean, preferredToolMode: string, theme: string }}
  */
 export function _emptyProfileSettings() {
   return {
@@ -1017,6 +1018,7 @@ export function _emptyProfileSettings() {
     pingInterval: 10000,  // 📖 default ms between pings in the steady "normal" mode
     hideUnconfiguredModels: true, // 📖 true = default to providers that are actually configured
     favoritesPinnedAndSticky: false, // 📖 default mode keeps favorites as normal starred rows; press Y to pin+stick them.
+    runAiSpeedTestOnStartup: false, // 📖 opt-in: automatically fire the Ctrl+U global AI Speed Test after startup.
     preferredToolMode: 'opencode', // 📖 remember the last Z-selected launcher across app restarts
     theme: 'auto',        // 📖 'auto' follows the terminal/OS theme, override with 'dark' or 'light' if needed
   }

package/src/key-handler.js

@@ -782,6 +782,21 @@ export function createKeyHandler(ctx) {
     applyThemeSetting(cycleThemeSetting(currentTheme))
   }
 
+  function toggleStartupAiSpeedScan() {
+    if (!state.config.settings || typeof state.config.settings !== 'object') state.config.settings = {}
+    state.config.settings.runAiSpeedTestOnStartup = state.config.settings.runAiSpeedTestOnStartup !== true
+    saveConfig(state.config)
+    state.settingsSyncStatus = {
+      type: 'success',
+      msg: state.config.settings.runAiSpeedTestOnStartup
+        ? '✅ Startup AI Speed Scan enabled — Ctrl+U benchmark will run after launch.'
+        : '✅ Startup AI Speed Scan disabled — use Ctrl+U manually when needed.',
+    }
+    trackAppAction('startup_ai_speed_scan_toggled', {
+      enabled: state.config.settings.runAiSpeedTestOnStartup === true,
+    })
+  }
+
   function toggleShellEnv() {
     if (!state.config.settings) state.config.settings = {}
     const currentlyEnabled = state.config.settings.shellEnvEnabled === true
@@ -877,6 +892,7 @@ export function createKeyHandler(ctx) {
     const visible = state.results.filter(r => !r.hidden)
     state.visibleSorted = sortResultsWithPinnedFavorites(visible, state.sortColumn, state.sortDirection, {
       pinFavorites: state.favoritesPinnedAndSticky,
+      benchmarkResults: state.benchmarkResults,
     })
     if (resetCursor) {
       state.cursor = 0
@@ -1040,6 +1056,31 @@ export function createKeyHandler(ctx) {
     saveConfig(state.config)
   }
 
+  // 📖 updateHealthFromBenchmark: When a benchmark reveals the real status of a model
+  // 📖 (e.g. it was marked 'down' but actually returns 429, or was 'timeout' but now responds),
+  // 📖 update the model's health status so the Health column stays accurate.
+  function updateHealthFromBenchmark(model, result) {
+    if (!result || result.ok) {
+      // 📖 Benchmark succeeded → model is definitely up
+      if (model.status !== 'up') model.status = 'up'
+      return
+    }
+    const code = result.code
+    if (code === 'TIMEOUT') {
+      model.status = 'timeout'
+    } else if (code === '401' || code === '403') {
+      const hasKey = !!getApiKey(state.config, model.providerKey)
+      model.status = hasKey ? 'auth_error' : 'noauth'
+      model.httpCode = code
+    } else if (code === '429') {
+      model.status = 'down'
+      model.httpCode = '429'
+    } else if (code && code !== 'ERR' && code !== 'UNSUPPORTED') {
+      model.status = 'down'
+      model.httpCode = code
+    }
+  }
+
   // 📖 runBenchmarkOnSelected: Fire a real-answer benchmark on the currently selected row.
   // 📖 Triggered by Ctrl+A. Async — does not block the UI. Results are stored in state
   // 📖 keyed by `${providerKey}/${modelId}` so they survive re-renders.
@@ -1052,7 +1093,8 @@ export function createKeyHandler(ctx) {
 
     const apiKey = getApiKey(state.config, selected.providerKey) ?? null
     const providerUrl = sources[selected.providerKey]?.url ?? null
-    if (!providerUrl) return
+    // 📖 No skip on missing URL — let benchmarkModel handle it. The whole point of Ctrl+A
+    // 📖 is to test models even when they're timeout, 429, down, or misconfigured.
 
     state.benchmarkRunning.add(benchmarkKey)
 
@@ -1064,6 +1106,7 @@ export function createKeyHandler(ctx) {
         url: providerUrl,
       })
       state.benchmarkResults[benchmarkKey] = result
+      updateHealthFromBenchmark(selected, result)
     } catch (err) {
       state.benchmarkResults[benchmarkKey] = {
         ok: false,
@@ -1100,7 +1143,20 @@ export function createKeyHandler(ctx) {
     if (state.globalBenchmarkRunning) return
     state.globalBenchmarkRunning = true
 
-    const models = state.visibleSorted
+    // 📖 Use state.results (ALL models) instead of state.visibleSorted so the benchmark
+    // 📖 runs on every model regardless of TUI filters. Zero filtering.
+    // 📖 Sort smart: UP models with low ping first (they finish fast and give instant feedback),
+    // 📖 then timeout/down/429 models last (they take longer and may need retries).
+    const healthPriority = { up: 0, pending: 1, timeout: 2, noauth: 3, auth_error: 4, down: 5 }
+    const models = [...state.results].sort((a, b) => {
+      const hpA = healthPriority[a.status] ?? 6
+      const hpB = healthPriority[b.status] ?? 6
+      if (hpA !== hpB) return hpA - hpB
+      // 📖 Same health → sort by latest ping (lower first, timeouts/downtimes to end)
+      const pingA = typeof a.pings?.[a.pings.length - 1]?.ms === 'number' ? a.pings[a.pings.length - 1].ms : 99999
+      const pingB = typeof b.pings?.[b.pings.length - 1]?.ms === 'number' ? b.pings[b.pings.length - 1].ms : 99999
+      return pingA - pingB
+    })
     const total = models.length
     state.globalBenchmarkTotal = total
     state.globalBenchmarkCompleted = 0
@@ -1115,10 +1171,6 @@ export function createKeyHandler(ctx) {
 
       const apiKey = getApiKey(state.config, model.providerKey) ?? null
       const providerUrl = sources[model.providerKey]?.url ?? null
-      if (!providerUrl) {
-        state.globalBenchmarkCompleted++
-        return { skipped: true }
-      }
 
       state.benchmarkRunning.add(benchmarkKey)
       try {
@@ -1129,6 +1181,7 @@ export function createKeyHandler(ctx) {
           url: providerUrl,
         })
         state.benchmarkResults[benchmarkKey] = result
+        updateHealthFromBenchmark(model, result)
         return { ok: result.ok }
       } catch (err) {
         state.benchmarkResults[benchmarkKey] = {
@@ -1462,7 +1515,9 @@ export function createKeyHandler(ctx) {
     }
 
     // 📖 Ctrl+U: Global AI Speed Benchmark (benchmark all visible models, 5 concurrent)
-    if (key.ctrl && key.name === 'u') {
+    // 📖 Also handles the raw \x15 byte as a fallback for terminals where readline doesn't
+    // 📖 set key.ctrl properly (same pattern as Ctrl+C → \x03 fallback).
+    if ((key.ctrl && key.name === 'u') || str === '\x15') {
       await runGlobalBenchmark(state)
       return
     }
@@ -2473,7 +2528,8 @@ export function createKeyHandler(ctx) {
       const updateRowIdx = providerKeys.length
       const themeRowIdx = updateRowIdx + 1
       const favoritesModeRowIdx = themeRowIdx + 1
-      const cleanupLegacyProxyRowIdx = favoritesModeRowIdx + 1
+      const startupAiSpeedScanRowIdx = favoritesModeRowIdx + 1
+      const cleanupLegacyProxyRowIdx = startupAiSpeedScanRowIdx + 1
       const changelogViewRowIdx = cleanupLegacyProxyRowIdx + 1
       const shellEnvRowIdx = changelogViewRowIdx + 1
         // 📖 Profile system removed - API keys now persist permanently across all sessions
@@ -2630,6 +2686,11 @@ export function createKeyHandler(ctx) {
           return
         }
 
+        if (state.settingsCursor === startupAiSpeedScanRowIdx) {
+          toggleStartupAiSpeedScan()
+          return
+        }
+
         if (state.settingsCursor === cleanupLegacyProxyRowIdx) {
           runLegacyProxyCleanup()
           return
@@ -2683,6 +2744,10 @@ export function createKeyHandler(ctx) {
           toggleFavoritesDisplayMode()
           return
         }
+        if (state.settingsCursor === startupAiSpeedScanRowIdx) {
+          toggleStartupAiSpeedScan()
+          return
+        }
         // 📖 Profile system removed - API keys now persist permanently across all sessions
 
         // 📖 Toggle enabled/disabled for selected provider
@@ -2699,6 +2764,7 @@ export function createKeyHandler(ctx) {
           state.settingsCursor === updateRowIdx
           || state.settingsCursor === themeRowIdx
           || state.settingsCursor === favoritesModeRowIdx
+          || state.settingsCursor === startupAiSpeedScanRowIdx
           || state.settingsCursor === cleanupLegacyProxyRowIdx
           || state.settingsCursor === changelogViewRowIdx
         ) return
@@ -3084,10 +3150,14 @@ export function createMouseEventHandler(ctx) {
       state.sortColumn = col
       state.sortDirection = 'asc'
     }
+    // 📖 Trigger header flash animation (3 frames ≈ 250ms at 12 FPS)
+    state.headerFlashColumn = col
+    state.headerFlashUntilFrame = state.frame + 3
     // 📖 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,
+      benchmarkResults: state.benchmarkResults,
     })
   }
 
@@ -3112,6 +3182,7 @@ export function createMouseEventHandler(ctx) {
     const visible = state.results.filter(r => !r.hidden)
     state.visibleSorted = sortResultsWithPinnedFavorites(visible, state.sortColumn, state.sortDirection, {
       pinFavorites: state.favoritesPinnedAndSticky,
+      benchmarkResults: state.benchmarkResults,
     })
     // 📖 If we unfavorited while pinned mode is on, reset cursor to top
     if (wasFavorite && state.favoritesPinnedAndSticky) {
@@ -3422,11 +3493,14 @@ export function createMouseEventHandler(ctx) {
           persistUiSettings()
         } else if (col.name === 'tier') {
           // 📖 Clicking the Tier header cycles the tier filter (same as T key)
+          state.headerFlashColumn = 'tier'
+          state.headerFlashUntilFrame = state.frame + 3
           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,
+            benchmarkResults: state.benchmarkResults,
           })
           state.cursor = 0
           state.scrollOffset = 0

package/src/overlays.js

@@ -118,7 +118,8 @@ export function createOverlayRenderers(state, deps) {
     const updateRowIdx = providerKeys.length
     const themeRowIdx = updateRowIdx + 1
     const favoritesModeRowIdx = themeRowIdx + 1
-    const cleanupLegacyProxyRowIdx = favoritesModeRowIdx + 1
+    const startupAiSpeedScanRowIdx = favoritesModeRowIdx + 1
+    const cleanupLegacyProxyRowIdx = startupAiSpeedScanRowIdx + 1
     const changelogViewRowIdx = cleanupLegacyProxyRowIdx + 1
     const shellEnvRowIdx = changelogViewRowIdx + 1
     const EL = '\x1b[K'
@@ -259,6 +260,15 @@ export function createOverlayRenderers(state, deps) {
     cursorLineByRow[favoritesModeRowIdx] = lines.length
     lines.push(state.settingsCursor === favoritesModeRowIdx ? themeColors.bgCursorSettingsList(favoritesModeRow) : favoritesModeRow)
 
+    // 📖 Startup AI Speed Scan row controls the opt-in Ctrl+U auto-run at launch.
+    const startupAiSpeedScanEnabled = state.config.settings?.runAiSpeedTestOnStartup === true
+    const startupAiSpeedScanStatus = startupAiSpeedScanEnabled
+      ? themeColors.successBold('✅ Enabled — runs Ctrl+U after startup')
+      : themeColors.dim('❌ Disabled — manual Ctrl+U only')
+    const startupAiSpeedScanRow = `${bullet(state.settingsCursor === startupAiSpeedScanRowIdx)}${themeColors.textBold('Startup AI Speed Scan').padEnd(44)} ${startupAiSpeedScanStatus}`
+    cursorLineByRow[startupAiSpeedScanRowIdx] = lines.length
+    lines.push(state.settingsCursor === startupAiSpeedScanRowIdx ? themeColors.bgCursorSettingsList(startupAiSpeedScanRow) : startupAiSpeedScanRow)
+
     if (updateState === 'error' && state.settingsUpdateError) {
       lines.push(themeColors.error(`      ${state.settingsUpdateError}`))
     }
@@ -290,7 +300,7 @@ export function createOverlayRenderers(state, deps) {
     if (state.settingsEditMode) {
       lines.push(themeColors.dim('  Type API key  •  Enter Save  •  Esc Cancel'))
     } else {
-      lines.push(themeColors.dim('  ↑↓ Navigate  •  Enter Edit/Run/Cycle  •  + Add key  •  - Remove key  •  Space Toggle/Cycle  •  T Test key  •  U Updates  •  G Global theme  •  Y Favorites mode  •  Esc Close'))
+      lines.push(themeColors.dim('  ↑↓ Navigate  •  Enter Edit/Run/Cycle  •  + Add key  •  - Remove key  •  Space Toggle/Cycle  •  T Test key  •  U Updates  •  G Theme  •  Y Favorites  •  Esc Close'))
     }
     // 📖 Show sync/restore status message if set
     if (state.settingsSyncStatus) {
@@ -897,10 +907,10 @@ export function createOverlayRenderers(state, deps) {
     lines.push(`  ${label('Provider')}    Provider source (NIM, Groq, Cerebras, etc.)  ${hint('Sort:')} ${key('O')}  ${hint('Cycle:')} ${key('D')}`)
     lines.push(`              ${hint('Same model on different providers can have very different speed and uptime.')}`)
     lines.push('')
-    lines.push(`  ${label('Latest')}      Most recent ping response time (ms)  ${hint('Sort:')} ${key('L')}`)
+    lines.push(`  ${label('Last Ping')}   Most recent ping response time (ms)  ${hint('Sort:')} ${key('L')}`)
     lines.push(`              ${hint('Shows how fast the server is responding right now — useful to catch live slowdowns.')}`)
     lines.push('')
-    lines.push(`  ${label('Avg Ping')}    Average response time across all measurable pings (200 + 401) (ms)  ${hint('Sort:')} ${key('A')}`)
+    lines.push(`  ${label('Avg Ping')}   Average response time across all measurable pings (200 + 401) (ms)  ${hint('Sort:')} ${key('A')}`)
     lines.push(`              ${hint('The long-term truth. Even without a key, a 401 still gives real latency so the average stays useful.')}`)
     lines.push('')
     lines.push(`  ${label('Health')}      Live status: ✅ UP / 🔥 429 / ⏳ TIMEOUT / ❌ ERR / 🔑 NO KEY  ${hint('Sort:')} ${key('H')}`)
@@ -931,6 +941,7 @@ export function createOverlayRenderers(state, deps) {
     lines.push(`  ${key('W')}  Toggle ping mode  ${hint('(speed 2s → normal 10s → slow 30s → forced 4s)')}`)
     lines.push(`  ${key('Ctrl+P')}  Open ⚡️ command palette  ${hint('(search and run actions quickly)')}`)
     lines.push(`  ${key('Ctrl+A')}  AI Speed Test  ${hint('(benchmark selected model → time + TPS)')}`)
+    lines.push(`  ${key('Ctrl+U')}  Global AI Speed Test  ${hint('(benchmark all models; Settings can auto-run it on startup)')}`)
     lines.push(`  ${key('E')}  Cycle filter mode  ${hint('(Normal → Configured only → Usable only)')}`)
     lines.push(`  ${key('Z')}  Cycle tool mode  ${hint('(📦 OpenCode → π Pi → 🪼 jcode → 📦 Desktop → 🦞 OpenClaw → 💘 Crush → 🪿 Goose → 🛠 Aider → 🐉 Qwen → 🤲 OpenHands → ⚡ Amp → 🦘 Rovo → ♊ Gemini)')}`)
     lines.push(`  ${key('F')}  Toggle favorite on selected row  ${hint('(1️⃣2️⃣3️⃣ = router fallback order, capped at 🔟)')}`)

package/src/render-helpers.js

@@ -202,7 +202,7 @@ export function calculateViewport(terminalRows, scrollOffset, totalModels, lineB
 // 📖 Non-favorites: active sort column/direction.
 // 📖 Models that are both recommended AND favorite — show in recommended section.
 // 📖 pinFavorites=false keeps favorites highlighted but lets normal sort/filter order apply.
-export function sortResultsWithPinnedFavorites(results, sortColumn, sortDirection, { pinFavorites = true } = {}) {
+export function sortResultsWithPinnedFavorites(results, sortColumn, sortDirection, { pinFavorites = true, benchmarkResults = {} } = {}) {
   if (!pinFavorites) {
     const recommendedRows = results
       .filter((r) => r.isRecommended)
@@ -210,7 +210,8 @@ export function sortResultsWithPinnedFavorites(results, sortColumn, sortDirectio
     const nonRecommendedRows = sortResults(
       results.filter((r) => !r.isRecommended),
       sortColumn,
-      sortDirection
+      sortDirection,
+      { benchmarkResults }
     )
     return [...recommendedRows, ...nonRecommendedRows]
   }
@@ -224,7 +225,7 @@ export function sortResultsWithPinnedFavorites(results, sortColumn, sortDirectio
   const bothRows = results
     .filter((r) => r.isRecommended && r.isFavorite)
     .sort((a, b) => (b.recommendScore || 0) - (a.recommendScore || 0))
-  const nonSpecialRows = sortResults(results.filter((r) => !r.isFavorite && !r.isRecommended), sortColumn, sortDirection)
+  const nonSpecialRows = sortResults(results.filter((r) => !r.isFavorite && !r.isRecommended), sortColumn, sortDirection, { benchmarkResults })
   return [...bothRows, ...recommendedRows, ...favoriteRows, ...nonSpecialRows]
 }