free-coding-models 0.1.84 → 0.1.85

package/README.md

@@ -72,7 +72,7 @@
 - **🚀 Parallel pings** — All models tested simultaneously via native `fetch`
 - **📊 Real-time animation** — Watch latency appear live in alternate screen buffer
 - **🏆 Smart ranking** — Top 3 fastest models highlighted with medals 🥇🥈🥉
-- **⏱ Continuous monitoring** — Pings all models every 3 seconds forever, never stops
+- **⏱ Adaptive monitoring** — Starts in a fast 2s cadence for 60s, settles to 10s, slows to 30s after 5 minutes idle, and supports a forced 4s mode
 - **📈 Rolling averages** — Avg calculated from ALL successful pings since start
 - **📊 Uptime tracking** — Percentage of successful pings shown in real-time
 - **📐 Stability score** — Composite 0–100 score measuring consistency (p95, jitter, spikes, uptime)
@@ -200,7 +200,7 @@ Use `↑↓` arrows to select, `Enter` to confirm. Then the TUI launches with yo
 
 **How it works:**
  1. **Ping phase** — All enabled models are pinged in parallel (up to 150 across 20 providers)
- 2. **Continuous monitoring** — Models are re-pinged every 3 seconds forever
+ 2. **Continuous monitoring** — Models start at 2s re-pings for 60s, then fall back to 10s automatically
 3. **Real-time updates** — Watch "Latest", "Avg", and "Up%" columns update live
 4. **Select anytime** — Use ↑↓ arrows to navigate, press Enter on a model to act
 5. **Smart detection** — Automatically detects if NVIDIA NIM is configured in OpenCode or OpenClaw
@@ -725,7 +725,7 @@ This script:
 │  1. Enter alternate screen buffer (like vim/htop/less)           │
 │  2. Ping ALL models in parallel                                  │
 │  3. Display real-time table with Latest/Avg/Stability/Up%        │
-│  4. Re-ping ALL models every 3 seconds (forever)               │
+│  4. Re-ping ALL models at 2s on startup, then 10s steady-state │
 │  5. Update rolling averages + stability scores per model        │
 │  6. User can navigate with ↑↓ and select with Enter            │
 │  7. On Enter (OpenCode): set model, launch OpenCode             │
@@ -803,7 +803,7 @@ This script:
 
 **Configuration:**
 - **Ping timeout**: 15 seconds per attempt (slow models get more time)
-- **Ping interval**: 3 seconds between complete re-pings of all models (adjustable with W/X keys)
+- **Ping cadence**: startup burst at 2 seconds for 60s, then 10 seconds normally, 30 seconds when idle for 5 minutes, or forced 4 seconds via `W`
 - **Monitor mode**: Interface stays open forever, press Ctrl+C to exit
 
 **Flags:**
@@ -831,12 +831,12 @@ This script:
 - **T** — Cycle tier filter (All → S+ → S → A+ → A → A- → B+ → B → C → All)
 - **D** — Cycle provider filter (All → NIM → Groq → ...)
 - **Z** — Cycle mode (OpenCode CLI → OpenCode Desktop → OpenClaw)
-- **X** — **Toggle Log Viewer** (view recent activity and error logs)
+- **X** — **Toggle Token Logs** (view recent request/token usage logs)
 - **P** — Open Settings (manage API keys, toggles, updates, profiles)
 - **Shift+P** — Cycle through saved profiles (switches live TUI settings)
 - **Shift+S** — Save current TUI settings as a named profile (inline prompt)
 - **Q** — Open Smart Recommend overlay (find the best model for your task)
-- **W / =** — Decrease / Increase ping interval
+- **W** — Cycle ping mode (`FAST` 2s → `NORMAL` 10s → `SLOW` 30s → `FORCED` 4s)
 - **J / I** — Request feature / Report bug
 - **K / Esc** — Show help overlay / Close overlay
 - **Ctrl+C** — Exit
@@ -862,7 +862,7 @@ Profiles let you save and restore different TUI configurations — useful if you
 - Favorites (starred models)
 - Sort column and direction
 - Tier filter
-- Ping interval
+- Ping mode
 - API keys
 
 **Saving a profile:**

package/bin/free-coding-models.js

@@ -288,6 +288,7 @@ async function main() {
       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.
       hidden: false,  // 📖 Simple flag to hide/show models
     }))
   syncFavoriteFlags(results, config)
@@ -305,8 +306,30 @@ async function main() {
   // 📖 Add interactive selection state - cursor index and user's choice
   // 📖 sortColumn: 'rank'|'tier'|'origin'|'model'|'ping'|'avg'|'status'|'verdict'|'uptime'
   // 📖 sortDirection: 'asc' (default) or 'desc'
-    // 📖 pingInterval: current interval in ms (default 2000, adjustable with W/= keys)
-    // 📖 tierFilter: current tier filter letter (null = all, 'S' = S+/S, 'A' = A+/A/A-, etc.)
+  // 📖 ping cadence is now mode-driven:
+  // 📖 speed  = 2s for 1 minute bursts
+  // 📖 normal = 10s steady state
+  // 📖 slow   = 30s after 5 minutes of inactivity
+  // 📖 forced = 4s and ignores inactivity / auto slowdowns
+  const PING_MODE_INTERVALS = {
+    speed: 2_000,
+    normal: 10_000,
+    slow: 30_000,
+    forced: 4_000,
+  }
+  const PING_MODE_CYCLE = ['speed', 'normal', 'slow', 'forced']
+  const SPEED_MODE_DURATION_MS = 60_000
+  const IDLE_SLOW_AFTER_MS = 5 * 60_000
+  const now = Date.now()
+
+  const intervalToPingMode = (intervalMs) => {
+    if (intervalMs <= 3000) return 'speed'
+    if (intervalMs <= 5000) return 'forced'
+    if (intervalMs >= 30000) return 'slow'
+    return 'normal'
+  }
+
+  // 📖 tierFilter: current tier filter letter (null = all, 'S' = S+/S, 'A' = A+/A/A-, etc.)
   const state = {
     results,
     pendingPings: 0,
@@ -315,8 +338,13 @@ async function main() {
     selectedModel: null,
     sortColumn: 'avg',
     sortDirection: 'asc',
-    pingInterval: PING_INTERVAL,  // 📖 Track current interval for W/= keys
-    lastPingTime: Date.now(),     // 📖 Track when last ping cycle started
+    pingInterval: PING_MODE_INTERVALS.speed, // 📖 Effective live interval derived from the active ping mode.
+    pingMode: 'speed',            // 📖 Current ping mode: speed | normal | slow | forced.
+    pingModeSource: 'startup',    // 📖 Why this mode is active: startup | manual | auto | idle | activity.
+    speedModeUntil: now + SPEED_MODE_DURATION_MS, // 📖 Speed bursts auto-fall back to normal after 60 seconds.
+    lastPingTime: now,            // 📖 Track when last ping cycle started
+    lastUserActivityAt: now,      // 📖 Any keypress refreshes this timer; inactivity can force slow mode.
+    resumeSpeedOnActivity: false, // 📖 Set after idle slowdown so the next activity restarts a 60s speed burst.
     mode,                         // 📖 'opencode' or 'openclaw' — controls Enter action
     tierFilterMode: 0,            // 📖 Index into TIER_CYCLE (0=All, 1=S+, 2=S, ...)
     originFilterMode: 0,          // 📖 Index into ORIGIN_CYCLE (0=All, then providers)
@@ -383,6 +411,53 @@ async function main() {
     adjustScrollOffset(state)
   })
 
+  let ticker = null
+  let onKeyPress = null
+  let pingModel = null
+
+  const scheduleNextPing = () => {
+    clearTimeout(state.pingIntervalObj)
+    const elapsed = Date.now() - state.lastPingTime
+    const delay = Math.max(0, state.pingInterval - elapsed)
+    state.pingIntervalObj = setTimeout(runPingCycle, delay)
+  }
+
+  const setPingMode = (nextMode, source = 'manual') => {
+    const modeInterval = PING_MODE_INTERVALS[nextMode] ?? PING_MODE_INTERVALS.normal
+    state.pingMode = nextMode
+    state.pingModeSource = source
+    state.pingInterval = modeInterval
+    state.speedModeUntil = nextMode === 'speed' ? Date.now() + SPEED_MODE_DURATION_MS : null
+    state.resumeSpeedOnActivity = source === 'idle'
+    if (state.pingIntervalObj) scheduleNextPing()
+  }
+
+  const noteUserActivity = () => {
+    state.lastUserActivityAt = Date.now()
+    if (state.pingMode === 'forced') return
+    if (state.resumeSpeedOnActivity) {
+      setPingMode('speed', 'activity')
+    }
+  }
+
+  const refreshAutoPingMode = () => {
+    const currentTime = Date.now()
+    if (state.pingMode === 'forced') return
+
+    if (state.speedModeUntil && currentTime >= state.speedModeUntil) {
+      setPingMode('normal', 'auto')
+      return
+    }
+
+    if (currentTime - state.lastUserActivityAt >= IDLE_SLOW_AFTER_MS) {
+      if (state.pingMode !== 'slow' || state.pingModeSource !== 'idle') {
+        setPingMode('slow', 'idle')
+      } else {
+        state.resumeSpeedOnActivity = true
+      }
+    }
+  }
+
   // 📖 Auto-start proxy on launch if OpenCode config already has an fcm-proxy provider.
   // 📖 Fire-and-forget: does not block UI startup. state.proxyStartupStatus is updated async.
   if (mode === 'opencode' || mode === 'opencode-desktop') {
@@ -425,9 +500,6 @@ async function main() {
   }
 
   // ─── Overlay renderers + key handler ─────────────────────────────────────
-  let pingModel = null
-  let ticker = null
-  let onKeyPress = null
   const stopUi = ({ resetRawMode = false } = {}) => {
     if (ticker) clearInterval(ticker)
     clearTimeout(state.pingIntervalObj)
@@ -518,6 +590,10 @@ async function main() {
     mergedModels,
     apiKey,
     chalk,
+    setPingMode,
+    noteUserActivity,
+    intervalToPingMode,
+    PING_MODE_CYCLE,
     setResults: (next) => { results = next },
     readline,
   })
@@ -544,9 +620,11 @@ async function main() {
   }
 
   process.stdin.on('keypress', onKeyPress)
+  process.on('SIGCONT', noteUserActivity)
 
   // 📖 Animation loop: render settings overlay, recommend overlay, help overlay, feature request overlay, bug report overlay, OR main table
   ticker = setInterval(() => {
+    refreshAutoPingMode()
     state.frame++
     // 📖 Cache visible+sorted models each frame so Enter handler always matches the display
     if (!state.settingsOpen && !state.recommendOpen && !state.featureRequestOpen && !state.bugReportOpen) {
@@ -561,11 +639,11 @@ async function main() {
           ? overlays.renderFeatureRequest()
           : state.bugReportOpen
             ? overlays.renderBugReport()
-            : state.helpVisible
-              ? overlays.renderHelp()
+              : state.helpVisible
+                ? overlays.renderHelp()
               : state.logVisible
                 ? overlays.renderLog()
-                : renderTable(state.results, state.pendingPings, state.frame, state.cursor, state.sortColumn, state.sortDirection, state.pingInterval, state.lastPingTime, state.mode, state.tierFilterMode, state.scrollOffset, state.terminalRows, state.originFilterMode, state.activeProfile, state.profileSaveMode, state.profileSaveBuffer, state.proxyStartupStatus)
+                : renderTable(state.results, state.pendingPings, state.frame, state.cursor, state.sortColumn, state.sortDirection, state.pingInterval, state.lastPingTime, state.mode, state.tierFilterMode, state.scrollOffset, state.terminalRows, state.originFilterMode, state.activeProfile, state.profileSaveMode, state.profileSaveBuffer, state.proxyStartupStatus, state.pingMode, state.pingModeSource)
     process.stdout.write(ALT_HOME + content)
   }, Math.round(1000 / FPS))
 
@@ -573,7 +651,7 @@ async function main() {
   const initialVisible = state.results.filter(r => !r.hidden)
   state.visibleSorted = sortResultsWithPinnedFavorites(initialVisible, state.sortColumn, state.sortDirection)
 
-  process.stdout.write(ALT_HOME + renderTable(state.results, state.pendingPings, state.frame, state.cursor, state.sortColumn, state.sortDirection, state.pingInterval, state.lastPingTime, state.mode, state.tierFilterMode, state.scrollOffset, state.terminalRows, state.originFilterMode, state.activeProfile, state.profileSaveMode, state.profileSaveBuffer, state.proxyStartupStatus))
+  process.stdout.write(ALT_HOME + renderTable(state.results, state.pendingPings, state.frame, state.cursor, state.sortColumn, state.sortDirection, state.pingInterval, state.lastPingTime, state.mode, state.tierFilterMode, state.scrollOffset, state.terminalRows, state.originFilterMode, state.activeProfile, state.profileSaveMode, state.profileSaveBuffer, state.proxyStartupStatus, state.pingMode, state.pingModeSource))
 
   // 📖 If --recommend was passed, auto-open the Smart Recommend overlay on start
   if (cliArgs.recommendMode) {
@@ -593,82 +671,89 @@ async function main() {
   // 📖 Uses per-provider API key and URL from sources.js
   // 📖 If no API key is configured, pings without auth — a 401 still tells us latency + server is up
   pingModel = async (r) => {
-    const providerApiKey = getApiKey(state.config, r.providerKey) ?? null
-    const providerUrl = sources[r.providerKey]?.url ?? sources.nvidia.url
-    let { code, ms, quotaPercent } = await ping(providerApiKey, r.modelId, r.providerKey, providerUrl)
-
-    if ((quotaPercent === null || quotaPercent === undefined) && providerApiKey) {
-      const providerQuota = await getProviderQuotaPercentCached(r.providerKey, providerApiKey)
-      if (typeof providerQuota === 'number' && Number.isFinite(providerQuota)) {
-        quotaPercent = providerQuota
+    state.pendingPings += 1
+    r.isPinging = true
+
+    try {
+      const providerApiKey = getApiKey(state.config, r.providerKey) ?? null
+      const providerUrl = sources[r.providerKey]?.url ?? sources.nvidia.url
+      let { code, ms, quotaPercent } = await ping(providerApiKey, r.modelId, r.providerKey, providerUrl)
+
+      if ((quotaPercent === null || quotaPercent === undefined) && providerApiKey) {
+        const providerQuota = await getProviderQuotaPercentCached(r.providerKey, providerApiKey)
+        if (typeof providerQuota === 'number' && Number.isFinite(providerQuota)) {
+          quotaPercent = providerQuota
+        }
       }
-    }
 
-    // 📖 Store ping result as object with ms and code
-    // 📖 ms = actual response time (even for errors like 429)
-    // 📖 code = HTTP status code ('200', '429', '500', '000' for timeout)
-    r.pings.push({ ms, code })
-
-    // 📖 Update status based on latest ping
-    if (code === '200') {
-      r.status = 'up'
-    } else if (code === '000') {
-      r.status = 'timeout'
-    } else if (code === '401') {
-      // 📖 401 = server is reachable but no API key set (or wrong key)
-      // 📖 Treated as 'noauth' — server is UP, latency is real, just needs a key
-      r.status = 'noauth'
-      r.httpCode = code
-    } else {
-      r.status = 'down'
-      r.httpCode = code
-    }
+      // 📖 Store ping result as object with ms and code
+      // 📖 ms = actual response time (even for errors like 429)
+      // 📖 code = HTTP status code ('200', '429', '500', '000' for timeout)
+      r.pings.push({ ms, code })
+
+      // 📖 Update status based on latest ping
+      if (code === '200') {
+        r.status = 'up'
+      } else if (code === '000') {
+        r.status = 'timeout'
+      } else if (code === '401') {
+        // 📖 401 = server is reachable but no API key set (or wrong key)
+        // 📖 Treated as 'noauth' — server is UP, latency is real, just needs a key
+        r.status = 'noauth'
+        r.httpCode = code
+      } else {
+        r.status = 'down'
+        r.httpCode = code
+      }
 
-    if (typeof quotaPercent === 'number' && Number.isFinite(quotaPercent)) {
-      r.usagePercent = quotaPercent
-      // Provider-level fallback: apply latest known quota to sibling rows on same provider.
-      for (const sibling of state.results) {
-        if (sibling.providerKey === r.providerKey && (sibling.usagePercent === undefined || sibling.usagePercent === null)) {
-          sibling.usagePercent = quotaPercent
+      if (typeof quotaPercent === 'number' && Number.isFinite(quotaPercent)) {
+        r.usagePercent = quotaPercent
+        // Provider-level fallback: apply latest known quota to sibling rows on same provider.
+        for (const sibling of state.results) {
+          if (sibling.providerKey === r.providerKey && (sibling.usagePercent === undefined || sibling.usagePercent === null)) {
+            sibling.usagePercent = quotaPercent
+          }
         }
       }
+    } finally {
+      r.isPinging = false
+      state.pendingPings = Math.max(0, state.pendingPings - 1)
     }
   }
 
   // 📖 Initial ping of all models
   const initialPing = Promise.all(state.results.map(r => pingModel(r)))
 
-  // 📖 Continuous ping loop with dynamic interval (adjustable with W/= keys)
-  const schedulePing = () => {
-    state.pingIntervalObj = setTimeout(async () => {
-      state.lastPingTime = Date.now()
-
-      // 📖 Refresh persisted usage snapshots each cycle so proxy writes appear live in table.
-      // 📖 Freshness-aware: stale snapshots (>30m) are excluded and row reverts to undefined.
-      for (const r of state.results) {
-        const pct = _usageForRow(r.providerKey, r.modelId)
-        if (typeof pct === 'number' && Number.isFinite(pct)) {
-          r.usagePercent = pct
-        } else {
-          // If snapshot is now stale or gone, clear the cached value so UI shows N/A.
-          r.usagePercent = undefined
-        }
+  // 📖 Continuous ping loop with mode-driven cadence.
+  const runPingCycle = async () => {
+    refreshAutoPingMode()
+    state.lastPingTime = Date.now()
+
+    // 📖 Refresh persisted usage snapshots each cycle so proxy writes appear live in table.
+    // 📖 Freshness-aware: stale snapshots (>30m) are excluded and row reverts to undefined.
+    for (const r of state.results) {
+      const pct = _usageForRow(r.providerKey, r.modelId)
+      if (typeof pct === 'number' && Number.isFinite(pct)) {
+        r.usagePercent = pct
+      } else {
+        // If snapshot is now stale or gone, clear the cached value so UI shows N/A.
+        r.usagePercent = undefined
       }
+    }
 
-      state.results.forEach(r => {
-        pingModel(r).catch(() => {
-          // Individual ping failures don't crash the loop
-        })
+    state.results.forEach(r => {
+      pingModel(r).catch(() => {
+        // Individual ping failures don't crash the loop
       })
+    })
 
-      // 📖 Schedule next ping with current interval
-      schedulePing()
-    }, state.pingInterval)
+    refreshAutoPingMode()
+    scheduleNextPing()
   }
 
   // 📖 Start the ping loop
   state.pingIntervalObj = null
-  schedulePing()
+  scheduleNextPing()
 
   await initialPing
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "free-coding-models",
-  "version": "0.1.84",
+  "version": "0.1.85",
   "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/config.js

@@ -392,7 +392,7 @@ export function _emptyProfileSettings() {
     tierFilter: null,     // 📖 null = show all tiers, or 'S'|'A'|'B'|'C'|'D'
     sortColumn: 'avg',    // 📖 default sort column
     sortAsc: true,        // 📖 true = ascending (fastest first for latency)
-    pingInterval: 8000,   // 📖 default ms between pings
+    pingInterval: 10000,  // 📖 default ms between pings in the steady "normal" mode
   }
 }
 

package/src/constants.js

@@ -51,7 +51,9 @@ export const ALT_HOME  = '\x1b[H'
 
 // 📖 Timing constants — control how fast the health-check loop runs.
 export const PING_TIMEOUT  = 15_000  // 📖 15s per attempt before abort
-export const PING_INTERVAL = 3_000   // 📖 3s between pings for fast model selection feedback
+// 📖 PING_INTERVAL is the baseline "normal" cadence. Startup can still temporarily
+// 📖 boost to faster modes, but steady-state uses 10s unless the user picks another mode.
+export const PING_INTERVAL = 10_000
 
 // 📖 Animation and column-width constants.
 export const FPS       = 12

package/src/key-handler.js

@@ -65,6 +65,10 @@ export function createKeyHandler(ctx) {
     mergedModels,
     apiKey,
     chalk,
+    setPingMode,
+    noteUserActivity,
+    intervalToPingMode,
+    PING_MODE_CYCLE,
     setResults,
     readline,
   } = ctx
@@ -121,6 +125,7 @@ export function createKeyHandler(ctx) {
 
   return async (str, key) => {
     if (!key) return
+    noteUserActivity()
 
     // 📖 Profile save mode: intercept ALL keys while inline name input is active.
     // 📖 Enter → save, Esc → cancel, Backspace → delete char, printable → append to buffer.
@@ -503,7 +508,7 @@ export function createKeyHandler(ctx) {
             // 📖 Try to reuse existing result to keep ping history
             const existing = state.results.find(r => r.modelId === modelId && r.providerKey === providerKey)
             if (existing) return existing
-            return { idx: i + 1, modelId, label, tier, sweScore, ctx, providerKey, status: 'pending', pings: [], httpCode: null, hidden: false }
+            return { idx: i + 1, modelId, label, tier, sweScore, ctx, providerKey, status: 'pending', pings: [], httpCode: null, isPinging: false, hidden: false }
           })
         // 📖 Re-index results
         nextResults.forEach((r, i) => { r.idx = i + 1 })
@@ -524,6 +529,7 @@ export function createKeyHandler(ctx) {
               r.status = 'pending'
               r.pings = []
               r.httpCode = null
+              r.isPinging = false
               pingModel(r).catch(() => {})
             }
           })
@@ -582,7 +588,7 @@ export function createKeyHandler(ctx) {
             if (settings) {
               state.sortColumn = settings.sortColumn || 'avg'
               state.sortDirection = settings.sortAsc ? 'asc' : 'desc'
-              state.pingInterval = settings.pingInterval || PING_INTERVAL
+              setPingMode(intervalToPingMode(settings.pingInterval || PING_INTERVAL), 'manual')
               if (settings.tierFilter) {
                 const tierIdx = TIER_CYCLE.indexOf(settings.tierFilter)
                 if (tierIdx >= 0) state.tierFilterMode = tierIdx
@@ -773,7 +779,7 @@ export function createKeyHandler(ctx) {
             // 📖 Apply profile's TUI settings to live state
             state.sortColumn = settings.sortColumn || 'avg'
             state.sortDirection = settings.sortAsc ? 'asc' : 'desc'
-            state.pingInterval = settings.pingInterval || PING_INTERVAL
+            setPingMode(intervalToPingMode(settings.pingInterval || PING_INTERVAL), 'manual')
             if (settings.tierFilter) {
               const tierIdx = TIER_CYCLE.indexOf(settings.tierFilter)
               if (tierIdx >= 0) state.tierFilterMode = tierIdx
@@ -871,13 +877,13 @@ export function createKeyHandler(ctx) {
       return
     }
 
-    // 📖 Interval adjustment keys: W=decrease (faster), ==increase (slower)
-    // 📖 X was previously used for interval increase but is now reserved for the log page overlay.
-    // 📖 Minimum 1s, maximum 60s
+    // 📖 W cycles the supported ping modes:
+    // 📖 speed (2s) → normal (10s) → slow (30s) → forced (4s) → speed.
+    // 📖 forced ignores auto speed/slow transitions until the user leaves it manually.
     if (key.name === 'w') {
-      state.pingInterval = Math.max(1000, state.pingInterval - 1000)
-    } else if (str === '=' || key.name === '=') {
-      state.pingInterval = Math.min(60000, state.pingInterval + 1000)
+      const currentIdx = PING_MODE_CYCLE.indexOf(state.pingMode)
+      const nextIdx = currentIdx >= 0 ? (currentIdx + 1) % PING_MODE_CYCLE.length : 0
+      setPingMode(PING_MODE_CYCLE[nextIdx], 'manual')
     }
 
     // 📖 Tier toggle key: T = cycle through each individual tier (All → S+ → S → A+ → A → A- → B+ → B → C → All)

package/src/overlays.js

@@ -250,8 +250,8 @@ export function createOverlayRenderers(state, deps) {
     lines.push(`  ${chalk.cyan('Latest')}      Most recent ping response time (ms)  ${chalk.dim('Sort:')} ${chalk.yellow('L')}`)
     lines.push(`              ${chalk.dim('Shows how fast the server is responding right now — useful to catch live slowdowns.')}`)
     lines.push('')
-    lines.push(`  ${chalk.cyan('Avg Ping')}    Average response time across all successful pings (ms)  ${chalk.dim('Sort:')} ${chalk.yellow('A')}`)
-    lines.push(`              ${chalk.dim('The long-term truth. Ignore lucky one-off pings, this tells you real everyday speed.')}`)
+    lines.push(`  ${chalk.cyan('Avg Ping')}    Average response time across all measurable pings (200 + 401) (ms)  ${chalk.dim('Sort:')} ${chalk.yellow('A')}`)
+    lines.push(`              ${chalk.dim('The long-term truth. Even without a key, a 401 still gives real latency so the average stays useful.')}`)
     lines.push('')
     lines.push(`  ${chalk.cyan('Health')}      Live status: ✅ UP / 🔥 429 / ⏳ TIMEOUT / ❌ ERR / 🔑 NO KEY  ${chalk.dim('Sort:')} ${chalk.yellow('H')}`)
     lines.push(`              ${chalk.dim('Tells you instantly if a model is reachable or down — no guesswork needed.')}`)
@@ -278,10 +278,9 @@ export function createOverlayRenderers(state, deps) {
     lines.push(`  ${chalk.yellow('Enter')}        Select model and launch`)
     lines.push('')
     lines.push(`  ${chalk.bold('Controls')}`)
-    lines.push(`  ${chalk.yellow('W')}  Decrease ping interval (faster)`)
-    lines.push(`  ${chalk.yellow('=')}  Increase ping interval (slower)  ${chalk.dim('(was X — X is now the log page)')}`)
-    lines.push(`  ${chalk.yellow('X')}  Toggle request log page  ${chalk.dim('(shows recent requests from request-log.jsonl)')}`)
-    lines.push(`  ${chalk.yellow('Z')}  Cycle launch mode  ${chalk.dim('(OpenCode CLI → OpenCode Desktop → OpenClaw)')}`)
+    lines.push(`  ${chalk.yellow('W')}  Toggle ping mode  ${chalk.dim('(speed 2s → normal 10s → slow 30s → forced 4s)')}`)
+    lines.push(`  ${chalk.yellow('X')}  Toggle token log page  ${chalk.dim('(shows recent request usage from request-log.jsonl)')}`)
+    lines.push(`  ${chalk.yellow('Z')}  Cycle tool mode  ${chalk.dim('(OpenCode CLI → OpenCode Desktop → OpenClaw)')}`)
     lines.push(`  ${chalk.yellow('F')}  Toggle favorite on selected row  ${chalk.dim('(⭐ pinned at top, persisted)')}`)
     lines.push(`  ${chalk.yellow('Q')}  Smart Recommend  ${chalk.dim('(🎯 find the best model for your task — questionnaire + live analysis)')}`)
     lines.push(`  ${chalk.rgb(57, 255, 20).bold('J')}  Request Feature  ${chalk.dim('(📝 send anonymous feedback to the project team)')}`)

package/src/render-table.js

@@ -77,7 +77,7 @@ export function setActiveProxy(proxyInstance) {
 }
 
 // ─── renderTable: mode param controls footer hint text (opencode vs openclaw) ─────────
-export function renderTable(results, pendingPings, frame, cursor = null, sortColumn = 'avg', sortDirection = 'asc', pingInterval = PING_INTERVAL, lastPingTime = Date.now(), mode = 'opencode', tierFilterMode = 0, scrollOffset = 0, terminalRows = 0, originFilterMode = 0, activeProfile = null, profileSaveMode = false, profileSaveBuffer = '', proxyStartupStatus = null) {
+export function renderTable(results, pendingPings, frame, cursor = null, sortColumn = 'avg', sortDirection = 'asc', pingInterval = PING_INTERVAL, lastPingTime = Date.now(), mode = 'opencode', tierFilterMode = 0, scrollOffset = 0, terminalRows = 0, originFilterMode = 0, activeProfile = null, profileSaveMode = false, profileSaveBuffer = '', proxyStartupStatus = null, pingMode = 'normal', pingModeSource = 'auto') {
   // 📖 Filter out hidden models for display
   const visibleResults = results.filter(r => !r.hidden)
 
@@ -97,6 +97,23 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
       ? chalk.dim(`pinging — ${pendingPings} in flight…`)
       : chalk.dim(`next ping ${secondsUntilNext}s`)
 
+  const intervalSec = Math.round(pingInterval / 1000)
+  const pingModeMeta = {
+    speed: { label: `${intervalSec}s speed`, color: chalk.bold.rgb(255, 210, 80) },
+    normal: { label: `${intervalSec}s normal`, color: chalk.bold.rgb(120, 210, 255) },
+    slow: { label: `${intervalSec}s slow`, color: chalk.bold.rgb(255, 170, 90) },
+    forced: { label: `${intervalSec}s forced`, color: chalk.bold.rgb(255, 120, 120) },
+  }
+  const activePingMode = pingModeMeta[pingMode] ?? pingModeMeta.normal
+  const pingModeBadge = activePingMode.color(` [${activePingMode.label}]`)
+  const pingModeHint = pingModeSource === 'idle'
+    ? chalk.dim(' idle')
+    : pingModeSource === 'activity'
+      ? chalk.dim(' resumed')
+      : pingModeSource === 'startup'
+        ? chalk.dim(' startup')
+        : ''
+
   // 📖 Mode badge shown in header so user knows what Enter will do
   // 📖 Now includes key hint for mode toggle
   let modeBadge
@@ -160,7 +177,7 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
   const sorted = sortResultsWithPinnedFavorites(visibleResults, sortColumn, sortDirection)
 
   const lines = [
-    `  ${chalk.greenBright.bold('✅ FCM')}${modeBadge}${modeHint}${tierBadge}${originBadge}${profileBadge}   ` +
+    `  ${chalk.greenBright.bold('✅ FCM')}${modeBadge}${pingModeBadge}${modeHint}${tierBadge}${originBadge}${profileBadge}   ` +
       chalk.greenBright(`✅ ${up}`) + chalk.dim(' up  ') +
       chalk.yellow(`⏳ ${timeout}`) + chalk.dim(' timeout  ') +
       chalk.red(`❌ ${down}`) + chalk.dim(' down  ') +
@@ -315,22 +332,30 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
       ? chalk.cyan(ctxRaw.padEnd(W_CTX))
       : chalk.dim(ctxRaw.padEnd(W_CTX))
 
+    // 📖 Keep the row-local spinner small and inline so users can still read the last measured latency.
+    const buildLatestPingDisplay = (value) => {
+      const spinner = r.isPinging ? ` ${FRAMES[frame % FRAMES.length]}` : ''
+      return `${value}${spinner}`.padEnd(W_PING)
+    }
+
     // 📖 Latest ping - pings are objects: { ms, code }
     // 📖 Show response time for 200 (success) and 401 (no-auth but server is reachable)
     const latestPing = r.pings.length > 0 ? r.pings[r.pings.length - 1] : null
     let pingCell
     if (!latestPing) {
-      pingCell = chalk.dim('———'.padEnd(W_PING))
+      const placeholder = r.isPinging ? buildLatestPingDisplay('———') : '———'.padEnd(W_PING)
+      pingCell = chalk.dim(placeholder)
     } else if (latestPing.code === '200') {
       // 📖 Success - show response time
-      const str = String(latestPing.ms).padEnd(W_PING)
+      const str = buildLatestPingDisplay(String(latestPing.ms))
       pingCell = latestPing.ms < 500 ? chalk.greenBright(str) : latestPing.ms < 1500 ? chalk.yellow(str) : chalk.red(str)
     } else if (latestPing.code === '401') {
       // 📖 401 = no API key but server IS reachable — still show latency in dim
-      pingCell = chalk.dim(String(latestPing.ms).padEnd(W_PING))
+      pingCell = chalk.dim(buildLatestPingDisplay(String(latestPing.ms)))
     } else {
       // 📖 Error or timeout - show "———" (error code is already in Status column)
-      pingCell = chalk.dim('———'.padEnd(W_PING))
+      const placeholder = r.isPinging ? buildLatestPingDisplay('———') : '———'.padEnd(W_PING)
+      pingCell = chalk.dim(placeholder)
     }
 
     // 📖 Avg ping (just number, no "ms")
@@ -523,18 +548,17 @@ export function renderTable(results, pendingPings, frame, cursor = null, sortCol
    } else {
      lines.push('')
    }
-  const intervalSec = Math.round(pingInterval / 1000)
-
-  // 📖 Footer hints adapt based on active mode
+  // 📖 Footer hints adapt based on active mode.
+  const hotkey = (keyLabel, text) => chalk.yellow(keyLabel) + chalk.dim(text)
   const actionHint = mode === 'openclaw'
-    ? chalk.rgb(255, 100, 50)('Enter→SetOpenClaw')
+    ? hotkey('Enter', '→SetOpenClaw')
     : mode === 'opencode-desktop'
-      ? chalk.rgb(0, 200, 255)('Enter→OpenDesktop')
-      : chalk.rgb(0, 200, 255)('Enter→OpenCode')
+      ? hotkey('Enter', '→OpenDesktop')
+      : hotkey('Enter', '→OpenCode')
   // 📖 Line 1: core navigation + sorting shortcuts
-  lines.push(chalk.dim(`  ↑↓ Navigate  •  `) + actionHint + chalk.dim(`  •  `) + chalk.yellow('F') + chalk.dim(` Favorite  •  R/Y/O/M/L/A/S/C/H/V/B/U/`) + chalk.yellow('G') + chalk.dim(` Sort  •  `) + chalk.yellow('T') + chalk.dim(` Tier  •  `) + chalk.yellow('D') + chalk.dim(` Provider  •  W↓/=↑ (${intervalSec}s)  •  `) + chalk.rgb(255, 100, 50).bold('Z') + chalk.dim(` Mode  •  `) + chalk.yellow('X') + chalk.dim(` Logs  •  `) + chalk.yellow('P') + chalk.dim(` Settings  •  `) + chalk.rgb(0, 255, 80).bold('K') + chalk.dim(` Help`))
+  lines.push(chalk.dim(`  ↑↓ Navigate  •  `) + actionHint + chalk.dim(`  •  `) + hotkey('F', ' Toggle Favorite') + chalk.dim(`  •  Press Highlighted letters in column named to sort & filter  •  `) + hotkey('T', ' Tier') + chalk.dim(`  •  `) + hotkey('D', ' Provider') + chalk.dim(`  •  `) + hotkey('W', ' Ping Mode : FAST/NORMAL/SLOW/FORCED') + chalk.dim(`  •  `) + hotkey('Z', ' Tool Mode') + chalk.dim(`  •  `) + hotkey('X', ' Token Logs') + chalk.dim(`  •  `) + hotkey('P', ' Settings') + chalk.dim(`  •  `) + hotkey('K', ' Help'))
   // 📖 Line 2: profiles, recommend, feature request, bug report, and extended hints — gives visibility to less-obvious features
-  lines.push(chalk.dim(`  `) + chalk.rgb(200, 150, 255).bold('⇧P') + chalk.dim(` Cycle profile  •  `) + chalk.rgb(200, 150, 255).bold('⇧S') + chalk.dim(` Save profile  •  `) + chalk.rgb(0, 200, 180).bold('Q') + chalk.dim(` Smart Recommend  •  `) + chalk.rgb(57, 255, 20).bold('J') + chalk.dim(` Request feature  •  `) + chalk.rgb(255, 87, 51).bold('I') + chalk.dim(` Report bug  •  `) + chalk.yellow('Esc') + chalk.dim(` Close overlay`))
+  lines.push(chalk.dim(`  `) + hotkey('⇧P', ' Cycle profile') + chalk.dim(`  •  `) + hotkey('⇧S', ' Save profile') + chalk.dim(`  •  `) + hotkey('Q', ' Smart Recommend') + chalk.dim(`  •  `) + hotkey('J', ' Request feature') + chalk.dim(`  •  `) + hotkey('I', ' Report bug'))
   // 📖 Proxy status line — always rendered with explicit state (starting/running/failed/stopped)
   lines.push(renderProxyStatusLine(proxyStartupStatus, activeProxyRef))
   lines.push(

package/src/utils.js

@@ -74,18 +74,23 @@ export const TIER_LETTER_MAP = {
 
 // ─── Core Logic Functions ────────────────────────────────────────────────────
 
-// 📖 getAvg: Calculate average latency from ONLY successful pings (HTTP 200).
-// 📖 Failed pings (timeouts, 429s, 500s) are excluded to avoid skewing the average.
-// 📖 Returns Infinity when no successful pings exist — this sorts "unknown" models to the bottom.
+// 📖 measureablePingCodes: HTTP codes that still give us a real round-trip latency sample.
+// 📖 200 = normal success, 401 = no key / bad key but the provider endpoint is reachable.
+const measurablePingCodes = new Set(['200', '401'])
+
+// 📖 getAvg: Calculate average latency from pings that produced a real latency sample.
+// 📖 HTTP 200 and 401 both count because a 401 still proves the endpoint responded in X ms.
+// 📖 Timeouts and server failures are excluded to avoid mixing availability with raw latency.
+// 📖 Returns Infinity when no measurable pings exist — this sorts "unknown" models to the bottom.
 // 📖 The rounding to integer avoids displaying fractional milliseconds in the TUI.
 //
 // 📖 Example:
-//   pings = [{ms: 200, code: '200'}, {ms: 0, code: '429'}, {ms: 400, code: '200'}]
-//   → getAvg returns 300 (only the two 200s count: (200+400)/2)
+//   pings = [{ms: 200, code: '200'}, {ms: 320, code: '401'}, {ms: 999, code: '500'}]
+//   → getAvg returns 260 (only the measurable pings count: (200+320)/2)
 export const getAvg = (r) => {
-  const successfulPings = (r.pings || []).filter(p => p.code === '200')
-  if (successfulPings.length === 0) return Infinity
-  return Math.round(successfulPings.reduce((a, b) => a + b.ms, 0) / successfulPings.length)
+  const measurablePings = (r.pings || []).filter(p => measurablePingCodes.has(p.code))
+  if (measurablePings.length === 0) return Infinity
+  return Math.round(measurablePings.reduce((a, b) => a + b.ms, 0) / measurablePings.length)
 }
 
 // 📖 getVerdict: Determine a human-readable health verdict for a model.
@@ -120,16 +125,16 @@ export const getVerdict = (r) => {
   if (avg === Infinity) return 'Pending'
 
   // 📖 Stability-aware verdict: penalize models with good avg but terrible tail latency
-  const successfulPings = (r.pings || []).filter(p => p.code === '200')
+  const measurablePings = (r.pings || []).filter(p => measurablePingCodes.has(p.code))
   const p95 = getP95(r)
 
   if (avg < 400) {
     // 📖 Only flag as "Spiky" when we have enough data (≥3 pings) to judge stability
-    if (successfulPings.length >= 3 && p95 > 3000) return 'Spiky'
+    if (measurablePings.length >= 3 && p95 > 3000) return 'Spiky'
     return 'Perfect'
   }
   if (avg < 1000) {
-    if (successfulPings.length >= 3 && p95 > 5000) return 'Spiky'
+    if (measurablePings.length >= 3 && p95 > 5000) return 'Spiky'
     return 'Normal'
   }
   if (avg < 3000) return 'Slow'
@@ -148,30 +153,30 @@ export const getUptime = (r) => {
   return Math.round((successful / r.pings.length) * 100)
 }
 
-// 📖 getP95: Calculate the 95th percentile latency from successful pings (HTTP 200).
+// 📖 getP95: Calculate the 95th percentile latency from measurable pings (HTTP 200/401).
 // 📖 The p95 answers: "95% of requests are faster than this value."
 // 📖 A low p95 means consistently fast responses — a high p95 signals tail-latency spikes.
-// 📖 Returns Infinity when no successful pings exist.
+// 📖 Returns Infinity when no measurable pings exist.
 //
 // 📖 Algorithm: sort latencies ascending, pick the value at ceil(N * 0.95) - 1.
 // 📖 Example: [100, 200, 300, 400, 5000] → p95 index = ceil(5 * 0.95) - 1 = 4 → 5000ms
 export const getP95 = (r) => {
-  const successfulPings = (r.pings || []).filter(p => p.code === '200')
-  if (successfulPings.length === 0) return Infinity
-  const sorted = successfulPings.map(p => p.ms).sort((a, b) => a - b)
+  const measurablePings = (r.pings || []).filter(p => measurablePingCodes.has(p.code))
+  if (measurablePings.length === 0) return Infinity
+  const sorted = measurablePings.map(p => p.ms).sort((a, b) => a - b)
   const idx = Math.ceil(sorted.length * 0.95) - 1
   return sorted[Math.max(0, idx)]
 }
 
-// 📖 getJitter: Calculate latency standard deviation (σ) from successful pings.
+// 📖 getJitter: Calculate latency standard deviation (σ) from measurable pings.
 // 📖 Low jitter = predictable response times. High jitter = erratic, spiky latency.
-// 📖 Returns 0 when fewer than 2 successful pings (can't compute variance from 1 point).
+// 📖 Returns 0 when fewer than 2 measurable pings (can't compute variance from 1 point).
 // 📖 Uses population σ (divides by N, not N-1) since we have ALL the data, not a sample.
 export const getJitter = (r) => {
-  const successfulPings = (r.pings || []).filter(p => p.code === '200')
-  if (successfulPings.length < 2) return 0
-  const mean = successfulPings.reduce((a, b) => a + b.ms, 0) / successfulPings.length
-  const variance = successfulPings.reduce((sum, p) => sum + (p.ms - mean) ** 2, 0) / successfulPings.length
+  const measurablePings = (r.pings || []).filter(p => measurablePingCodes.has(p.code))
+  if (measurablePings.length < 2) return 0
+  const mean = measurablePings.reduce((a, b) => a + b.ms, 0) / measurablePings.length
+  const variance = measurablePings.reduce((sum, p) => sum + (p.ms - mean) ** 2, 0) / measurablePings.length
   return Math.round(Math.sqrt(variance))
 }
 
@@ -190,14 +195,14 @@ export const getJitter = (r) => {
 //   Model B: avg 400ms, p95 650ms (boringly consistent) → score ~85
 //   In real usage, Model B FEELS faster because it doesn't randomly stall.
 export const getStabilityScore = (r) => {
-  const successfulPings = (r.pings || []).filter(p => p.code === '200')
-  if (successfulPings.length === 0) return -1
+  const measurablePings = (r.pings || []).filter(p => measurablePingCodes.has(p.code))
+  if (measurablePings.length === 0) return -1
 
   const p95 = getP95(r)
   const jitter = getJitter(r)
   const uptime = getUptime(r)
-  const spikeCount = successfulPings.filter(p => p.ms > 3000).length
-  const spikeRate = spikeCount / successfulPings.length
+  const spikeCount = measurablePings.filter(p => p.ms > 3000).length
+  const spikeRate = spikeCount / measurablePings.length
 
   // 📖 Normalize each component to 0–100 (higher = better)
   const p95Score = Math.max(0, Math.min(100, 100 * (1 - p95 / 5000)))