free-coding-models 0.3.80 → 0.4.1

package/src/render-table.js

@@ -8,7 +8,7 @@
  *   with consistent alignment, colorization, and viewport clipping.
  *
  *   🎯 Key features:
- *   - Full table layout with tier, latency, stability, uptime, token totals, and usage columns
+ *   - Full table layout with micro verdict indicator, tier, latency, stability, uptime, token totals, and usage columns
  *   - Hotkey-aware header lettering so highlighted letters always match live sort/filter keys
  *   - Emoji-aware padding via padEndDisplay for aligned verdict/status cells
  *   - Viewport clipping with above/below indicators
@@ -45,7 +45,7 @@ import {
   TABLE_FOOTER_LINES,
   FRAMES
 } from './constants.js'
-import { themeColors, getProviderRgb, getTierRgb, getReadableTextRgb, getTheme } from './theme.js'
+import { themeColors, currentPalette, getProviderRgb, getTierRgb, getReadableTextRgb, getTheme } from './theme.js'
 import { TIER_COLOR } from './tier-colors.js'
 import { getAvg, getVerdict, getUptime, getStabilityScore, getVersionStatusInfo } from './utils.js'
 import { usagePlaceholderForProvider } from './ping.js'
@@ -79,6 +79,7 @@ export function getLastLayout() { return _lastLayout }
 
 // 📖 Column name → sort key mapping for mouse click-to-sort on header row
 const COLUMN_SORT_MAP = {
+  mood: 'verdict',
   rank: 'rank',
   tier: null, // 📖 Tier column click cycles tier filter rather than sorting
   swe: 'swe',
@@ -91,8 +92,8 @@ const COLUMN_SORT_MAP = {
   verdict: 'verdict',
   stability: 'stability',
   uptime: 'uptime',
-  aiLatency: null,
-  tps: null,
+  aiLatency: 'aiLatency',
+  tps: 'tps',
 }
 export { COLUMN_SORT_MAP }
 
@@ -186,7 +187,8 @@ export function renderTable({
   routerFooterRequests = 0,
   benchmarkResults = {},
   benchmarkRunning = new Set(),
-} = {}) {
+  headerFlashColumn = null,
+} = _) {
   // 📖 Filter out hidden models for display
   const visibleResults = results.filter(r => !r.hidden)
 
@@ -270,16 +272,17 @@ export function renderTable({
   const COL_SEP = getColumnSpacing()
   const SEP_W = 3  // ' │ ' display width
   const ROW_MARGIN = 2  // left margin '  '
+  const W_MOOD = 2
   const W_RANK = 6
   const W_TIER = 5
   const W_CTX = 4
   const W_SOURCE = 14
   const W_MODEL = 26
   const W_SWE = 5
-  const W_STATUS = 18
-  const W_VERDICT = 14
+  const W_STATUS = 17
+  const W_VERDICT = 13
   const W_UPTIME = 6
-  const W_AI_LATENCY = 18
+  const W_AI_LATENCY = 17
   const W_TPS = 5
 
   // const W_TOKENS = 7 // Used column removed
@@ -289,11 +292,12 @@ export function renderTable({
   // 📖 Responsive column visibility: progressively hide least-useful columns
   // 📖 and shorten header labels when terminal width is insufficient.
   // 📖 Hiding order (least useful first): Rank → AI Latency/TPS → Up% → Tier → Stability
-  // 📖 Compact mode shrinks: Latest Ping→Lat. P (9), Avg Ping→Avg. P (8),
-  // 📖 Stability→StaB. (8), Provider→4chars+… (7), Health→6chars+… (13)
+  // 📖 Ping columns stay compact because the cell values are tiny numbers without a "ms" suffix.
+  // 📖 Both ping columns use the same 9-char width so Last Ping and Avg Ping fit cleanly.
+  // 📖 Compact mode also shrinks Stability→StaB. (8), Provider→4chars+… (7), Health→6chars+… (13).
   // 📖 Breakpoints are computed dynamically from active column widths.
-  let wPing = 14
-  let wAvg = 11
+  let wPing = 9
+  let wAvg = 9
   let wStab = 11
   let wSource = W_SOURCE
   let wStatus = W_STATUS
@@ -309,6 +313,7 @@ export function renderTable({
     // 📖 Dynamically compute needed row width from visible columns
     const calcWidth = () => {
       const cols = []
+      cols.push(W_MOOD)
       if (showRank) cols.push(W_RANK)
       if (showTier) cols.push(W_TIER)
       cols.push(W_SWE, W_CTX, W_MODEL, wSource, wPing, wAvg, wStatus, W_VERDICT)
@@ -321,8 +326,8 @@ export function renderTable({
     // 📖 Step 1: Compact mode — shorten labels and reduce column widths
     if (calcWidth() > terminalCols) {
       isCompact = true
-      wPing = 9      // 'Lat. P' instead of 'Latest Ping'
-      wAvg = 8       // 'Avg. P' instead of 'Avg Ping'
+      wPing = 9      // 'Last Ping' stays compact and matches Avg Ping width
+      wAvg = 9       // 'Avg Ping' stays aligned with Last Ping
       wStab = 8      // 'StaB.' instead of 'Stability'
       wSource = 7    // Provider truncated to 4 chars + '…', 7 cols total
       wStatus = 13   // Health truncated after 6 chars + '…'
@@ -341,6 +346,7 @@ export function renderTable({
   // 📖 matching exactly what renderTable paints so click-to-sort hits the right column.
   {
     const colDefs = []
+    colDefs.push({ name: 'mood', width: W_MOOD })
     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 })
@@ -402,6 +408,7 @@ export function renderTable({
   // 📖 Sort models using the shared helper
   const sorted = sortResultsWithPinnedFavorites(visibleResults, sortColumn, sortDirection, {
     pinFavorites: favoritesPinnedAndSticky,
+    benchmarkResults,
   })
 
   const lines = [
@@ -418,24 +425,20 @@ export function renderTable({
   // 📖 Solution: build plain text first, then colorize
   const dir = sortDirection === 'asc' ? '↑' : '↓'
 
-  const rankH    = 'Rank'
-  const tierH    = 'Tier'
-  const originH  = 'Provider'
-  const modelH   = 'Model'
-  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'
-  const stabLabel = isCompact ? 'StaB.' : 'Stability'
-  const pingH    = sortColumn === 'ping' ? dir + ' ' + pingLabel : pingLabel
-  const avgH     = sortColumn === 'avg' ? dir + ' ' + avgLabel : avgLabel
-  const healthH  = sortColumn === 'condition' ? dir + ' Health' : 'Health'
-  const verdictH = sortColumn === 'verdict' ? dir + ' Verdict' : 'Verdict'
-  // 📖 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%'
+  // 📖 Plain header labels — arrows are appended dynamically below.
+  const moodLabel    = '❔'
+  const rankLabel    = 'Rank'
+  const tierLabel    = 'Tier'
+  const originLabel  = isCompact ? 'PrOD…' : 'Provider'
+  const modelLabel   = 'Model'
+  const sweLabel     = 'SWE%'
+  const ctxLabel     = 'CTX'
+  const pingLabel    = 'Last Ping'
+  const avgLabel     = 'Avg Ping'
+  const healthLabel  = 'Health'
+  const verdictLabel = 'Verdict'
+  const stabLabel    = isCompact ? 'StaB.' : 'Stability'
+  const uptimeLabel  = 'Up%'
 
   // 📖 Helper to colorize first letter for keyboard shortcuts
   // 📖 IMPORTANT: Pad PLAIN TEXT first, then apply colors to avoid alignment issues
@@ -447,50 +450,116 @@ export function renderTable({
     return colorFn(first) + themeColors.dim(rest + padding)
   }
 
-  // 📖 Now colorize after padding is calculated on plain text
-  const rankH_c    = colorFirst(rankH, W_RANK)
-  const tierH_c    = colorFirst('Tier', W_TIER)
-  const originLabel = isCompact ? 'PrOD…' : 'Provider'
-  const originH_c  = sortColumn === 'origin'
-    ? themeColors.accentBold(originLabel.padEnd(wSource))
-    : (originFilterMode > 0 ? themeColors.accentBold(originLabel.padEnd(wSource)) : (() => {
-      // 📖 Provider keeps O for sorting and D for provider-filter cycling.
-      // 📖 In compact mode, shorten to 'PrOD…' (4 chars + ellipsis) to save space.
-      const plain = isCompact ? 'PrOD…' : 'PrOviDer'
-      const padding = ' '.repeat(Math.max(0, wSource - plain.length))
-      if (isCompact) {
-        return themeColors.dim('Pr') + themeColors.hotkey('O') + themeColors.hotkey('D') + themeColors.dim('…' + padding)
-      }
-      return themeColors.dim('Pr') + themeColors.hotkey('O') + themeColors.dim('vi') + themeColors.hotkey('D') + themeColors.dim('er' + padding)
-    })())
-  const modelH_c   = colorFirst(modelH, W_MODEL)
-  const sweH_c     = sortColumn === 'swe' ? themeColors.accentBold(sweH.padEnd(W_SWE)) : colorFirst(sweH, W_SWE)
-  const ctxH_c     = sortColumn === 'ctx' ? themeColors.accentBold(ctxH.padEnd(W_CTX)) : colorFirst(ctxH, W_CTX)
-  const pingH_c    = sortColumn === 'ping' ? themeColors.accentBold(pingH.padEnd(wPing)) : colorFirst(pingLabel, wPing)
-  const avgH_c     = sortColumn === 'avg' ? themeColors.accentBold(avgH.padEnd(wAvg)) : colorFirst(avgLabel, wAvg)
-  const healthH_c  = sortColumn === 'condition' ? themeColors.accentBold(healthH.padEnd(wStatus)) : colorFirst('Health', wStatus)
-  const verdictH_c = sortColumn === 'verdict' ? themeColors.accentBold(verdictH.padEnd(W_VERDICT)) : colorFirst(verdictH, W_VERDICT)
-  // 📖 Custom colorization for Stability: highlight 'B' (the sort key) since 'S' is taken by SWE
-  const stabH_c    = sortColumn === 'stability' ? themeColors.accentBold(stabH.padEnd(wStab)) : (() => {
+  // 📖 Flash animation: when a column header is clicked, it briefly renders with
+  // 📖 a vivid inverse style (bright accent bg + white bold fg) for ~250ms.
+  // 📖 This gives satisfying visual feedback that the click was registered.
+  const flashHeader = (plainText, width) => {
+    const padded = plainText.length <= width ? plainText.padEnd(width) : plainText.slice(0, width)
+    const [r, g, b] = currentPalette().accentStrong
+    return chalk.bold.rgb(255, 255, 255).bgRgb(r, g, b)(padded)
+  }
+
+  // 📖 Sort-active header: renders the column header with a subtle background color
+  // 📖 to visually indicate which column is currently sorted.
+  // 📖 Includes the ↑/↓ arrow and bold white text on a tinted background.
+  // 📖 If the arrow prefix doesn't fit, appends it: 'SWE↑' instead of '↑ SWE%'.
+  const sortActiveHeader = (label, width) => {
+    const arrow = dir
+    const prefixed = arrow + ' ' + label
+    const text = prefixed.length <= width ? prefixed : label + arrow
+    const padded = text.padEnd(width).slice(0, width)
+    // 📖 Subtle dark accent background — visible but not overwhelming.
+    const bg = currentPalette().cursor.defaultBg
+    return chalk.bold.rgb(255, 255, 255).bgRgb(...bg)(padded)
+  }
+
+  // 📖 Now colorize each column header.
+  // 📖 Three rendering states per column:
+  // 📖   1. FLASH  — headerFlashColumn matches → vivid inverse style (click feedback)
+  // 📖   2. ACTIVE — sortColumn matches → subtle bg + ↑/↓ arrow
+  // 📖   3. DEFAULT — normal dim text with highlighted first letter
+
+  // 📖 Helper: pick the right style for a standard column header.
+  // 📖 colKey = sort key (e.g. 'rank', 'swe'), label = plain text, width = column width.
+  const headerStyle = (colKey, label, width) => {
+    const arrowText = dir + ' ' + label
+    const flashText = arrowText.length <= width ? arrowText : label + dir
+    if (headerFlashColumn === colKey) return flashHeader(flashText, width)
+    if (sortColumn === colKey) return sortActiveHeader(label, width)
+    return colorFirst(label, width)
+  }
+
+  const moodH_c    = (() => {
+    // 📖 Tiny verdict indicator column: keep it emoji-only, no arrow, so it stays 2 cells wide.
+    const padded = padEndDisplay(moodLabel, W_MOOD)
+    if (headerFlashColumn === 'verdict') return chalk.bold.rgb(255, 255, 255).bgRgb(...currentPalette().accentStrong)(padded)
+    if (sortColumn === 'verdict') return chalk.bold.rgb(255, 255, 255).bgRgb(...currentPalette().cursor.defaultBg)(padded)
+    return themeColors.hotkey(padded)
+  })()
+  const rankH_c    = headerStyle('rank', rankLabel, W_RANK)
+  const tierH_c    = (() => {
+    if (headerFlashColumn === 'tier') return flashHeader(tierLabel, W_TIER)
+    return colorFirst(tierLabel, W_TIER)
+  })()
+  const modelH_c   = headerStyle('model', modelLabel, W_MODEL)
+  const sweH_c     = headerStyle('swe', sweLabel, W_SWE)
+  const ctxH_c     = headerStyle('ctx', ctxLabel, W_CTX)
+  const pingH_c    = headerStyle('ping', pingLabel, wPing)
+  const avgH_c     = headerStyle('avg', avgLabel, wAvg)
+  const healthH_c  = headerStyle('condition', healthLabel, wStatus)
+  const verdictH_c = headerStyle('verdict', verdictLabel, W_VERDICT)
+  const stabH_c    = (() => {
+    if (headerFlashColumn === 'stability') {
+      const ft = (dir + ' ' + stabLabel).length <= wStab ? dir + ' ' + stabLabel : stabLabel + dir
+      return flashHeader(ft, wStab)
+    }
+    if (sortColumn === 'stability') return sortActiveHeader(stabLabel, wStab)
     const plain = stabLabel
     const padding = ' '.repeat(Math.max(0, wStab - plain.length))
     return themeColors.dim('Sta') + themeColors.hotkey('B') + themeColors.dim((isCompact ? '.' : 'ility') + padding)
   })()
-  // 📖 Up% sorts on U, so keep the highlighted shortcut in the shared yellow sort-key color.
-  const uptimeH_c  = sortColumn === 'uptime' ? themeColors.accentBold(uptimeH.padEnd(W_UPTIME)) : (() => {
-    const plain = 'Up%'
-    const padding = ' '.repeat(Math.max(0, W_UPTIME - plain.length))
+  const uptimeH_c  = (() => {
+    if (headerFlashColumn === 'uptime') {
+      const ft = (dir + ' ' + uptimeLabel).length <= W_UPTIME ? dir + ' ' + uptimeLabel : uptimeLabel + dir
+      return flashHeader(ft, W_UPTIME)
+    }
+    if (sortColumn === 'uptime') return sortActiveHeader(uptimeLabel, W_UPTIME)
+    const padding = ' '.repeat(Math.max(0, W_UPTIME - uptimeLabel.length))
     return themeColors.hotkey('U') + themeColors.dim('p%' + padding)
   })()
+  const originH_c  = (() => {
+    if (headerFlashColumn === 'origin') {
+      const ft = (dir + ' ' + originLabel).length <= wSource ? dir + ' ' + originLabel : originLabel + dir
+      return flashHeader(ft, wSource)
+    }
+    if (sortColumn === 'origin') return sortActiveHeader(originLabel, wSource)
+    if (originFilterMode > 0) return themeColors.accentBold(originLabel.padEnd(wSource))
+    const plain = isCompact ? 'PrOD…' : 'PrOviDer'
+    const padding = ' '.repeat(Math.max(0, wSource - plain.length))
+    if (isCompact) {
+      return themeColors.dim('Pr') + themeColors.hotkey('O') + themeColors.hotkey('D') + themeColors.dim('…' + padding)
+    }
+    return themeColors.dim('Pr') + themeColors.hotkey('O') + themeColors.dim('vi') + themeColors.hotkey('D') + themeColors.dim('er' + padding)
+  })()
 
   // 📖 Benchmark headers — split the old combined AI Speed field into latency + throughput.
   const aiLatencyLabel = isCompact ? 'AI Lat.' : 'AI Latency'
   const aiLatencyH_c = (() => {
+    if (headerFlashColumn === 'aiLatency') {
+      const ft = (dir + ' ' + aiLatencyLabel).length <= wAiLatency ? dir + ' ' + aiLatencyLabel : aiLatencyLabel + dir
+      return flashHeader(ft, wAiLatency)
+    }
+    if (sortColumn === 'aiLatency') return sortActiveHeader(aiLatencyLabel, wAiLatency)
     const plain = aiLatencyLabel
     const padding = ' '.repeat(Math.max(0, wAiLatency - plain.length))
     return themeColors.dim(plain + padding)
   })()
   const tpsH_c = (() => {
+    if (headerFlashColumn === 'tps') {
+      const ft = (dir + ' ' + 'TPS').length <= W_TPS ? dir + ' ' + 'TPS' : 'TPS' + dir
+      return flashHeader(ft, W_TPS)
+    }
+    if (sortColumn === 'tps') return sortActiveHeader('TPS', W_TPS)
     const plain = 'TPS'
     const padding = ' '.repeat(Math.max(0, W_TPS - plain.length))
     return themeColors.dim(plain + padding)
@@ -498,7 +567,7 @@ export function renderTable({
 
   // 📖 Usage column removed from UI – no header or separator for it.
   // 📖 Header row: conditionally include columns based on responsive visibility
-  const headerParts = []
+  const headerParts = [moodH_c]
   if (showRank) headerParts.push(rankH_c)
   if (showTier) headerParts.push(tierH_c)
   headerParts.push(sweH_c, ctxH_c, modelH_c, originH_c, pingH_c, avgH_c, healthH_c, verdictH_c)
@@ -715,52 +784,63 @@ export function renderTable({
 
     // 📖 Verdict column - use getVerdict() for stability-aware verdicts, then render with emoji
     const verdict = getVerdict(r)
-    let verdictText, verdictColor
+    let verdictText, verdictIcon, verdictColor
     // 📖 Verdict colors follow the same green→red gradient as TIER_COLOR / SWE%
     switch (verdict) {
       case 'Perfect':
-        verdictText = 'Perfect 🚀'
+        verdictIcon = '🟩'
+        verdictText = `${verdictIcon} Perfect`
         verdictColor = themeColors.successBold
         break
       case 'Normal':
-        verdictText = 'Normal ✅'
+        verdictIcon = '🟢'
+        verdictText = `${verdictIcon} Normal`
         verdictColor = themeColors.metricGood
         break
       case 'Spiky':
-        verdictText = 'Spiky 📈'
+        verdictIcon = '🟡'
+        verdictText = `${verdictIcon} Spiky`
         verdictColor = (text) => chalk.bold.rgb(...getTierRgb('A+'))(text)
         break
       case 'Slow':
-        verdictText = 'Slow 🐢'
+        verdictIcon = '🟠'
+        verdictText = `${verdictIcon} Slow`
         verdictColor = (text) => chalk.bold.rgb(...getTierRgb('A-'))(text)
         break
       case 'Very Slow':
-        verdictText = 'Very Slow 🐌'
+        verdictIcon = '🔴'
+        verdictText = `${verdictIcon} Very Slow`
         verdictColor = (text) => chalk.bold.rgb(...getTierRgb('B+'))(text)
         break
       case 'Overloaded':
-        verdictText = 'Overloaded 🔥'
+        verdictIcon = '🔥'
+        verdictText = `${verdictIcon} Overloaded`
         verdictColor = (text) => chalk.bold.rgb(...getTierRgb('B'))(text)
         break
       case 'Unstable':
-        verdictText = 'Unstable  ⚠️'
+        verdictIcon = '⚠️'
+        verdictText = `${verdictIcon} Unstable`
         verdictColor = themeColors.errorBold
         break
       case 'Not Active':
-        verdictText = 'Not Active  👻'
+        verdictIcon = '⚫'
+        verdictText = `${verdictIcon} Not Active`
         verdictColor = themeColors.dim
         break
       case 'Pending':
-        verdictText = 'Pending ⏳'
+        verdictIcon = '⏳'
+        verdictText = `${verdictIcon} Pending`
         verdictColor = themeColors.dim
         break
       default:
-        verdictText = 'Unusable 💀'
+        verdictIcon = '💀'
+        verdictText = `${verdictIcon} Unusable`
         verdictColor = (text) => chalk.bold.rgb(...getTierRgb('C'))(text)
         break
     }
     // 📖 Use padEndDisplay to account for emoji display width (2 cols each) so all rows align
     const speedCell = verdictColor(padEndDisplay(verdictText, W_VERDICT))
+    const moodCell = padEndDisplay(verdictIcon, W_MOOD)
 
     // 📖 Stability column - composite score (0–100) from p95 + jitter + spikes + uptime
     // 📖 Left-aligned to sit flush under the column header
@@ -807,30 +887,54 @@ export function renderTable({
     const usageCell = ''
 
     // 📖 AI Latency + TPS columns — same benchmark result, split into two readable metrics.
+    // 📖 Benchmark results are shown regardless of health status (up/timeout/down/429/noauth).
+    // 📖 If benchmark failed → red dash. Error details live in the Health column.
+    // 📖 If no benchmark has been run yet, show dim dash.
+    // 📖 Retry badge (↻N) is colored blue and spaced from the main value.
     const benchmarkKey = `${r.providerKey}/${r.modelId}`
     const benchmarkResult = benchmarkResults[benchmarkKey]
     const isBenchmarkRunning = benchmarkRunning.has(benchmarkKey)
-    const healthIsGood = r.status === 'up'
-    const latencyText = healthIsGood
-      ? formatBenchmarkLatency(benchmarkResult, { running: isBenchmarkRunning, frame })
-      : statusDisplayText
-    const tpsText = healthIsGood
-      ? formatBenchmarkTps(benchmarkResult, { running: isBenchmarkRunning, frame })
-      : '—'
-    const benchmarkIsError = healthIsGood && benchmarkResult && !benchmarkResult.ok
-    const latencyCell = !healthIsGood
-      ? statusColor(padEndDisplay(latencyText, wAiLatency))
-      : benchmarkIsError
-        ? themeColors.metricBad(latencyText.padEnd(wAiLatency))
-        : benchmarkResult || isBenchmarkRunning
-          ? themeColors.metricGood(latencyText.padEnd(wAiLatency))
-          : themeColors.dim(latencyText.padEnd(wAiLatency))
-    const tpsCell = healthIsGood && (benchmarkResult?.ok || isBenchmarkRunning)
-      ? themeColors.metricGood(tpsText.padEnd(W_TPS))
-      : themeColors.dim(tpsText.padEnd(W_TPS))
+    const hasBenchmark = benchmarkResult || isBenchmarkRunning
+    const benchmarkOk = benchmarkResult && benchmarkResult.ok
+
+    // 📖 Build latency cell: value + blue retry badge
+    const latParsed = isBenchmarkRunning
+      ? formatBenchmarkLatency(benchmarkResult, { running: true, frame })
+      : benchmarkOk
+        ? formatBenchmarkLatency(benchmarkResult)
+        : { text: '—', retryBadge: '' }
+    const latValue = benchmarkOk
+      ? themeColors.metricGood(latParsed.text)
+      : hasBenchmark
+        ? themeColors.metricBad(latParsed.text)
+        : themeColors.dim(latParsed.text)
+    const latBadge = latParsed.retryBadge
+      ? themeColors.info(' ' + latParsed.retryBadge)
+      : ''
+    const latBadgeWidth = latParsed.retryBadge ? displayWidth(' ' + latParsed.retryBadge) : 0
+    const latPad = wAiLatency - displayWidth(latParsed.text) - latBadgeWidth
+    const latencyCell = latValue + latBadge + themeColors.dim(''.padEnd(Math.max(0, latPad)))
+
+    // 📖 Build TPS cell: value + blue retry badge
+    const tpsParsed = isBenchmarkRunning
+      ? formatBenchmarkTps(benchmarkResult, { running: true, frame })
+      : benchmarkOk
+        ? formatBenchmarkTps(benchmarkResult)
+        : { text: '—', retryBadge: '' }
+    const tpsValue = benchmarkOk || isBenchmarkRunning
+      ? themeColors.metricGood(tpsParsed.text)
+      : hasBenchmark
+        ? themeColors.metricBad(tpsParsed.text)
+        : themeColors.dim(tpsParsed.text)
+    const tpsBadge = tpsParsed.retryBadge
+      ? themeColors.info(' ' + tpsParsed.retryBadge)
+      : ''
+    const tpsBadgeWidth = tpsParsed.retryBadge ? displayWidth(' ' + tpsParsed.retryBadge) : 0
+    const tpsPad = W_TPS - displayWidth(tpsParsed.text) - tpsBadgeWidth
+    const tpsCell = tpsValue + tpsBadge + themeColors.dim(''.padEnd(Math.max(0, tpsPad)))
 
     // 📖 Build row: conditionally include columns based on responsive visibility
-    const rowParts = []
+    const rowParts = [moodCell]
     if (showRank) rowParts.push(num)
     if (showTier) rowParts.push(tier)
     rowParts.push(sweCell, ctxCell, nameCell, sourceCell, pingCell, avgCell, status, speedCell)

package/src/setup.js

@@ -16,8 +16,9 @@
  *   1. Builds a `providers` list from `Object.keys(sources)` so new providers added to
  *      sources.js automatically appear in the wizard without any code changes here.
  *   2. Uses `readline.createInterface` for line-at-a-time input (not raw mode).
- *   3. Calls `saveConfig(config)` once after collecting all answers.
- *   4. Returns the nvidia key (or the first entered key) for backward-compatibility with
+ *   3. Asks whether the opt-in startup AI Speed Test should run on every launch.
+ *   4. Calls `saveConfig(config)` once after collecting all answers.
+ *   5. Returns the nvidia key (or the first entered key) for backward-compatibility with
  *      the `main()` caller that originally checked for `nvidiKey !== null` before continuing.
  *
  * @functions
@@ -86,18 +87,27 @@ export async function promptApiKey(config) {
     }
   }
 
-  rl.close()
-
-  // 📖 Check at least one key was entered
+  // 📖 Check at least one key was entered before asking optional behavior questions.
   const anyKey = Object.values(config.apiKeys).some(v => v)
   if (!anyKey) {
+    rl.close()
     return null
   }
 
+  console.log(chalk.bold('  ⚡ Startup AI Speed Scan'))
+  console.log(chalk.dim('  FCM can automatically run the Ctrl+U benchmark after launch to fill AI Latency + TPS.'))
+  console.log(chalk.dim('  This uses real provider requests, so it is opt-in and can be changed later in Settings.'))
+  const autoBenchmarkAnswer = await ask(chalk.dim('  Run the AI Speed Scan automatically on every launch? (y/N): '))
+  if (!config.settings || typeof config.settings !== 'object') config.settings = {}
+  config.settings.runAiSpeedTestOnStartup = ['y', 'yes', 'oui', 'o'].includes(autoBenchmarkAnswer.toLowerCase())
+  console.log()
+
+  rl.close()
+
   saveConfig(config)
   const savedCount = Object.values(config.apiKeys).filter(v => v).length
   console.log(chalk.green(`  ✅ ${savedCount} key(s) saved to ~/.free-coding-models.json`))
-  console.log(chalk.dim('  You can add or change keys anytime with the ') + chalk.yellow('P') + chalk.dim(' key in the TUI.'))
+  console.log(chalk.dim('  You can add/change keys and toggle Startup AI Speed Scan anytime with the ') + chalk.yellow('P') + chalk.dim(' key in the TUI.'))
   console.log()
 
   // 📖 Return nvidia key for backward-compat (main() checks it exists before continuing)

package/src/theme.js

@@ -199,7 +199,7 @@ const TIER_PALETTES = {
   },
 }
 
-function currentPalette() {
+export function currentPalette() {
   return PALETTES[activeTheme] ?? PALETTES.dark
 }
 

package/src/tui-state.js

@@ -273,5 +273,10 @@ export function createTuiState({
     globalBenchmarkRunning: false,
     globalBenchmarkTotal: 0,
     globalBenchmarkCompleted: 0,
+
+    // 📖 Header click flash animation: briefly highlights the clicked column header
+    // 📖 with an inverse/bright style for ~250ms (3 frames at 12 FPS).
+    headerFlashColumn: null,       // 📖 Column name being flashed (null = no flash active)
+    headerFlashUntilFrame: 0,      // 📖 Frame number when flash expires
   }
 }

package/src/utils.js

@@ -235,7 +235,7 @@ export const getStabilityScore = (r) => {
 //   - 'stability' (B key) — stability score (0–100, higher = more stable)
 //
 // 📖 sortDirection 'asc' = ascending (smallest first), 'desc' = descending (largest first)
-export const sortResults = (results, sortColumn, sortDirection) => {
+export const sortResults = (results, sortColumn, sortDirection, { benchmarkResults = {} } = {}) => {
   return [...results].sort((a, b) => {
     let cmp = 0
 
@@ -317,6 +317,30 @@ export const sortResults = (results, sortColumn, sortDirection) => {
         // 📖 Models with no data (-1) sort to the bottom
         cmp = getStabilityScore(a) - getStabilityScore(b)
         break
+      case 'aiLatency': {
+        // 📖 Sort by AI benchmark latency (totalMs). Lower = better.
+        // 📖 Models without benchmark data sort to the bottom.
+        const aKey = `${a.providerKey}/${a.modelId}`
+        const bKey = `${b.providerKey}/${b.modelId}`
+        const aBench = benchmarkResults[aKey]
+        const bBench = benchmarkResults[bKey]
+        const aMs = (aBench?.ok && aBench.totalMs != null) ? aBench.totalMs : Infinity
+        const bMs = (bBench?.ok && bBench.totalMs != null) ? bBench.totalMs : Infinity
+        cmp = aMs - bMs
+        break
+      }
+      case 'tps': {
+        // 📖 Sort by benchmark throughput (tokens/second). Higher = better.
+        // 📖 Models without benchmark data sort to the bottom.
+        const aKey2 = `${a.providerKey}/${a.modelId}`
+        const bKey2 = `${b.providerKey}/${b.modelId}`
+        const aBench2 = benchmarkResults[aKey2]
+        const bBench2 = benchmarkResults[bKey2]
+        const aTps = (aBench2?.ok && aBench2.tokensPerSecond != null) ? aBench2.tokensPerSecond : -1
+        const bTps = (bBench2?.ok && bBench2.tokensPerSecond != null) ? bBench2.tokensPerSecond : -1
+        cmp = aTps - bTps
+        break
+      }
       case 'usage':
         // 📖 Sort by quota usage percent (usagePercent numeric field, 0–100)
         // 📖 Models with no usage data (undefined/null) are treated as 0 — stable tie-break