sigrank 0.12.0 → 0.12.2

package/README.md

@@ -67,7 +67,7 @@ sigrank
 ## Commands
 
 ```
-⊙ SigRank CLI  v0.11.2
+⊙ SigRank CLI  v0.12.1
 
 Default (no args)
   sigrank              unified dashboard: cascade + token pillars + board
@@ -258,7 +258,7 @@ All adapters are token-only (no message content, no cost fields, no credentials)
 | Var | Default | Description |
 |---|---|---|
 | `SIGRANK_API_BASE` | `https://signalaf.com` | Override the board host |
-| `SIGRANK_FETCH_TIMEOUT_MS` | `10000` | Board API fetch timeout |
+| `SIGRANK_FETCH_TIMEOUT` | `10000` | Board API fetch timeout (ms) |
 
 ---
 

package/cli.mjs

@@ -396,6 +396,16 @@ async function runMe({ platform = 'claude', compare = false } = {}) {
 
 // ── COMPARE command ───────────────────────────────────────────────────────────
 // Side-by-side: ccusage (JSON) vs tokenpull vs token-dashboard (SQLite)
+//
+// NOTE (P3 2026-06-27): These sync verifier readers (ccusagePillars / tokscalePillars /
+// tokenDashPillars / appPillars) are INTENTIONALLY separate from tokenpull.mjs
+// `freshVerifierPillars()`. The compare command uses cached/file-based data sources
+// (tokscale_report.json, direct db read with windowed+model-filtered queries) for a
+// quick side-by-side, while freshVerifierPillars runs all three live (bunx tokscale,
+// scan+read tokendash) for the dashboard. Merging them would change compare's data
+// source and lose the windowed tokendash breakdown. ccusagePillars IS functionally
+// identical to _freshCcusage and could be consolidated in a future pass if compare
+// switches to live data — but that's a behavior change, not a refactor.
 
 function ccusagePillars(platform = 'claude') {
   // ccusage <platform> daily --json → sum by window
@@ -831,7 +841,7 @@ async function runSigRank() {
   writeln(`  ${gold('⊙ SigRank')}  ${bold('Operator Dashboard')}`)
   writeln(`  ${dim('reading local data…')}`)
 
-  const { tokenpullAny } = await import('./tokenpull.mjs')
+  const { tokenpullAny, freshVerifierPillars } = await import('./tokenpull.mjs')
 
   // Local sources first (fast) — board fetch with 5s timeout runs in parallel
   const boardPromise = Promise.race([
@@ -839,24 +849,16 @@ async function runSigRank() {
     new Promise(r => setTimeout(() => r(null), 5000)),
   ])
 
-  const [platformResults, tdPillars] = await Promise.all([
+  // FIX A1-CLI (2026-06-27): verifiers (ccusage/tokscale/tokendash) are fetched
+  // ON-DEMAND for ACTIVE platforms only — not synchronously for all 15 platforms
+  // upfront (which blocked Dashboard paint up to ~40s, same class of bug as TUI
+  // FIX A1). The sync ccusagePillars()/tokscalePillars()/tokenDashPillars() loop
+  // over ALL_PLATFORMS is replaced by parallel freshVerifierPillars() calls after
+  // we know which platforms actually have local data.
+  const [platformResults] = await Promise.all([
     Promise.allSettled(ALL_PLATFORMS.map(p => tokenpullAny(p))),
-    Promise.resolve(tokenDashPillars()),
   ])
 
-  // per-platform verifiers: ccusage + tokscale both support multiple platforms
-  // build map: platform → { cc, ts }
-  const verifierMap = {}
-  for (const platform of ALL_PLATFORMS) {
-    verifierMap[platform] = {
-      cc: ccusagePillars(platform),
-      ts: tokscalePillars(platform),
-    }
-  }
-  // keep top-level claude refs for combined section
-  const ccPillars = verifierMap['claude']?.cc ?? null
-  const tsPillars = verifierMap['claude']?.ts ?? null
-
   const boardData = await boardPromise
 
   // filter to platforms with actual data
@@ -872,6 +874,21 @@ async function runSigRank() {
     active.push(d)
   }
 
+  // Fetch verifiers on-demand for active platforms only (parallel, never throws).
+  // tdPillars (token-dashboard) is claude-only and pulled from the claude fresh result.
+  const verifierMap = {}
+  let tdPillars = null
+  if (active.length > 0) {
+    const fresh = await Promise.all(
+      active.map(d => freshVerifierPillars(d.platform).catch(() => ({ ccusage: null, tokscale: null, tokendash: null })))
+    )
+    for (let i = 0; i < active.length; i++) {
+      const f = fresh[i]
+      verifierMap[active[i].platform] = { cc: f.ccusage, ts: f.tokscale }
+      if (active[i].platform === 'claude' && f.tokendash) tdPillars = f.tokendash
+    }
+  }
+
   // clear the 3 loading lines (blank + header + "reading…")
   write(CURSOR_UP(3) + ERASE_LINE + CURSOR_UP(1) + ERASE_LINE + CURSOR_UP(1) + ERASE_LINE)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigrank",
-  "version": "0.12.0",
+  "version": "0.12.2",
   "description": "SigRank MCP server — the yield cascade + live leaderboard as MCP tools any agent can call",
   "type": "module",
   "license": "MIT",

package/tokenpull.mjs

@@ -17,13 +17,27 @@
 
 import { readdir, readFile, lstat } from 'node:fs/promises'
 import { existsSync } from 'node:fs'
-import { execSync } from 'node:child_process'
+import { execSync, execFile } from 'node:child_process'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
 import { ADAPTERS } from './adapters.mjs'
 
 const DAY_MS = 86_400_000
 
+// ASYNC FIX (2026-06-27): execFile wrapped in a Promise — replaces execSync in the
+// fresh verifier readers. execSync blocks the entire Node event loop (no key handling,
+// no screen repaint for up to 90s during the tokendash scan). execFile is async: the
+// event loop keeps running, so the TUI stays responsive while external commands run.
+// Returns stdout as a string. Rejects on error or timeout (caller catches → null).
+function execFileAsync(cmd, args, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    execFile(cmd, args, { timeout: timeoutMs, stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 10 * 1024 * 1024 }, (err, stdout) => {
+      if (err) reject(err)
+      else resolve(stdout.toString())
+    })
+  })
+}
+
 // Background tooling that runs under your account but is NOT your work — memory plugins,
 // observers, summarizers, sub-agent fleets. They pad output/Υ (claude-mem did ~27%).
 // Excluded so pillars reflect the operator, not their tools. EXTENSIBLE — add tool
@@ -297,9 +311,13 @@ export async function tokenpullAny(platform, opts = {}) {
 
 // ccusage: run `ccusage <platform> daily --json` and bucket the daily rows into the four
 // windows by date. Logic copied from tools.mjs `_ccusagePillars` (do NOT import private fns).
-function _freshCcusage(platform = 'claude') {
+//
+// ASYNC FIX (2026-06-27): was execSync (blocked the entire event loop for up to 15s,
+// freezing the TUI locked frame + key handling). Now uses execFile (async) so the
+// event loop keeps running — the TUI stays responsive while the external command runs.
+async function _freshCcusage(platform = 'claude') {
   try {
-    const raw = execSync(`ccusage ${platform} daily --json`, { timeout: 15000, stdio: ['ignore', 'pipe', 'ignore'] }).toString()
+    const raw = await execFileAsync('ccusage', [platform, 'daily', '--json'], 15000)
     const rows = JSON.parse(raw)?.daily ?? JSON.parse(raw)
     if (!Array.isArray(rows)) return null
     const now = Date.now()
@@ -329,24 +347,26 @@ function _freshCcusage(platform = 'claude') {
 // tokendash: REFRESH ~/.claude/token-dashboard.db by running the dashboard's scan, then read
 // the live db via sqlite3. Claude only (the db only holds Claude Code sessions). The scan is
 // best-effort: if it fails (tool missing, slow), we still read whatever the db currently has.
-function _freshTokendash(platform = 'claude') {
+//
+// ASYNC FIX (2026-06-27): was execSync with a 90s timeout — that blocked the ENTIRE event
+// loop for up to 90 seconds, freezing the TUI completely (no key handling, no frame repaint).
+// Now uses execFile (async) so the TUI stays responsive during the scan.
+async function _freshTokendash(platform = 'claude') {
   if (platform !== 'claude') return null
   const dbPath = join(homedir(), '.claude', 'token-dashboard.db')
   const scanCli = join(homedir(), 'Desktop', 'token-dashboard', 'cli.py')
   // Step 1 — refresh the db (best-effort; failures must not abort the read).
   if (existsSync(scanCli)) {
-    try {
-      execSync(`python3 "${scanCli}" scan`, { timeout: 90000, stdio: ['ignore', 'ignore', 'ignore'] })
-    } catch { /* continue: read whatever the db currently has */ }
+    try { await execFileAsync('python3', [scanCli, 'scan'], 90000) }
+    catch { /* continue: read whatever the db currently has */ }
   }
   // Step 2 — read the (now-refreshed) db. all-time only; the db doesn't expose windowing here.
   if (!existsSync(dbPath)) return null
   try {
-    const raw = execSync(
-      `sqlite3 "${dbPath}" "SELECT SUM(input_tokens),SUM(output_tokens),SUM(cache_create_5m_tokens)+SUM(cache_create_1h_tokens),SUM(cache_read_tokens) FROM messages"`,
-      { timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] },
-    ).toString().trim()
-    const [i, o, cw, cr] = raw.split('|').map(Number)
+    const raw = await execFileAsync('sqlite3', [dbPath,
+      'SELECT SUM(input_tokens),SUM(output_tokens),SUM(cache_create_5m_tokens)+SUM(cache_create_1h_tokens),SUM(cache_read_tokens) FROM messages'
+    ], 5000)
+    const [i, o, cw, cr] = raw.trim().split('|').map(Number)
     if (![i, o, cw, cr].some((n) => Number.isFinite(n) && n > 0)) return null
     return { all: { input: i || 0, output: o || 0, cacheCreate: cw || 0, cacheRead: cr || 0 } }
   } catch { return null }
@@ -358,9 +378,12 @@ function _freshTokendash(platform = 'claude') {
 // `client` maps directly to our platform name. Synthetic/unknown model rows are dropped (they
 // carry no real usage). all-time only — tokscale's models view is not windowed. If no row
 // matches the platform, return null gracefully.
-function _freshTokscale(platform = 'claude') {
+//
+// ASYNC FIX (2026-06-27): was execSync with a 60s timeout — blocked the event loop entirely.
+// Now uses execFile (async) so the TUI stays responsive.
+async function _freshTokscale(platform = 'claude') {
   try {
-    const raw = execSync(`bunx tokscale@latest models --json`, { timeout: 60000, stdio: ['ignore', 'pipe', 'ignore'] }).toString()
+    const raw = await execFileAsync('bunx', ['tokscale@latest', 'models', '--json'], 60000)
     const data = JSON.parse(raw)
     const entries = Array.isArray(data?.entries) ? data.entries : (Array.isArray(data) ? data : [])
     const rows = entries.filter((e) =>

package/tools.mjs

@@ -22,6 +22,12 @@ import path from 'node:path'
 
 // ── Verifier readers (sync, on-device, token-only) ────────────────────────────
 // These mirror the implementations in cli.mjs / tui.mjs without the circular import.
+//
+// NOTE (P3 2026-06-27): Intentionally separate from tokenpull.mjs `freshVerifierPillars()`.
+// The MCP `tokenpull_compare` tool uses these file-based/cached readers (tokscale_report.json,
+// direct db read) for a quick comparison, while freshVerifierPillars runs all sources live
+// (bunx tokscale, scan+read tokendash) for the TUI/CLI dashboard. Different data sources =
+// different behavior; do NOT merge without understanding the trade-off.
 
 function _ccusagePillars(platform = 'claude') {
   try {

package/tui.mjs

@@ -221,70 +221,13 @@ function sparkline(values) {
   }).join('')
 }
 
-// ── Data sources (same as cli.mjs) ──────────────────────────────────────────
-function ccusagePillars(platform = 'claude') {
-  try {
-    const cmd = platform === 'claude' ? 'ccusage claude daily --json' : `ccusage ${platform} daily --json`
-    const raw = execSync(cmd, { timeout: 15000, stdio: ['ignore', 'pipe', 'ignore'] }).toString()
-    const data = JSON.parse(raw)
-    const rows = data.daily ?? data
-    const now = Date.now()
-    const cutoff = { '7d': 7, '30d': 30, '90d': 90 }
-    const result = {}
-    for (const [win, days] of Object.entries(cutoff)) {
-      const since = new Date(now - days * 86400000)
-      let i = 0, o = 0, cw = 0, cr = 0
-      for (const row of rows) {
-        if (new Date(row.date ?? row.day ?? '1970') >= since) {
-          i  += row.inputTokens        ?? row.input_tokens        ?? 0
-          o  += row.outputTokens       ?? row.output_tokens       ?? 0
-          cw += row.cacheCreationTokens ?? row.cache_create_tokens ?? 0
-          cr += row.cacheReadTokens    ?? row.cache_read_tokens   ?? 0
-        }
-      }
-      result[win] = { input: i, output: o, cacheCreate: cw, cacheRead: cr }
-    }
-    let i = 0, o = 0, cw = 0, cr = 0
-    for (const row of rows) {
-      i  += row.inputTokens        ?? 0
-      o  += row.outputTokens       ?? 0
-      cw += row.cacheCreationTokens ?? 0
-      cr += row.cacheReadTokens    ?? 0
-    }
-    result['all'] = { input: i, output: o, cacheCreate: cw, cacheRead: cr }
-    return result
-  } catch { return null }
-}
-
-function tokscalePillars(platform = 'claude') {
-  const p = path.join(os.homedir(), 'tokscale_report.json')
-  if (!existsSync(p)) return null
-  try {
-    const data = JSON.parse(readFileSync(p, 'utf8'))
-    const rows = (data.entries ?? []).filter(e =>
-      e.client === platform && e.model !== '<synthetic>' && e.model !== 'unknown' && (e.input > 0 || e.output > 0)
-    )
-    if (!rows.length) return null
-    const acc = rows.reduce((a, e) => ({
-      input: a.input + (e.input ?? 0), output: a.output + (e.output ?? 0),
-      cacheCreate: a.cacheCreate + (e.cacheWrite ?? 0), cacheRead: a.cacheRead + (e.cacheRead ?? 0),
-    }), { input: 0, output: 0, cacheCreate: 0, cacheRead: 0 })
-    return { all: acc }
-  } catch { return null }
-}
-
-function tokenDashPillars() {
-  const dbPath = path.join(os.homedir(), '.claude', 'token-dashboard.db')
-  if (!existsSync(dbPath)) return null
-  try {
-    const raw = execSync(
-      `sqlite3 "${dbPath}" "SELECT SUM(input_tokens),SUM(output_tokens),SUM(cache_create_5m_tokens)+SUM(cache_create_1h_tokens),SUM(cache_read_tokens) FROM messages"`,
-      { timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] }
-    ).toString().trim()
-    const [i, o, cw, cr] = raw.split('|').map(Number)
-    return { all: { input: i || 0, output: o || 0, cacheCreate: cw || 0, cacheRead: cr || 0 } }
-  } catch { return null }
-}
+// ── Data sources ─────────────────────────────────────────────────────────────
+// (0.12.1 FIX 4) The local verifier readers (ccusage / tokscale / token-dashboard)
+// moved to `freshVerifierPillars()` in tokenpull.mjs — FRESH on-demand pulls used by
+// the Compare tab (#9). The old in-tui copies were dead after A1 removed the Dashboard
+// verifierMap loop and #9 routed Compare through the fresh helper; removed here.
+// (tools.mjs keeps its own `_ccusagePillars`/`_tokscalePillars`/`_tokenDashPillars` —
+// still used by the `tokenpull_compare` MCP tool.)
 
 async function loadDashboardData() {
   const { tokenpullAny } = await import('./tokenpull.mjs')
@@ -474,7 +417,40 @@ function yieldSpark(d) {
 }
 
 // ── TAB 1: DASHBOARD ─────────────────────────────────────────────────────────
-function renderDashboard(data, status = '') {
+
+// SCROLL-VIEW (2026-06-27): section-scoped scroll for the cascade table.
+// The cascade section gets a real scroll viewport — up/down arrows scroll just
+// the cascade rows while the rest of the dashboard (header, token composition,
+// board, footer) stays pinned. This replaces the misleading "+N more — resize /
+// scroll" text (A3) which implied scroll existed but didn't (alt-screen locked
+// frame = no terminal scroll). The scroll is IN-SECTION only, on the Dashboard tab.
+
+const DASH_WINS = ['7d', '30d', '90d', 'all']
+
+// Count how many cascade rows the active platforms would produce (every window
+// with data across all active platforms). This is the "total wanted" count.
+function cascadeScrollableCount(active) {
+  return active.reduce((n, d) =>
+    n + DASH_WINS.filter(wk => {
+      const wd = d.windows?.find(x => x.window === wk)
+      return wd && (wd.pillars.input + wd.pillars.output) > 0
+    }).length, 0)
+}
+
+// Compute the max cascade rows that fit in the current terminal height budget.
+// Mirrors the calculation in renderDashboard (budget - used - sectionsBelow).
+function maxCascadeRowsFor(active) {
+  const budget = H() - 4  // 2 tab bar + 2 footer
+  const platformCount = active.length
+  const barLines = 4 + platformCount + (platformCount > 1 ? 1 : 0)
+  const boardLines = 17
+  const sectionsBelow = barLines + boardLines
+  // used before cascade = header(2) + blank(1) + title(1) + blank(1) + col-header(1) + separator(1) = 7
+  const usedBeforeCascade = 7
+  return Math.max(8, budget - usedBeforeCascade - sectionsBelow)
+}
+
+function renderDashboard(data, status = '', scrollOffset = 0) {
   const w = W()
   const budget = H() - 4  // 2 tab bar + 2 footer
   const WINS = ['7d', '30d', '90d', 'all']
@@ -554,35 +530,51 @@ function renderDashboard(data, status = '') {
   const sectionsBelow = barLines + boardLines
   const maxCascadeRows = Math.max(8, budget - used - sectionsBelow)
 
-  // A3 (2026-06-27): count the cascade rows we WANT to show (every window with data across all
-  // active platforms) so we can tell the user how many were dropped by the height budget, instead
-  // of silently truncating them. (Fit logic below is unchanged — this is observation only.)
-  const totalCascadeRowsWanted = active.reduce((n, d) =>
-    n + WINS.filter(wk => {
-      const wd = d.windows?.find(x => x.window === wk)
-      return wd && (wd.pillars.input + wd.pillars.output) > 0
-    }).length, 0)
-
+  // SCROLL-VIEW (2026-06-27): Build the full list of cascade rows first, then
+  // slice by [scrollOffset, scrollOffset + maxCascadeRows]. This gives a real
+  // in-section scroll viewport — up/down arrows scroll just the cascade rows
+  // while the rest of the dashboard stays pinned. Replaces the A3 "+N more —
+  // resize / scroll" text which implied scroll existed but didn't.
   let firstWin = {}
-  let cascadeRowCount = 0
+  const allCascadeRows = []  // flat list: { platform, winKey, pillars, estimated }
   for (const d of active) {
     firstWin[d.platform] = WINS.find(wk => {
       const wd = d.windows?.find(w => w.window === wk)
       return wd && (wd.pillars.input + wd.pillars.output) > 0
     })
     for (const wk of WINS) {
-      if (cascadeRowCount >= maxCascadeRows || used >= budget - sectionsBelow) break
       const wd = d.windows?.find(x => x.window === wk)
       if (!wd || (wd.pillars.input + wd.pillars.output) === 0) continue
-      renderRow(d.platform, (s) => wk === firstWin[d.platform] ? cyan(s) : dim(s), wk, wd.pillars, d.estimated)
-      cascadeRowCount++
+      allCascadeRows.push({ platform: d.platform, winKey: wk, pillars: wd.pillars, estimated: d.estimated })
     }
-    emit()
   }
 
-  // A3: if any cascade rows were dropped (height budget / row cap), say so instead of hiding them.
-  const cascadeDropped = totalCascadeRowsWanted - cascadeRowCount
-  if (cascadeDropped > 0) emit(`  ${dim(`  +${cascadeDropped} more — resize / scroll`)}`)
+  const totalWanted = allCascadeRows.length
+  const canScroll = totalWanted > maxCascadeRows
+  // Clamp scroll offset to valid range [0, totalWanted - maxCascadeRows]
+  const maxOffset = Math.max(0, totalWanted - maxCascadeRows)
+  const effectiveOffset = Math.min(scrollOffset, maxOffset)
+  const visibleRows = allCascadeRows.slice(effectiveOffset, effectiveOffset + maxCascadeRows)
+
+  // ▲ indicator: rows above the current viewport
+  if (canScroll && effectiveOffset > 0) {
+    emit(`  ${dim(`  ▲ ${effectiveOffset} row${effectiveOffset > 1 ? 's' : ''} above`)}`)
+  }
+
+  // Render the visible slice — group by platform (emit a blank line between platforms)
+  let lastPlatform = null
+  for (const row of visibleRows) {
+    if (lastPlatform !== null && row.platform !== lastPlatform) emit()
+    renderRow(row.platform, (s) => row.winKey === firstWin[row.platform] ? cyan(s) : dim(s), row.winKey, row.pillars, row.estimated)
+    lastPlatform = row.platform
+  }
+  if (visibleRows.length > 0) emit()
+
+  // ▼ indicator: rows below the current viewport
+  const rowsBelow = totalWanted - effectiveOffset - visibleRows.length
+  if (canScroll && rowsBelow > 0) {
+    emit(`  ${dim(`  ▼ ${rowsBelow} row${rowsBelow > 1 ? 's' : ''} below · ↑↓ scroll`)}${effectiveOffset > 0 ? dim(` · ${effectiveOffset}/${maxOffset}`) : ''}`)
+  }
 
   // combined
   if (active.length > 1 && used < budget - sectionsBelow) {
@@ -763,7 +755,9 @@ function renderTrends(data, subIdx = 0) {
       emit()
     }
     // A3: surface the dropped count instead of hiding it.
-    if (trendsDropped > 0) emit(`  ${dim(`  +${trendsDropped} more — resize / scroll`)}`)
+    // SCROLL-VIEW (2026-06-27): changed "resize / scroll" → "resize to see more"
+    // because these tabs don't have a real scroll viewport (only Dashboard cascade does).
+    if (trendsDropped > 0) emit(`  ${dim(`  +${trendsDropped} more — resize to see more`)}`)
   } else { // Field
     emit(`  ${dim('  Field-wide trends — calculating…')}`)
     emit(`  ${dim('  (needs per-window board history; materializes once live ingest lands)')}`)
@@ -939,8 +933,10 @@ function renderSubmissions(boardData, window = '30d', filterCodename = null, hig
     shown++
   }
   // A3-style: if the height budget dropped rows, say so instead of silently truncating.
+  // SCROLL-VIEW (2026-06-27): changed "resize / scroll" → "resize to see more"
+  // (Board tab doesn't have a real scroll viewport — only Dashboard cascade does).
   const dropped = sorted.length - shown
-  if (dropped > 0 && used < budget) emit(`  ${dim(`  +${dropped} more — resize / scroll`)}`)
+  if (dropped > 0 && used < budget) emit(`  ${dim(`  +${dropped} more — resize to see more`)}`)
 }
 
 // ── TAB 3: BOARD ─────────────────────────────────────────────────────────────
@@ -1360,6 +1356,7 @@ export async function runTui({ platform: initPlatform = 'claude', window: win =
   let submitMsg    = ''        // [S] in-place submit result, shown in the read-tab footer
   let submitPreview = false    // FIX I1: [S] opens a preview grid before sending (see→confirm→send)
   let boardYouOnly = false     // FIX I2: [Y] toggles the Board to "just me" (hybrid model)
+  let cascadeScroll = 0        // SCROLL-VIEW (2026-06-27): cascade-section scroll offset (Dashboard only)
 
   // ── Redraw (buffered: renders into memory, then paints as a locked frame)
   const redraw = async () => {
@@ -1386,9 +1383,13 @@ export async function runTui({ platform: initPlatform = 'claude', window: win =
       if (!dashData) {
         writeln(`\n  ${dim('loading dashboard…')}`)
       } else {
-        renderDashboard(dashData, status)
+        renderDashboard(dashData, status, cascadeScroll)
       }
-      setFooter(readFooter(`${hint}${submitHint}`))
+      // SCROLL-VIEW: show ↑↓ hint only when there are cascade rows to scroll
+      const scrollHint = dashData && Array.isArray(dashData.active)
+        ? cascadeScrollableCount(dashData.active) > maxCascadeRowsFor(dashData.active) ? `   ${dim('↑↓ scroll cascade')}` : ''
+        : ''
+      setFooter(readFooter(`${hint}${scrollHint}${submitHint}`))
     } else if (activeTab === 1) {                // Trends
       if (!dashData) {
         writeln(`\n  ${dim('loading trends…')}`)
@@ -1631,6 +1632,33 @@ export async function runTui({ platform: initPlatform = 'claude', window: win =
         return
       }
 
+      // SCROLL-VIEW (2026-06-27): ↑/↓ (or j/k) scroll the cascade section on the
+      // Dashboard tab ONLY. The rest of the dashboard stays pinned. Only active
+      // when there are more cascade rows than fit in the viewport.
+      if (activeTab === 0 && dashData && Array.isArray(dashData.active)) {
+        const total = cascadeScrollableCount(dashData.active)
+        const maxRows = maxCascadeRowsFor(dashData.active)
+        if (total > maxRows) {
+          const maxOff = total - maxRows
+          if (key === '\x1b[A' || k === 'k') {              // ↑ / k → scroll up
+            cascadeScroll = Math.max(0, cascadeScroll - 1)
+            await redraw(); return
+          }
+          if (key === '\x1b[B' || k === 'j') {              // ↓ / j → scroll down
+            cascadeScroll = Math.min(maxOff, cascadeScroll + 1)
+            await redraw(); return
+          }
+          if (key === '\x1b[5~') {                          // PageUp → scroll up by viewport
+            cascadeScroll = Math.max(0, cascadeScroll - maxRows)
+            await redraw(); return
+          }
+          if (key === '\x1b[6~') {                          // PageDown → scroll down by viewport
+            cascadeScroll = Math.min(maxOff, cascadeScroll + maxRows)
+            await redraw(); return
+          }
+        }
+      }
+
       // tab switching (6 tabs: 0=Dashboard 1=Trends 2=Compare 3=Board 4=Watch 5=Connect)
       let switched = false
       if (key === '\x1b[C') { activeTab = Math.min(5, activeTab + 1); switched = true }
@@ -1643,14 +1671,23 @@ export async function runTui({ platform: initPlatform = 'claude', window: win =
       if (k === '6') { activeTab = 5; switched = true }  // Connect = sign in / switch device
       if (k === 'c' && activeTab !== 5) { activeTab = 5; switched = true }  // [C] → Connect from any read tab
 
+      // SCROLL-VIEW: reset cascade scroll when leaving the Dashboard tab
+      if (switched && activeTab !== 0) cascadeScroll = 0
+
       // #9 (2026-06-27): Compare loads its FRESH verifier pull ON-DEMAND when the tab opens
       // (NOT on the Dashboard load path — that pull is a 5–60s scan). Paint the "pulling fresh
       // sources…" spinner first (compareData null → redraw shows it), then run the pull + re-render.
+      // ASYNC FIX (2026-06-27): with execFile (async), the event loop keeps running during the
+      // pull — key presses are NOT blocked. Guard: only render the result if the user is still
+      // on the Compare tab (they may have switched away during the pull).
       if (switched && activeTab === 2 && !compareData) {
         submitMsg = ''
         await redraw()  // show the spinner line before the (slow) fresh pull
-        compareData = await loadCompareData(platform).catch(() => null)
-        await redraw()
+        const result = await loadCompareData(platform).catch(() => null)
+        if (activeTab === 2) {  // still on Compare? render the result
+          compareData = result
+          await redraw()
+        }
         return
       }
 
@@ -1674,8 +1711,12 @@ export async function runTui({ platform: initPlatform = 'claude', window: win =
           compareData = null
           status = `loading ${platform}…`
           await redraw()
-          compareData = await loadCompareData(platform).catch(() => null)
-          status = `last refreshed ${new Date().toLocaleTimeString('en-US', { hour12: false })}`
+          // ASYNC FIX: guard — only render if still on Compare (user may have switched away)
+          const result = await loadCompareData(platform).catch(() => null)
+          if (activeTab === 2) {
+            compareData = result
+            status = `last refreshed ${new Date().toLocaleTimeString('en-US', { hour12: false })}`
+          }
         } else {
           // A5: Watch [P] cycles 'all' → claude → codex → … → 'all' (optional focus; default 'all').
           const WATCH_PLAT_CYCLE = ['all', ...CYCLE_PLATFORMS]
@@ -1714,14 +1755,19 @@ export async function runTui({ platform: initPlatform = 'claude', window: win =
 
       if (k === 'r') {
         status = 'refreshing…'
+        cascadeScroll = 0  // SCROLL-VIEW: reset scroll on refresh
         // #9: on the Compare tab, [R] re-runs the FRESH verifier pull for the current platform
         // (loadAll no longer touches Compare). Clearing compareData shows the spinner first.
         if (activeTab === 2) {
           compareData = null
           await redraw()
-          compareData = await loadCompareData(platform).catch(() => null)
-          status = `last refreshed ${new Date().toLocaleTimeString('en-US', { hour12: false })}`
-          await redraw()
+          // ASYNC FIX: guard — only render if still on Compare
+          const result = await loadCompareData(platform).catch(() => null)
+          if (activeTab === 2) {
+            compareData = result
+            status = `last refreshed ${new Date().toLocaleTimeString('en-US', { hour12: false })}`
+            await redraw()
+          }
           return
         }
         await redraw()