free-coding-models 0.3.79 → 0.4.0

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,11 +45,11 @@ 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'
-import { formatBenchmarkResult } from './benchmark.js'
+import { formatBenchmarkLatency, formatBenchmarkTps } from './benchmark.js'
 import { calculateViewport, sortResultsWithPinnedFavorites, padEndDisplay, displayWidth, stripAnsi } from './render-helpers.js'
 import { getToolMeta, TOOL_METADATA, TOOL_MODE_ORDER, isModelCompatibleWithTool } from './tool-metadata.js'
 import { getColumnSpacing } from './ui-config.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,6 +92,8 @@ const COLUMN_SORT_MAP = {
   verdict: 'verdict',
   stability: 'stability',
   uptime: 'uptime',
+  aiLatency: 'aiLatency',
+  tps: 'tps',
 }
 export { COLUMN_SORT_MAP }
 
@@ -184,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)
 
@@ -268,16 +272,18 @@ 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_ANSWER = 14
+  const W_AI_LATENCY = 17
+  const W_TPS = 5
 
   // const W_TOKENS = 7 // Used column removed
   // const W_USAGE = 7 // Usage column removed
@@ -285,17 +291,19 @@ 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 → Answer Speed → 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)
-  // 📖 Breakpoints: full=183 | compact=160 | -Rank=151 | -Answer=142 | -Up%=133 | -Tier=125 | -Stab=114
-  let wPing = 14
-  let wAvg = 11
+  // 📖 Hiding order (least useful first): Rank → AI Latency/TPS → Up% → Tier → Stability
+  // 📖 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 = 9
+  let wAvg = 9
   let wStab = 11
   let wSource = W_SOURCE
   let wStatus = W_STATUS
+  let wAiLatency = W_AI_LATENCY
   let showRank = true
-  let showAnswerSpeed = true
+  let showBenchmarkColumns = true
   let showUptime = true
   let showTier = true
   let showStability = true
@@ -305,27 +313,29 @@ 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)
       if (showStability) cols.push(wStab)
       if (showUptime) cols.push(W_UPTIME)
-      if (showAnswerSpeed) cols.push(W_ANSWER)
+      if (showBenchmarkColumns) cols.push(wAiLatency, W_TPS)
       return ROW_MARGIN + cols.reduce((a, b) => a + b, 0) + (cols.length - 1) * SEP_W
     }
 
     // 📖 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 + '…'
+      wAiLatency = 13 // Mirror compact Health text when health is not good
     }
     // 📖 Steps 2–6: Progressive column hiding (least useful first)
     if (calcWidth() > terminalCols) showRank = false
-    if (calcWidth() > terminalCols) showAnswerSpeed = false
+    if (calcWidth() > terminalCols) showBenchmarkColumns = false
     if (calcWidth() > terminalCols) showUptime = false
     if (calcWidth() > terminalCols) showTier = false
     if (calcWidth() > terminalCols) showStability = false
@@ -336,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 })
@@ -348,7 +359,10 @@ export function renderTable({
     colDefs.push({ name: 'verdict', width: W_VERDICT })
     if (showStability) colDefs.push({ name: 'stability', width: wStab })
     if (showUptime) colDefs.push({ name: 'uptime', width: W_UPTIME })
-    if (showAnswerSpeed) colDefs.push({ name: 'answerSpeed', width: W_ANSWER })
+    if (showBenchmarkColumns) {
+      colDefs.push({ name: 'aiLatency', width: wAiLatency })
+      colDefs.push({ name: 'tps', width: W_TPS })
+    }
     let x = ROW_MARGIN + 1 // 📖 1-based: first column starts after the 2-char left margin
     const columns = []
     for (let i = 0; i < colDefs.length; i++) {
@@ -394,6 +408,7 @@ export function renderTable({
   // 📖 Sort models using the shared helper
   const sorted = sortResultsWithPinnedFavorites(visibleResults, sortColumn, sortDirection, {
     pinFavorites: favoritesPinnedAndSticky,
+    benchmarkResults,
   })
 
   const lines = [
@@ -410,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
@@ -439,59 +450,130 @@ 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)
+  })()
 
-  // 📖 Answer Speed header — renamed to AI Speed, no sort hotkey
-  const answerLabel = isCompact ? 'AI Sp.' : 'AI Speed'
-  const answerH_c = (() => {
-    const plain = answerLabel
-    const padding = ' '.repeat(Math.max(0, W_ANSWER - plain.length))
+  // 📖 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)
   })()
 
   // 📖 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)
   if (showStability) headerParts.push(stabH_c)
   if (showUptime) headerParts.push(uptimeH_c)
-  if (showAnswerSpeed) headerParts.push(answerH_c)
+  if (showBenchmarkColumns) headerParts.push(aiLatencyH_c, tpsH_c)
   lines.push('  ' + headerParts.join(COL_SEP))
 
   // 📖 Mouse support: the column header row is the last line we just pushed.
@@ -702,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
@@ -793,33 +886,61 @@ export function renderTable({
     // (We keep the logic but do not render it.)
     const usageCell = ''
 
-    // 📖 Answer Speed column — show benchmark result, running spinner, or dash
+    // 📖 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)
-    let answerSpeedCell
-    if (isBenchmarkRunning) {
-      const spinner = FRAMES[frame % FRAMES.length]
-      answerSpeedCell = themeColors.success(spinner.padEnd(W_ANSWER))
-    } else if (benchmarkResult) {
-      const text = formatBenchmarkResult(benchmarkResult)
-      // 📖 Colorize: success = green, error = red/dim
-      const isError = !benchmarkResult.ok
-      answerSpeedCell = isError
-        ? themeColors.metricBad(text.padEnd(W_ANSWER))
-        : themeColors.metricGood(text.padEnd(W_ANSWER))
-    } else {
-      answerSpeedCell = themeColors.dim('—'.padEnd(W_ANSWER))
-    }
+    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)
     if (showStability) rowParts.push(stabCell)
     if (showUptime) rowParts.push(uptimeCell)
-    if (showAnswerSpeed) rowParts.push(answerSpeedCell)
+    if (showBenchmarkColumns) rowParts.push(latencyCell, tpsCell)
     const row = '  ' + rowParts.join(COL_SEP)
 
     if (isCursor) {

package/src/router-daemon.js

@@ -47,7 +47,7 @@ import {
   normalizeRouterConfig,
   saveConfig,
 } from './config.js'
-import { resolveCloudflareUrl } from './ping.js'
+import { buildChatCompletionPingBody, resolveCloudflareUrl, shouldUseDisabledThinkingForProvider } from './ping.js'
 import { sendUsageTelemetry } from './telemetry.js'
 
 export const ROUTER_DEFAULT_PORT = 19280
@@ -1200,12 +1200,11 @@ class RouterRuntime {
         : await fetch(providerUrl, {
             method: 'POST',
             headers: cloneHeadersForUpstream({}, apiKey, candidate.provider),
-            body: JSON.stringify({
-              model: getApiModelId(candidate.provider, candidate.model),
-              messages: [{ role: 'user', content: 'hi' }],
-              max_tokens: 1,
-              stream: false,
-            }),
+            body: JSON.stringify(buildChatCompletionPingBody(
+              getApiModelId(candidate.provider, candidate.model),
+              { stream: false },
+              { disableThinking: shouldUseDisabledThinkingForProvider(candidate.provider) }
+            )),
             signal: controller.signal,
           })
       const latencyMs = Math.round(performance.now() - started)

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
   }
 }