free-coding-models 0.5.86 → 0.5.88

package/src/tui/overlays.js

@@ -19,14 +19,14 @@
  * @see ./key-handler.js — handles keypresses for all overlay interactions
  */
 
-import { loadChangelog } from '../core/changelog-loader.js'
 import { buildCliHelpLines } from './cli-help.js'
 import { renderRouterDashboard as renderRouterDashboardOverlay } from '../core/router-dashboard.js'
 import { renderPlayground as renderPlaygroundOverlay } from '../core/playground.js'
 import { themeColors, getThemeStatusLabel, getProviderRgb } from './theme.js'
 import { getProviderBillingNote, getProviderLabelWithBilling } from '../core/provider-metadata.js'
 import { detectTerminalCapabilities } from '../core/utils.js'
-import { truncateAnsiWidth } from './render-helpers.js'
+import { truncateAnsiWidth, loadChangelogCached } from './render-helpers.js'
+import { COMMAND_PALETTE_MAX_RESULTS } from './command-palette.js'
 
 export function createOverlayRenderers(state, deps) {
   const {
@@ -516,14 +516,17 @@ export function createOverlayRenderers(state, deps) {
     }
 
     const targetLine = cursorLineByRow[state.installEndpointsCursor] ?? 0
-    state.toolInstallPromptScrollOffset = keepOverlayTargetVisible(
-      state.toolInstallPromptScrollOffset,
+    // 📖 Own its scroll offset (fix): this renderer used to read/write
+    // 📖 toolInstallPromptScrollOffset, sharing (and fighting over) state with
+    // 📖 the tool-install prompt overlay. Each overlay now scrolls independently.
+    state.installEndpointsScrollOffset = keepOverlayTargetVisible(
+      state.installEndpointsScrollOffset,
       targetLine,
       lines.length,
       state.terminalRows
     )
-    const { visible, offset } = sliceOverlayLines(lines, state.toolInstallPromptScrollOffset, state.terminalRows)
-    state.toolInstallPromptScrollOffset = offset
+    const { visible, offset } = sliceOverlayLines(lines, state.installEndpointsScrollOffset, state.terminalRows)
+    state.installEndpointsScrollOffset = offset
 
     const tintedLines = tintOverlayLines(visible, themeColors.overlayBgSettings, state.terminalCols)
     const cleared = tintedLines.map((line) => line + EL)
@@ -710,14 +713,15 @@ export function createOverlayRenderers(state, deps) {
     }
 
     const targetLine = cursorLineByRow[state.toolInstallPromptCursor] ?? 0
-    state.installEndpointsScrollOffset = keepOverlayTargetVisible(
-      state.installEndpointsScrollOffset,
+    // 📖 Own its scroll offset (fix): was reading/writing installEndpointsScrollOffset.
+    state.toolInstallPromptScrollOffset = keepOverlayTargetVisible(
+      state.toolInstallPromptScrollOffset,
       targetLine,
       lines.length,
       state.terminalRows
     )
-    const { visible, offset } = sliceOverlayLines(lines, state.installEndpointsScrollOffset, state.terminalRows)
-    state.installEndpointsScrollOffset = offset
+    const { visible, offset } = sliceOverlayLines(lines, state.toolInstallPromptScrollOffset, state.terminalRows)
+    state.toolInstallPromptScrollOffset = offset
 
     const tintedLines = tintOverlayLines(visible, themeColors.overlayBgSettings, state.terminalCols)
     const cleared = tintedLines.map((line) => line + EL)
@@ -773,7 +777,7 @@ export function createOverlayRenderers(state, deps) {
       return out
     }
 
-    const allResults = Array.isArray(state.commandPaletteResults) ? state.commandPaletteResults.slice(0, 80) : []
+    const allResults = Array.isArray(state.commandPaletteResults) ? state.commandPaletteResults.slice(0, COMMAND_PALETTE_MAX_RESULTS) : []
     const panelLines = []
     const cursorLineByRow = {}
 
@@ -1266,7 +1270,9 @@ export function createOverlayRenderers(state, deps) {
   function renderChangelog() {
     const EL = '\x1b[K'
     const lines = []
-    const changelogData = loadChangelog()
+    // 📖 TTL-cached load (fix): this ran readdirSync + readFileSync of every
+    // 📖 changelog/*.md on EVERY render frame while the overlay was open.
+    const changelogData = loadChangelogCached()
     const { versions } = changelogData
     const versionList = Object.keys(versions).sort((a, b) => {
       const aParts = a.split('.').map(Number)
@@ -1628,64 +1634,9 @@ export function createOverlayRenderers(state, deps) {
     return tintedLines.map((l) => l + EL).join('\n')
   }
 
-  // ─── Router Onboarding overlay renderer ─────────────────────────────────────
-  // 📖 renderRouterOnboarding: shown on first launch (no config.router) or
-  // 📖 first launch after upgrade (existing config but router.onboardingSeen !== true).
-  // 📖 Two options: Enable (Y) or Not now (N). Phase 6 — Smart Model Router.
-  function renderRouterOnboarding() {
-    const EL = '\x1b[K'
-    const lines = []
-    const cursorLineByRow = {}
-
-    lines.push('')
-    lines.push(`  ${themeColors.accent('🚀')} ${themeColors.accentBold('free-coding-models')} ${themeColors.dim(`v${LOCAL_VERSION}`)}`)
-    lines.push(`  ${themeColors.textBold('🔀 Smart Router Available!')}`)
-    lines.push('')
-    lines.push(themeColors.dim('  FCM can run a background daemon that automatically'))
-    lines.push(themeColors.dim('  routes your requests to the fastest healthy model —'))
-    lines.push(themeColors.dim('  with zero manual intervention after initial setup.'))
-    lines.push('')
-
-    const options = [
-      { label: 'Yes, enable the router', hint: 'Recommended — creates default set and starts daemon', key: 'Y' },
-      { label: 'Not now', hint: 'You can enable it later from the TUI', key: 'N' },
-    ]
-
-    if (state.routerOnboardingPhase === 'loading') {
-      lines.push(themeColors.info('  Enabling router, please wait...'))
-    } else if (state.routerOnboardingPhase === 'success') {
-      lines.push(themeColors.success('  ✅ Router enabled! Dashboard opening...'))
-      lines.push(themeColors.dim('  Setup complete. Return to the main table to continue.'))
-    } else if (state.routerOnboardingPhase === 'error') {
-      lines.push(themeColors.error(`  ❌ ${state.routerOnboardingError || 'Failed to enable router'}`))
-      lines.push(themeColors.dim('  Press Esc or Enter to continue to the main table'))
-    } else {
-      for (let i = 0; i < options.length; i++) {
-        const opt = options[i]
-        const isCursor = i === state.routerOnboardingCursor
-        const keyLabel = themeColors.hotkey(`  ${opt.key}]`)
-        const row = `${bullet(isCursor)}${keyLabel} ${isCursor ? themeColors.textBold(opt.label) : themeColors.text(opt.label)}`
-        cursorLineByRow[i] = lines.length
-        lines.push(isCursor ? themeColors.bgCursorSettingsList(row) : row)
-        lines.push(themeColors.dim(`      ${opt.hint}`))
-        lines.push('')
-      }
-      lines.push(themeColors.dim('  ↑↓ Navigate  •  Enter Select  •  Esc Skip for now'))
-      lines.push('')
-      lines.push(
-        themeColors.dim('  💬 ') +
-        themeColors.footerDiscord('\x1b]8;;https://discord.gg/ZTNFHvvCkU\x1b\\Join the Discord community\x1b]8;;\x1b\\') +
-        themeColors.dim('  •  Get help, share feedback, follow updates')
-      )
-    }
-
-    const targetLine = cursorLineByRow[state.routerOnboardingCursor] ?? 0
-    state.routerOnboardingScrollOffset = keepOverlayTargetVisible(state.routerOnboardingScrollOffset, targetLine, lines.length, state.terminalRows)
-    const { visible, offset } = sliceOverlayLines(lines, state.routerOnboardingScrollOffset, state.terminalRows)
-    state.routerOnboardingScrollOffset = offset
-    const tintedLines = tintOverlayLines(visible, themeColors.overlayBgSettings, state.terminalCols)
-    return tintedLines.map((l) => l + EL).join('\n')
-  }
+  // 📖 renderRouterOnboarding removed (dead code): nothing ever set
+  // 📖 state.routerOnboardingOpen = true, so the overlay was unreachable.
+  // 📖 The TUI auto-enables the router silently at startup instead (app.js).
 
   return {
     renderSettings,
@@ -1700,7 +1651,6 @@ export function createOverlayRenderers(state, deps) {
     renderPlayground,
     renderIncompatibleFallback,
     renderTokenUsage,
-    renderRouterOnboarding,
     startRecommendAnalysis,
     stopRecommendAnalysis,
     overlayLayout,

package/src/tui/render-helpers.js

@@ -31,6 +31,8 @@
  *   - `calculateViewport`: Compute visible slice of model rows
  *   - `sortResultsWithPinnedFavorites`: Sort with pinned items at top
  *   - `adjustScrollOffset`: Clamp scrollOffset so cursor stays visible
+ *   - `runWithConcurrency`: Run async task factories with limited parallelism
+ *   - `loadChangelogCached`: TTL-cached changelog reader for overlay renders
  *   - `fadedRow`: Multiply every 24-bit RGB channel by a factor to fade an
  *     entire ANSI-colored line uniformly — used for "unusable" rows.
  *
@@ -51,12 +53,23 @@
 import chalk from 'chalk'
 import { OVERLAY_PANEL_WIDTH, TABLE_FIXED_LINES, TABLE_HEADER_LINES, TABLE_FOOTER_LINES } from '../core/constants.js'
 import { sortResults } from '../core/utils.js'
+import { loadChangelog } from '../core/changelog-loader.js'
+
+// 📖 Shared ANSI escape pattern: CSI sequences (colors, \x1b[K, cursor moves),
+// 📖 OSC sequences terminated by EITHER ST ("\x1b\\") or BEL ("\x07") so OSC 8
+// 📖 hyperlinks never inflate width regardless of which terminator the emitter
+// 📖 used, and any leftover escape pair. stripAnsi() and truncateAnsiWidth()
+// 📖 both derive from this one source so width accounting can never disagree.
+const ANSI_SEQUENCE_SOURCE = '\\x1b\\[[0-9;?]*[A-Za-z]|\\x1b\\][^\\x1b\\x07]*(?:\\x1b\\\\|\\x07)|\\x1b.'
+const ANSI_SEQUENCE = new RegExp(ANSI_SEQUENCE_SOURCE, 'g')                  // 📖 match + drop
+const ANSI_SEQUENCE_KEEP = new RegExp(`(${ANSI_SEQUENCE_SOURCE})`, 'g')      // 📖 split + keep tokens
 
 // 📖 stripAnsi: Remove ANSI control sequences to estimate visible text width before padding.
 // 📖 Strips ALL CSI sequences (SGR colors, \x1b[K clear, cursor moves) and OSC
-// 📖 sequences (hyperlinks) - every escape is zero-width for measurement purposes.
+// 📖 sequences (hyperlinks, BEL- or ST-terminated) - every escape is zero-width
+// 📖 for measurement purposes.
 export function stripAnsi(input) {
-  return String(input).replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '').replace(/\x1b\][^\x1b]*\x1b\\/g, '')
+  return String(input).replace(ANSI_SEQUENCE, '')
 }
 
 // 📖 fadedRow: Multiply every 24-bit RGB channel inside an ANSI-colored string by `factor`
@@ -173,8 +186,7 @@ export function truncateAnsiWidth(input, maxWidth, { ellipsis = '…' } = {}) {
 
   // 📖 Split into ANSI sequences and visible characters so escapes are kept verbatim.
   // 📖 Capturing group makes String.split keep the separators (ANSI tokens) in the result.
-  const ANSI_TOKEN = /(\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x1b]*(?:\x1b\\|\u0007)?|\x1b.)/g
-  const tokens = text.split(ANSI_TOKEN).filter((t) => t !== '')
+  const tokens = text.split(ANSI_SEQUENCE_KEEP).filter((t) => t !== '')
   let out = ''
   let w = 0
   const ellWidth = displayWidth(ellipsis)
@@ -333,3 +345,49 @@ export function adjustScrollOffset(st) {
   if (st.scrollOffset > maxOffset) st.scrollOffset = maxOffset
   if (st.scrollOffset < 0) st.scrollOffset = 0
 }
+
+// ─── Shared TUI task utilities ────────────────────────────────────────────────
+
+// 📖 runWithConcurrency: Execute async task factories with limited parallelism
+// 📖 (max `maxConcurrent` simultaneous). Per-task rejections are captured as
+// 📖 { error } in the results array so one failure never rejects the whole
+// 📖 batch (the 404 probe and the startup ping burst both rely on that).
+// 📖 Previously this lived inside key-handler.js only, so app.js's startup
+// 📖 burst had to fall back to unbounded Promise.all (~226 simultaneous pings,
+// 📖 a guaranteed 429 storm). Exported so every call site shares one impl.
+export async function runWithConcurrency(tasks, maxConcurrent) {
+  const results = new Array(tasks.length)
+  let nextIndex = 0
+  const workers = new Array(Math.max(1, maxConcurrent)).fill(null).map(async () => {
+    while (true) {
+      const index = nextIndex++
+      if (index >= tasks.length) break
+      try {
+        results[index] = await tasks[index]()
+      } catch (err) {
+        results[index] = { error: err }
+      }
+    }
+  })
+  return Promise.all(workers).then(() => results)
+}
+
+// ─── Cached changelog loader ──────────────────────────────────────────────────
+
+// 📖 loadChangelogCached: TTL-cached wrapper around core loadChangelog().
+// 📖 The raw loader does readdirSync + readFileSync of every changelog/*.md on
+// 📖 each call, and the TUI used to call it on EVERY keypress AND every render
+// 📖 frame while the changelog overlay was open (~12 disk reads/sec). The
+// 📖 parsed result is cached in module scope for a few seconds; the file set
+// 📖 only changes on a release, so a short TTL is plenty fresh (and keeps the
+// 📖 overlay correct across version bumps during development).
+const CHANGELOG_CACHE_TTL_MS = 5000
+let changelogCache = null
+let changelogCacheAt = 0
+export function loadChangelogCached() {
+  const now = Date.now()
+  if (changelogCache && (now - changelogCacheAt) < CHANGELOG_CACHE_TTL_MS) return changelogCache
+  changelogCache = loadChangelog()
+  changelogCacheAt = now
+  return changelogCache
+}

package/src/tui/render-table.js

@@ -76,6 +76,12 @@ let _lastLayout = {
   hasBelowIndicator: false, // 📖 whether "... N more below ..." is shown
   footerHotkeys: [],  // 📖 Array of { key, row, xStart, xEnd } for footer click zones
   updateBannerRow: 0, // 📖 1-based terminal row of the fluorescent update banner (0 = none)
+  // 📖 Space-expanded detail card (issue #168): the 2 extra lines rendered under
+  // 📖 the cursor row shift every following row down. expandedDetailAfterIdx is
+  // 📖 the sorted index the card belongs to; the mouse handler subtracts
+  // 📖 expandedDetailRows from row offsets BELOW it so clicks map to the right model.
+  expandedDetailAfterIdx: -1,
+  expandedDetailRows: 0,
 }
 export function getLastLayout() { return _lastLayout }
 
@@ -691,6 +697,22 @@ export function renderTable({
     }
     return out
   }
+  // 📖 clipToWidth: Width-aware HARD clip without ellipsis (used for the Model
+  // 📖 column label). The old `r.label.slice(0, nameWidth)` cut by UTF-16 units
+  // 📖 and could split surrogate pairs, rendering emoji model names as mojibake.
+  // 📖 This walks code points and stops at the max DISPLAY width instead.
+  const clipToWidth = (text, max) => {
+    if (max <= 0) return ''
+    let w = 0
+    let out = ''
+    for (const ch of String(text)) {
+      const cw = displayWidth(ch)
+      if (w + cw > max) break
+      out += ch
+      w += cw
+    }
+    return out
+  }
   const paintSweScore = (score, paddedText) => {
     if (score >= 70) return chalk.bold.rgb(...getTierRgb('S+'))(paddedText)
     if (score >= 60) return chalk.bold.rgb(...getTierRgb('S'))(paddedText)
@@ -713,6 +735,9 @@ export function renderTable({
   _lastLayout.viewportEndIdx = vp.endIdx
   _lastLayout.hasAboveIndicator = vp.hasAbove
   _lastLayout.hasBelowIndicator = vp.hasBelow
+  // 📖 Reset per-frame expansion layout info (re-set below when a card renders).
+  _lastLayout.expandedDetailAfterIdx = -1
+  _lastLayout.expandedDetailRows = 0
 
   for (let i = vp.startIdx; i < vp.endIdx; i++) {
     const r = sorted[i]
@@ -747,7 +772,9 @@ export function renderTable({
     }
     const prefixDisplayWidth = displayWidth(favoritePrefix)
     const nameWidth = Math.max(0, wModel - prefixDisplayWidth)
-    const name = favoritePrefix + r.label.slice(0, nameWidth).padEnd(nameWidth)
+    // 📖 Width-aware clip + display padding keeps emoji labels intact and the
+    // 📖 column perfectly aligned (see clipToWidth above).
+    const name = favoritePrefix + padEndDisplay(clipToWidth(r.label, nameWidth), nameWidth)
     const sweScore = r.sweScore ?? '—'
     // 📖 SWE% colorized on the same gradient as Tier:
     //   ≥70% bright neon green (S+), ≥60% green (S), ≥50% yellow-green (A+),
@@ -1090,6 +1117,10 @@ export function renderTable({
     // 📖 truncate them. Plain text is built first, clipped to the terminal
     // 📖 width, then colorized (same pattern as the table header).
     if (isCursor && expansionActive) {
+      // 📖 Mouse support (fix 15): record that 2 extra rows follow sorted index i
+      // 📖 so the click handler can shift row mappings below the card.
+      _lastLayout.expandedDetailAfterIdx = i
+      _lastLayout.expandedDetailRows = EXPANDED_DETAIL_LINES
       const maxDetailWidth = Math.max(0, (terminalCols || 80) - 4)
       const keyText = r.hasApiKey ? 'key configured' : 'no key'
       const endpoint = sources[r.providerKey]?.url ?? 'unknown endpoint'
@@ -1390,9 +1421,9 @@ export function renderTable({
   if (releaseLabel || speedTestLabel || globalBenchmarkLabel || probeLabel || probeCacheLabel || pausedProvidersLabel || enrichmentLabel || quotaLabel || actionErrorLabel) {
     const parts = [
       { text: '  ', key: null },
-      { text: speedTestLabel, key: 'a' },
+      { text: speedTestLabel, key: 'ctrl+a' },
       { text: '  ', key: null },
-      { text: globalBenchmarkLabel, key: 'u' },
+      { text: globalBenchmarkLabel, key: 'ctrl+u' },
       { text: probeLabel ? '  ' : '', key: null },
       { text: probeLabel, key: null },
       { text: actionErrorLabel ? '  ' : '', key: null },

package/src/tui/theme.js

@@ -280,6 +280,35 @@ export function getReadableTextRgb(bgRgb) {
   return yiq >= 150 ? [10, 16, 28] : [248, 251, 255]
 }
 
+// 📖 Cached OS-level appearance probe ('dark' | 'light'). The sync execSync
+// 📖 probe blocks the event loop up to 100ms and used to run inside the G
+// 📖 keypress, visibly freezing the UI on every theme cycle. It now resolves
+// 📖 once at startup; later calls reuse the cache and kick off a non-blocking
+// 📖 re-resolve so a mid-session macOS appearance change is picked up on the
+// 📖 NEXT press instead of freezing the current one.
+let osThemeCache = null
+
+function execOsThemeProbeSync() {
+  try {
+    const style = execSync('defaults read -g AppleInterfaceStyle 2>/dev/null', { timeout: 100 }).toString().trim()
+    return style === 'Dark' ? 'dark' : 'light'
+  } catch {
+    // 📖 The key is absent in Light mode, so a non-zero exit means light.
+    return 'light'
+  }
+}
+
+function refreshOsThemeAsync() {
+  import('node:child_process')
+    .then(({ execFile }) => {
+      execFile('defaults', ['read', '-g', 'AppleInterfaceStyle'], { timeout: 500 }, (err, stdout) => {
+        // 📖 Same semantics as the sync probe: read error = Light mode.
+        osThemeCache = (!err && String(stdout).trim() === 'Dark') ? 'dark' : 'light'
+      })
+    })
+    .catch(() => {})
+}
+
 export function detectActiveTheme(configTheme = 'auto') {
   if (configTheme === 'dark' || configTheme === 'light') {
     activeTheme = configTheme
@@ -297,12 +326,14 @@ export function detectActiveTheme(configTheme = 'auto') {
   }
 
   if (process.platform === 'darwin') {
-    try {
-      const style = execSync('defaults read -g AppleInterfaceStyle 2>/dev/null', { timeout: 100 }).toString().trim()
-      activeTheme = style === 'Dark' ? 'dark' : 'light'
-    } catch {
-      activeTheme = 'light'
+    if (osThemeCache === null) {
+      // 📖 First call (startup): one sync probe, then never again this session.
+      osThemeCache = execOsThemeProbeSync()
+    } else {
+      // 📖 Subsequent G presses: reuse the cache, refresh it in the background.
+      refreshOsThemeAsync()
     }
+    activeTheme = osThemeCache
     return activeTheme
   }
 

package/src/tui/tui-filters.js

@@ -8,14 +8,16 @@
  *   keypress that changes a filter mode, so the visible set is always consistent.
  *
  *   🎯 Filter precedence (first failing check hides the row):
- *   1. Configure-only mode (E key) — hide models with no API key or bad health
- *   2. Usable-only mode (E key, second cycle) — only Health UP + verdict Normal/Perfect/Slow
- *   3. Sticky favorites (Y key) — pinned favorites bypass tier/origin/text filters
- *   4. Tier filter (T key) — only show models in the selected tier family
- *   5. Origin filter (O key) — only show models from the selected provider
- *   6. Verdict filter (V key) — only show models with the selected verdict
- *   7. Health filter (H key) — only show models with the selected health status
- *   8. Custom text filter (Ctrl+P) — case-insensitive match on name, ctx, provider
+ *   1. Probe-cache broken models - cachedBroken rows stay hidden (Shift+B shows them)
+ *   2. 404-probe hidden models - keys in config.hiddenModels stay hidden
+ *   3. Configure-only mode (E key) - hide models with no API key or bad health
+ *   4. Usable-only mode (E key, second cycle) - only Health UP + verdict Normal/Perfect/Slow
+ *   5. Sticky favorites (Y key) - pinned favorites bypass tier/origin/text filters
+ *   6. Tier filter (T key) - only show models in the selected tier family
+ *   7. Origin filter (D key) - only show models from the selected provider
+ *   8. Verdict filter (Shift+V key) - only show models with the selected verdict
+ *   9. Health filter (Shift+H key) - only show models with the selected health status
+ *   10. Custom text filter (Ctrl+P) - case-insensitive match on name, ctx, provider
  *
  * @functions
  *   → createTuiFilters(state, deps) — Returns { applyTierFilter, buildOriginCycle }
@@ -54,6 +56,24 @@ export function createTuiFilters(state, { sources, getApiKey, PROVIDER_METADATA
     const activeHealth = HEALTH_CYCLE[state.healthFilterMode]
 
     state.results.forEach(r => {
+      // 📖 Probe-cache / 404-probe auto-hide must survive every frame: this filter
+      // 📖 runs at ~12 FPS and used to reset r.hidden=false for passing rows,
+      // 📖 clobbering the hidden state set at startup (app.js probe-cache prefill)
+      // 📖 and by the Shift+P / Ctrl+Shift+P 404 probe (config.hiddenModels).
+      // 📖 Same representation as app.js + key-handler Shift+B: cachedBroken rows
+      // 📖 hide unless showBrokenMode, and hiddenModels stores `provider/modelId`
+      // 📖 keys. autoHideBrokenModels=false unhides both (matches startup behavior).
+      const autoHideBrokenEnabled = state.config.settings?.autoHideBrokenModels !== false
+      if (r.cachedBroken && !state.showBrokenMode && autoHideBrokenEnabled) {
+        r.hidden = true
+        return
+      }
+      if (autoHideBrokenEnabled
+        && state.config.hiddenModels instanceof Set
+        && state.config.hiddenModels.has(`${r.providerKey}/${r.modelId}`)) {
+        r.hidden = true
+        return
+      }
       const stickyFavorite = state.favoritesPinnedAndSticky && r.isFavorite
       // 📖 CLI-only tools and Zen models don't need traditional API keys —
       // 📖 they authenticate via their own CLI login flow, so "configured only" should never hide them.

package/src/tui/tui-state.js

@@ -44,6 +44,22 @@ export const SPEED_MODE_DURATION_MS = 60_000
 // 📖 After this much inactivity, the ping loop slows down to save quota.
 export const IDLE_SLOW_AFTER_MS = 5 * 60_000
 
+// 📖 Max ping results kept per model row. Older entries shift out so r.pings
+// 📖 cannot grow unbounded during long sessions (avg/p95/uptime become a
+// 📖 rolling window over the last 300 pings instead of the whole session).
+export const PING_HISTORY_CAP = 300
+
+/**
+ * 📖 sanitizePingInterval: Accept only a positive finite number, else fallback.
+ * 📖 Shared guard for config.settings.pingInterval readers (TUI state, palette).
+ * @param {unknown} value
+ * @param {number} fallbackMs
+ * @returns {number}
+ */
+export function sanitizePingInterval(value, fallbackMs) {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : fallbackMs
+}
+
 /**
  * 📖 intervalToPingMode: Map a raw interval (ms) to the closest ping mode label.
  * @param {number} intervalMs
@@ -88,13 +104,12 @@ export function createTuiState({
   const now = Date.now()
 
   // 📖 Dynamic normal interval from config (default 10s)
-  const normalInterval = config.settings?.pingInterval ?? PING_MODE_INTERVALS.normal
+  const normalInterval = sanitizePingInterval(config.settings?.pingInterval, PING_MODE_INTERVALS.normal)
   // 📖 Respect config.settings.pingInterval at startup (issue #155).
   // 📖 CLI override is already merged into config.settings.pingInterval in app.js.
-  const configuredInterval = config.settings?.pingInterval
-  const hasConfiguredInterval =
-    typeof configuredInterval === 'number' && Number.isFinite(configuredInterval) && configuredInterval > 0
-  const initialInterval = hasConfiguredInterval ? configuredInterval : PING_MODE_INTERVALS.speed
+  // 📖 sanitizePingInterval rejects 0/negative/NaN so a corrupt config can't break pinging.
+  const hasConfiguredInterval = sanitizePingInterval(config.settings?.pingInterval, 0) > 0
+  const initialInterval = hasConfiguredInterval ? normalInterval : PING_MODE_INTERVALS.speed
   const initialMode = intervalToPingMode(initialInterval)
 
   return {
@@ -164,6 +179,7 @@ export function createTuiState({
     settingsAddKeyMode: false,
     settingsEditBuffer: '',
     settingsErrorMsg: null,
+    settingsErrorMsgClearTimer: null, // 📖 Tracked auto-clear timer (see key-handler scheduleErrorMsgClear)
     settingsTestResults: {},
     settingsTestDetails: {},
     settingsUpdateState: 'idle',
@@ -251,6 +267,7 @@ export function createTuiState({
     installedModelsScrollOffset: 0,
     installedModelsData: [],
     installedModelsErrorMsg: null,
+    installedModelsErrorMsgClearTimer: null, // 📖 Tracked auto-clear timer (see key-handler scheduleErrorMsgClear)
 
     // 📖 Router Dashboard overlay (Shift+R)
     routerDashboardOpen: false,
@@ -272,7 +289,6 @@ export function createTuiState({
     routerDashboardEventError: null,
     routerDashboardNotice: null,
     routerDashboardNoticeTimer: null,
-    routerOnboardingScrollOffset: 0,
     routerDashboardEverOpened: false,
     routerDashboardCursorIndex: 0,