sigrank 0.11.4 → 0.12.0

package/cli.mjs

@@ -12,8 +12,9 @@
  *   npx sigrank me                   your cascade across all 4 windows
  *   npx sigrank me --platform amp    use a different platform adapter
  *   npx sigrank me --compare         raw pillar comparison: ccusage vs tokenpull vs token-dashboard
- *   npx sigrank watch                RT tune meter — local cascade, refreshes
- *   npx sigrank watch --window 7d    watch a specific window
+ *   npx sigrank watch                RT tune meter — ALL active platforms × all windows
+ *   npx sigrank watch --platform X   watch one platform only (optional filter)
+ *   npx sigrank watch --window 7d    watch one window only (optional filter)
  *
  * Color palette mirrors the SigRank web dark theme:
  *   gold = class TRANSMITTER headline + rank #1
@@ -684,37 +685,50 @@ async function runCompare({ platform = 'claude' } = {}) {
 }
 
 // ── WATCH command ─────────────────────────────────────────────────────────────
+//
+// A5: by default (no --platform / --window) the watcher auto-loads EVERYTHING — every
+// active platform (input+output > 0) × every window (7d/30d/90d/all), refreshed each tick.
+// --platform / --window remain OPTIONAL filters for back-compat (focus one cell). The
+// refresh loop + --submit behavior are preserved; submit publishes whichever windows are
+// shown whenever their Υ changes.
+
+const WATCH_WINDOWS = ['7d', '30d', '90d', 'all']
+
+// Detect which platforms have real local data (input+output > 0 in any window) via tokenpull.
+// Returns an array of pull results (the same shape tokenpullAny yields), one per active platform.
+async function detectActivePulls() {
+  const { tokenpullAny } = await import('./tokenpull.mjs')
+  const settled = await Promise.allSettled(ALL_PLATFORMS.map((p) => tokenpullAny(p)))
+  const active = []
+  for (const r of settled) {
+    if (r.status !== 'fulfilled' || !r.value) continue
+    const d = r.value
+    const live = (d.windows || []).some((w) => (w.pillars.input + w.pillars.output) > 0)
+    if (live) active.push(d)
+  }
+  return active
+}
 
-async function runWatch({ platform = 'claude', window: win = '7d', refresh = 30, submit = false } = {}) {
-  let prev = null
+async function runWatch({ platform, window: win, refresh = 30, submit = false } = {}) {
   let lines = 0
-  let lastSubmit = null
   const id = submit ? ensureIdentity() : null
   const enrolled = !!(id && id.codename && id.operator_id && id.private_key_pkcs8_b64)
 
-  write(HIDE_CURSOR)
+  // Filters: when provided, narrow the grid; when absent, watch all active × all windows.
+  const winFilter = typeof win === 'string' && win ? win : null
+  const platFilter = typeof platform === 'string' && platform ? platform : null
+  const windows = winFilter ? [winFilter] : WATCH_WINDOWS
 
-  const draw = async () => {
-    let result
-    try {
-      result = await callTool('watch_tokenpull', { platform, window: win })
-    } catch (e) {
-      writeln(red(`  ✗ ${e.message}`))
-      return
-    }
+  // Per-cell Υ memory (key = `${platform}|${window}`) so each cell tracks its own change.
+  const prevY = new Map()
+  const lastSubmitMsg = new Map()
 
-    const cas = result.cascade
-    const changed = prev !== null && prev !== cas?.yield
+  write(HIDE_CURSOR)
 
-    // --submit (D7 §7): publish the verified window on first observation + whenever Υ changes.
-    if (submit && enrolled && (prev === null || changed)) {
-      try {
-        const r = await submitSignedWindow(win, result.pillars, result.messages, id, { platform: result.platform })
-        lastSubmit = r.status === 'received' ? green(`✓ submitted · tier=${r.verification_tier || '—'}`) : red(`✗ ${r.reason || r.status}`)
-      } catch (e) {
-        lastSubmit = red(`✗ ${e.message}`)
-      }
-    }
+  const draw = async () => {
+    // Re-detect each tick so a platform that just started writing logs appears automatically.
+    let pulls = await detectActivePulls().catch(() => [])
+    if (platFilter) pulls = pulls.filter((d) => d.platform === platFilter)
 
     if (lines > 0) write(CURSOR_UP(lines))
 
@@ -723,31 +737,64 @@ async function runWatch({ platform = 'claude', window: win = '7d', refresh = 30,
     const w = termWidth()
     const ts = new Date().toLocaleTimeString('en-US', { hour12: false })
 
+    const scopeLabel = (platFilter || 'all active platforms') + '  ·  ' + (winFilter ? `window: ${winFilter}` : 'all windows')
+
     push()
-    push(`  ${gold('⊙ SigRank')} ${bold('Watch')}  ${dim(`${platform}  ·  window: ${win}  ·  ${ts}`)}`)
+    push(`  ${gold('⊙ SigRank')} ${bold('Watch')}  ${dim(`${scopeLabel}  ·  ${ts}`)}`)
     push(`  ${dim('─'.repeat(w - 4))}`)
-    push()
 
-    const yDisplay = cas?.yield != null ? fmtYield(cas.yield) : '—'
-    const indicator = changed ? green(' ▲ updated') : dim(' · no change')
+    if (pulls.length === 0) {
+      push()
+      push(`  ${dim('no active platforms detected — run some sessions, this will pick them up automatically')}`)
+      push()
+    }
 
-    push(`  ${bold('Υ Yield')}      ${cas?.yield != null ? gold(yDisplay) : '—'}${indicator}`)
-    push(`  ${bold('SNR')}          ${fmtSNR(cas?.snr)}`)
-    push(`  ${bold('Leverage')}     ${cas?.leverage != null ? `${fmtLev(cas.leverage)}×` : '—'}`)
-    push(`  ${bold('Velocity')}     ${cas?.velocity != null ? cas.velocity.toFixed(2) : '—'}`)
-    push(`  ${bold('10xDEV')}       ${cas?.dev10x != null ? cas.dev10x.toFixed(2) : '—'}`)
-    push(`  ${bold('Class')}        ${colorClass(cas?.class ?? '—')}`)
-    push()
-    if (submit) {
-      push(`  ${dim('submit:')} ${enrolled ? (lastSubmit || dim('waiting for a change…')) : red('not enrolled — run `npx sigrank enroll`')}`)
+    for (const d of pulls) {
+      const plat = d.platform
+      const byWin = {}
+      for (const ww of (d.windows || [])) byWin[ww.window] = ww
+      push()
+      push(`  ${cyan(plat)}${d.estimated ? dim(' (est)') : ''}`)
+      for (const wk of windows) {
+        const ww = byWin[wk]
+        const cas = ww ? cascadeFromPillars(ww.pillars) : null
+        const key = `${plat}|${wk}`
+        const prev = prevY.get(key)
+        const yNow = cas?.yield ?? null
+        const changed = prev !== undefined && prev !== yNow
+
+        // --submit: publish this cell on first observation + whenever its Υ changes.
+        if (submit && enrolled && ww && yNow != null && (prev === undefined || changed)) {
+          try {
+            const r = await submitSignedWindow(wk, ww.pillars, ww.messages, id, { platform: plat })
+            lastSubmitMsg.set(key, r.status === 'received' ? green(`✓ tier=${r.verification_tier || '—'}`) : red(`✗ ${r.reason || r.status}`))
+          } catch (e) {
+            lastSubmitMsg.set(key, red(`✗ ${e.message}`))
+          }
+        }
+        prevY.set(key, yNow)
+
+        const winLabel = wk === 'all' ? 'all-time' : wk
+        const yDisplay = cas?.yield != null ? gold(fmtYield(cas.yield)) : dim('—')
+        const indicator = changed ? green(' ▲') : dim(' ·')
+        const metrics = cas
+          ? `${dim('SNR')} ${fmtSNR(cas.snr)}  ${dim('Lev')} ${cas.leverage != null ? fmtLev(cas.leverage) + '×' : '—'}  ${dim('Vel')} ${cas.velocity != null ? cas.velocity.toFixed(2) : '—'}  ${colorClass(cas.class ?? '—')}`
+          : dim('no data')
+        const submitNote = (submit && enrolled) ? '  ' + (lastSubmitMsg.get(key) || dim('…')) : ''
+        push(`    ${padEnd(winLabel, 8)}  ${bold('Υ')} ${yDisplay}${indicator}  ${metrics}${submitNote}`)
+      }
     }
+
+    push()
     push(`  ${dim('─'.repeat(w - 4))}`)
+    if (submit && !enrolled) {
+      push(`  ${red('not enrolled — run `npx sigrank enroll` to auto-submit')}`)
+    }
     push(`  ${dim(`polling every ${refresh}s  ·  ${submit ? 'auto-submit ON  ·  ' : ''}tokens stay on your machine  ·  ctrl+c to exit`)}`)
     push()
 
     write(out.join('\n'))
     lines = out.length
-    prev = cas?.yield ?? null
   }
 
   try {
@@ -1213,11 +1260,12 @@ async function showHelp() {
   writeln(`    ${cyan('compare --platform codex')} compare for a specific platform`)
   writeln(`    ${cyan('tui')}                      full tabbed TUI: Dashboard / Compare / Board / Watch`)
   writeln(`    ${cyan('tui --platform codex')}     TUI with a different default platform`)
-  writeln(`    ${cyan('watch')}                    live tune meter — re-reads local logs every 30s`)
-  writeln(`    ${cyan('watch --window 7d')}        watch a specific window`)
+  writeln(`    ${cyan('watch')}                    live tune meter — ALL active platforms × all windows, every 30s`)
+  writeln(`    ${cyan('watch --platform codex')}   watch only one platform (optional filter)`)
+  writeln(`    ${cyan('watch --window 7d')}        watch only one window (optional filter)`)
   writeln()
   writeln(`  ${bold('Options')}`)
-  writeln(`    ${dim('--window')}    7d · 30d · 90d · all  (default: 30d for board, 7d for watch)`)
+  writeln(`    ${dim('--window')}    7d · 30d · 90d · all  (default: 30d for board; all windows for watch)`)
   writeln(`    ${dim('--platform')}  claude · codex · amp · gemini · opencode · goose · …`)
   writeln(`    ${dim('--refresh')}   poll interval in seconds (default: 30)`)
   writeln(`    ${dim('--once')}      print once and exit (board only)`)
@@ -1337,14 +1385,31 @@ export async function runCli(argv) {
   const args = argv.slice(2) // strip 'node' + script path
   const cmd  = args[0]
 
-  // parse --key value flags
+  // parse --key value AND --key=value flags. E4: validate against the known set and warn
+  // (don't crash) on anything unknown, so a typo'd flag is visible instead of silently ignored.
+  const KNOWN_FLAGS = new Set(['window', 'platform', 'refresh', 'once', 'submit', 'compare', 'label'])
   const flags = {}
   for (let i = 1; i < args.length; i++) {
-    if (args[i].startsWith('--')) {
-      const key = args[i].slice(2)
-      const val = args[i + 1] && !args[i + 1].startsWith('--') ? args[++i] : true
-      flags[key] = val
+    const a = args[i]
+    if (!a.startsWith('--')) continue
+    const body = a.slice(2)
+    let key, val
+    const eq = body.indexOf('=')
+    if (eq !== -1) {
+      // --flag=value form
+      key = body.slice(0, eq)
+      val = body.slice(eq + 1)
+    } else {
+      // --flag [value] form: consume the next token as the value unless it's another flag
+      key = body
+      val = args[i + 1] && !args[i + 1].startsWith('--') ? args[++i] : true
+    }
+    if (!key) continue
+    if (!KNOWN_FLAGS.has(key)) {
+      writeln(dim(`  (ignoring unknown flag --${key}; known: ${[...KNOWN_FLAGS].join(', ')})`))
+      continue
     }
+    flags[key] = val
   }
 
   try {
@@ -1362,9 +1427,12 @@ export async function runCli(argv) {
       const { runTui } = await import('./tui.mjs')
       await runTui({ platform: flags.platform ?? 'claude', window: flags.window ?? '7d' })
     } else if (cmd === 'watch') {
+      // A5: no --platform/--window → watch ALL active platforms × ALL windows. Pass the raw
+      // flags through (undefined = no filter) so runWatch's auto-all mode engages by default;
+      // a provided flag narrows the grid (back-compat).
       await runWatch({
-        platform: flags.platform ?? 'claude',
-        window:   flags.window   ?? '7d',
+        platform: typeof flags.platform === 'string' ? flags.platform : undefined,
+        window:   typeof flags.window === 'string' ? flags.window : undefined,
         refresh:  Number(flags.refresh) || 30,
         submit:   flags.submit === true || flags.submit === 'true',
       })

package/connect.mjs

@@ -0,0 +1,13 @@
+// connect.mjs — pure predicates for the TUI consolidation (the TUI is the whole app).
+// No fs, no I/O, no side effects — unit-testable in isolation. Used by tui.mjs to
+// decide sign-in state and to classify keystrokes while the Connect code field is focused.
+
+/** True iff this device identity is signed in (bound to an operator). */
+export function isSignedIn(id) {
+  return !!(id && id.codename && id.operator_id)
+}
+
+/** True iff `s` is a single character a connect code can contain ([A-Za-z0-9-]). */
+export function isCodeChar(s) {
+  return typeof s === 'string' && /^[A-Za-z0-9-]$/.test(s)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigrank",
-  "version": "0.11.4",
+  "version": "0.12.0",
   "description": "SigRank MCP server — the yield cascade + live leaderboard as MCP tools any agent can call",
   "type": "module",
   "license": "MIT",
@@ -36,6 +36,7 @@
     "sign.mjs",
     "keystore.mjs",
     "submit.mjs",
+    "connect.mjs",
     "README.md",
     "LICENSE"
   ],

package/tokenpull.mjs

@@ -16,6 +16,8 @@
  */
 
 import { readdir, readFile, lstat } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { execSync } from 'node:child_process'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
 import { ADAPTERS } from './adapters.mjs'
@@ -280,3 +282,119 @@ export async function tokenpullAny(platform, opts = {}) {
   if (adapter.setupNote) result.setupNote = adapter.setupNote
   return result
 }
+
+// ── Fresh verifier pull (#9 / C1) ─────────────────────────────────────────────
+// The owner-requested FRESH pull of the three external verifier sources. Unlike the
+// stale snapshot readers (a 3-day-old token-dashboard.db, a static tokscale_report.json),
+// these RUN the source tool on every call so the numbers are live. Token-only: each tool
+// reports usage counts, never transcript content. Every external call is wrapped so a
+// missing binary / parse error / timeout returns null and NEVER throws — a verifier the
+// machine doesn't have simply doesn't appear.
+//
+// Returns { ccusage, tokscale, tokendash } where each value is either null or an object
+// keyed by window: { '7d':{...}, '30d':{...}, '90d':{...}, all:{...} } (windows that can't
+// be derived from a source are omitted; 'all' is present whenever the source has data).
+
+// 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') {
+  try {
+    const raw = execSync(`ccusage ${platform} daily --json`, { timeout: 15000, stdio: ['ignore', 'pipe', 'ignore'] }).toString()
+    const rows = JSON.parse(raw)?.daily ?? JSON.parse(raw)
+    if (!Array.isArray(rows)) return null
+    const now = Date.now()
+    const result = {}
+    for (const [win, days] of Object.entries({ '7d': 7, '30d': 30, '90d': 90 })) {
+      const since = new Date(now - days * DAY_MS)
+      let i = 0, o = 0, cw = 0, cr = 0
+      for (const r of rows) {
+        if (new Date(r.date ?? r.day ?? '1970') >= since) {
+          i  += r.inputTokens         ?? r.input_tokens         ?? 0
+          o  += r.outputTokens        ?? r.output_tokens        ?? 0
+          cw += r.cacheCreationTokens ?? r.cache_create_tokens  ?? 0
+          cr += r.cacheReadTokens     ?? r.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 r of rows) {
+      i += r.inputTokens ?? 0; o += r.outputTokens ?? 0; cw += r.cacheCreationTokens ?? 0; cr += r.cacheReadTokens ?? 0
+    }
+    result['all'] = { input: i, output: o, cacheCreate: cw, cacheRead: cr }
+    return result
+  } catch { return null }
+}
+
+// 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') {
+  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 */ }
+  }
+  // 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)
+    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 }
+}
+
+// tokscale: run `bunx tokscale@latest models --json` and sum the per-(client,model) rows for
+// the requested platform. The JSON shape (verified live) is:
+//   { entries: [ { client, model, input, output, cacheRead, cacheWrite, ... }, ... ], ... }
+// `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') {
+  try {
+    const raw = execSync(`bunx tokscale@latest models --json`, { timeout: 60000, stdio: ['ignore', 'pipe', 'ignore'] }).toString()
+    const data = JSON.parse(raw)
+    const entries = Array.isArray(data?.entries) ? data.entries : (Array.isArray(data) ? data : [])
+    const rows = entries.filter((e) =>
+      e && e.client === platform && e.model !== '<synthetic>' && e.model !== 'unknown' &&
+      ((Number(e.input) || 0) > 0 || (Number(e.output) || 0) > 0),
+    )
+    if (!rows.length) return null
+    const acc = rows.reduce((a, e) => ({
+      input:       a.input       + (Number(e.input)      || 0),
+      output:      a.output      + (Number(e.output)     || 0),
+      cacheCreate: a.cacheCreate + (Number(e.cacheWrite) || 0),
+      cacheRead:   a.cacheRead   + (Number(e.cacheRead)  || 0),
+    }), { input: 0, output: 0, cacheCreate: 0, cacheRead: 0 })
+    return { all: acc }
+  } catch { return null }
+}
+
+/**
+ * Fresh-pull all three external verifier sources for a platform. Each is run live (no stale
+ * snapshot) and returned as { window → {input,output,cacheCreate,cacheRead} } or null when the
+ * source is unavailable / has no data for the platform. Never throws — a failing source is null.
+ *
+ *   - ccusage  : `ccusage <platform> daily --json`              → 7d/30d/90d/all
+ *   - tokendash: refresh + read ~/.claude/token-dashboard.db    → all (claude only)
+ *   - tokscale : `bunx tokscale@latest models --json`           → all
+ */
+export async function freshVerifierPillars(platform = 'claude') {
+  const p = platform || 'claude'
+  // Each call is internally try/catch → null; await Promise.all of resolved values keeps the
+  // helper async (per the contract) without any individual failure rejecting the batch.
+  const [ccusage, tokendash, tokscale] = await Promise.all([
+    Promise.resolve().then(() => _freshCcusage(p)).catch(() => null),
+    Promise.resolve().then(() => _freshTokendash(p)).catch(() => null),
+    Promise.resolve().then(() => _freshTokscale(p)).catch(() => null),
+  ])
+  return { ccusage, tokscale, tokendash }
+}

package/tools.mjs

@@ -113,6 +113,9 @@ async function pullByPlatform(platform, opts = {}) {
 export const DEFAULT_API_BASE = process.env.SIGRANK_API_BASE || 'https://signalaf.com'
 /** Default network timeout in ms (override via opts.fetchTimeout or SIGRANK_FETCH_TIMEOUT). */
 export const DEFAULT_FETCH_TIMEOUT = Number(process.env.SIGRANK_FETCH_TIMEOUT) || 10_000
+/** Max accepted length for a single paste/string arg (chars). Token counts are tiny; anything
+ *  past this is malformed or abusive — reject cleanly before parsing/POSTing (E2 hardening). */
+const MAX_INPUT = 1_000_000
 
 export const TOOLS = [
   {
@@ -246,6 +249,13 @@ export const TOOLS = [
 // tokenpull window key → the board's window_type enum.
 const WINDOW_TYPE = { '7d': '7d', '30d': '30d', '90d': '90d', all: 'all_time' }
 
+// E3: client-side auto-submit cooldown for watch_tokenpull. The server already dedups
+// identical snapshots (exact hash → 422), but a noisy poll loop with submit:true could still
+// churn the network/board with near-identical rows. Cap auto-submit to once per WATCH_SUBMIT_COOLDOWN_MS
+// per window (in-memory, per process). Keyed by window so different windows don't block each other.
+const WATCH_SUBMIT_COOLDOWN_MS = 5 * 60 * 1000
+const _lastWatchSubmitAt = new Map()
+
 export async function callTool(name, args, opts = {}) {
   const apiBase = opts.apiBase || DEFAULT_API_BASE
   const timeoutMs = opts.fetchTimeout ?? DEFAULT_FETCH_TIMEOUT
@@ -390,6 +400,9 @@ export async function callTool(name, args, opts = {}) {
 
   if (name === 'submit_paste') {
     if (!args?.text) throw new Error('submit_paste requires a non-empty `text` argument.')
+    if (typeof args.text === 'string' && args.text.length > MAX_INPUT) {
+      return { status: 'error', reason: 'input_too_large', detail: `text exceeds ${MAX_INPUT} chars (${args.text.length}). Paste only the token-count table, not full output.` }
+    }
     // Local preview first — also validates the paste is parseable before any POST.
     const pillars = parsePillars(args.text)
     const c = withParseWarnings(pillars, cascade(pillars))
@@ -469,6 +482,13 @@ export async function callTool(name, args, opts = {}) {
     // in the same shape as tokenpull output for easy follow-up with tokenpull_submit.
     const WINDOW_KEYS = ['7d', '30d', '90d', 'all']
     const sourceTool = args?.source_tool || null
+    // E2: reject any oversized window paste up front (token tables are tiny).
+    for (const wk of WINDOW_KEYS) {
+      const v = args?.[wk]
+      if (typeof v === 'string' && v.length > MAX_INPUT) {
+        return { status: 'error', reason: 'input_too_large', detail: `window '${wk}' exceeds ${MAX_INPUT} chars (${v.length}). Paste only the token-count table.` }
+      }
+    }
     const windows = []
     for (const wk of WINDOW_KEYS) {
       const text = args?.[wk]
@@ -514,12 +534,22 @@ export async function callTool(name, args, opts = {}) {
     if (args?.submit === true) {
       const id = opts.identity || ensureIdentity()
       if (id.codename && id.operator_id && id.private_key_pkcs8_b64) {
-        auth_submit = await submitSignedWindow(watchWindow, win.pillars, win.messages, id, {
-          apiBase,
-          fetchImpl: doFetch,
-          platform: pulled.platform,
-          now: opts.now,
-        })
+        // E3: client-side cooldown — at most one auto-submit per window per 5 min. Prevents a
+        // fast poll loop from churning the board even before the server's hash-dedup kicks in.
+        const clockNow = typeof opts.now === 'number' ? opts.now : Date.now()
+        const last = _lastWatchSubmitAt.get(watchWindow)
+        if (last != null && clockNow - last < WATCH_SUBMIT_COOLDOWN_MS) {
+          const waitS = Math.ceil((WATCH_SUBMIT_COOLDOWN_MS - (clockNow - last)) / 1000)
+          auth_submit = { status: 'cooldown', detail: `auto-submit for '${watchWindow}' on cooldown — next in ~${waitS}s (max once / 5 min).`, retry_after_s: waitS }
+        } else {
+          _lastWatchSubmitAt.set(watchWindow, clockNow)
+          auth_submit = await submitSignedWindow(watchWindow, win.pillars, win.messages, id, {
+            apiBase,
+            fetchImpl: doFetch,
+            platform: pulled.platform,
+            now: opts.now,
+          })
+        }
       } else {
         auth_submit = { status: 'not_enrolled', detail: 'Run `npx sigrank-mcp enroll` to auto-submit verified runs.' }
       }

package/tui.mjs

@@ -13,6 +13,7 @@
  */
 
 import { callTool, DEFAULT_API_BASE } from './tools.mjs'
+import { freshVerifierPillars } from './tokenpull.mjs'
 import { isSignedIn, isCodeChar } from './connect.mjs'
 import { loadIdentity, clearIdentity } from './keystore.mjs'
 import { execSync } from 'child_process'
@@ -301,10 +302,7 @@ async function loadDashboardData() {
   // then fill the other 13 as they resolve. The caller passes an onFirst callback
   // that fires when claude is ready so the user sees their cascade within ~1 read,
   // not after a 14-platform barrier.
-  const [claudeResult] = await Promise.all([
-    tokenpullAny('claude').catch(() => null),
-    Promise.resolve(tokenDashPillars()),
-  ])
+  const claudeResult = await tokenpullAny('claude').catch(() => null)
 
   const active = []
   if (claudeResult) {
@@ -312,13 +310,13 @@ async function loadDashboardData() {
     if (all && (all.pillars.input ?? 0) + (all.pillars.output ?? 0) > 0) active.push(claudeResult)
   }
 
-  const verifierMap = {}
-  for (const platform of ALL_PLATFORMS) {
-    verifierMap[platform] = { cc: ccusagePillars(platform), ts: tokscalePillars(platform) }
-  }
-
+  // FIX A1 (2026-06-27): removed the 14× SYNCHRONOUS ccusage `verifierMap` build (measured 39,816 ms)
+  // that blocked the very first Dashboard paint — and the render never read `verifierMap` or `tdPillars`.
+  // (Also dropped the discarded second `tokenDashPillars()` call above.) Verifier comparison
+  // (ccusage / tokscale / token-dashboard) now runs FRESH + on-demand in the Compare tab, scoped to
+  // active platforms — see loadCompareData. Dashboard paints from tokenpull in ~2s.
   const boardData = await boardPromise
-  return { active, verifierMap, tdPillars: tokenDashPillars(), boardData, _loading: true, _remaining: ALL_PLATFORMS.slice(1) }
+  return { active, verifierMap: {}, tdPillars: null, boardData, _loading: true, _remaining: ALL_PLATFORMS.slice(1) }
 }
 
 /** FIX 0: fill the remaining platforms after the primary render. Mutates dashData.active. */
@@ -342,20 +340,42 @@ async function fillDashboardRest(dashData) {
   return true
 }
 
+// #9 / C1 (2026-06-27): Compare pulls the three external verifier sources FRESH + on-demand
+// (ccusage + tokscale models + a token-dashboard rescan), via tokenpull.freshVerifierPillars —
+// NOT the old stale snapshot readers (static tokscale_report.json / 3-day-old db). This runs ONLY
+// when the Compare tab opens (it's a 5–60s scan), never on the Dashboard load path. Scoped to the
+// current platform. tokenpull (the canonical board/cascade source) stays the fast/fresh tpData.
 async function loadCompareData(platform = 'claude') {
   const tpData = await callTool('tokenpull', { platform }).catch(() => null)
-  const cc = ccusagePillars(platform)
-  const ts = tokscalePillars(platform)
-  const td = platform === 'claude' ? tokenDashPillars() : null
-  return { tpData, cc, ts, td, platform }
+  // Fresh pull — { ccusage, tokscale, tokendash }, each null or window-keyed pillars.
+  const fresh = await freshVerifierPillars(platform).catch(() => ({ ccusage: null, tokscale: null, tokendash: null }))
+  return { tpData, cc: fresh.ccusage, ts: fresh.tokscale, td: fresh.tokendash, platform }
 }
 
+// #8 (2026-06-27): the Board tab shows ALL SUBMISSIONS ranked (raw submission rows), not operator
+// aggregates. Try the NEW GET /api/v1/submissions first; if it's not deployed yet (non-200 / 404),
+// FALL BACK to the existing /api/v1/leaderboard so nothing breaks pre-deploy. The return is tagged
+// with `_source` ('submissions' | 'leaderboard') so renderBoard picks the right column layout.
 async function loadBoardData(window = '30d') {
-  const res = await fetch(`${DEFAULT_API_BASE}/api/v1/leaderboard?window=${window}&metric=yield_`, {
-    headers: { accept: 'application/json' }
-  })
-  if (!res.ok) return null
-  return res.json()
+  // Primary: submissions endpoint (ranked submission rows).
+  try {
+    const res = await fetch(`${DEFAULT_API_BASE}/api/v1/submissions?window=${window}&metric=yield_`, {
+      headers: { accept: 'application/json' },
+    })
+    if (res.ok) {
+      const data = await res.json()
+      return { ...data, _source: 'submissions' }
+    }
+  } catch { /* fall through to leaderboard */ }
+  // Fallback: existing leaderboard endpoint + current render (pre-deploy safety).
+  try {
+    const res = await fetch(`${DEFAULT_API_BASE}/api/v1/leaderboard?window=${window}&metric=yield_`, {
+      headers: { accept: 'application/json' },
+    })
+    if (!res.ok) return null
+    const data = await res.json()
+    return { ...data, _source: 'leaderboard' }
+  } catch { return null }
 }
 
 // ── TAB BAR ──────────────────────────────────────────────────────────────────
@@ -455,13 +475,26 @@ function yieldSpark(d) {
 
 // ── TAB 1: DASHBOARD ─────────────────────────────────────────────────────────
 function renderDashboard(data, status = '') {
-  const { active, verifierMap, tdPillars, boardData } = data
   const w = W()
   const budget = H() - 4  // 2 tab bar + 2 footer
   const WINS = ['7d', '30d', '90d', 'all']
   let used = 0
   const emit = (s = '') => { if (used < budget) { writeln(s); used++ } }
 
+  // A2 (2026-06-27): tolerate null/empty dashData so the FIRST paint can happen BEFORE the
+  // initial load resolves (loadAll renders an empty frame + "reading your cascade…" immediately,
+  // then re-renders with real data). Guard the destructure: no data → header + status + return.
+  if (!data || !Array.isArray(data.active)) {
+    emit()
+    emit(`  ${bold('Your Cascade')}  ${dim('all platforms · all windows')}`)
+    emit()
+    emit(`  ${dim('  reading token logs… (press [R] to refresh)')}`)
+    if (status && used < budget) emit(`  ${dim(status)}`)
+    return
+  }
+
+  const { active } = data
+
   // Responsive: the full 12-col table is ~124 wide. On terminals narrower than
   // that, drop the two derived columns (Vel, 10x) and tighten the inter-column
   // gap from 2 spaces to 1, so the core pillars + Υ/SNR/Lev/Class still fit.
@@ -521,6 +554,15 @@ 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)
+
   let firstWin = {}
   let cascadeRowCount = 0
   for (const d of active) {
@@ -538,6 +580,10 @@ function renderDashboard(data, status = '') {
     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`)}`)
+
   // combined
   if (active.length > 1 && used < budget - sectionsBelow) {
     const lbl = active.map(d => d.platform).join('+')
@@ -663,11 +709,14 @@ const TREND_METRICS = [
   { label: '10xDEV',   pick: (c) => c.dev10x,    fmt: (v) => v.toFixed(2) },
   { label: 'Eff',      pick: (c) => c.yield != null ? c.yield / AA_EFF_BASELINE : null, fmt: (v) => v.toFixed(1) + '×' },
   { label: '§IGNA',    pick: () => null, fmt: () => '—', stub: 'composite calibrating (needs user volume)' },
-  { label: 'Op Ratio', pick: (c, p) => (p.input ?? 0) > 0 ? { cacheRead: p.cacheRead ?? 0, input: p.input ?? 0, output: p.output ?? 0 } : null, fmt: (v) => `${fmtTok(v.cacheRead)}:${fmtTok(v.input)}:${fmtTok(v.output)}` },
+  // FIX A4 (2026-06-27): operating ratio is INPUT-NORMALIZED `cache : 1 : output` (matches web canon —
+  // ThreeDegreesChart / OperatingRatioBar, e.g. "3.5 : 1 : 0.50"), not raw token counts (which also
+  // overflowed the Trends columns).
+  { label: 'Op Ratio', pick: (c, p) => (p.input ?? 0) > 0 ? { cacheRead: p.cacheRead ?? 0, input: p.input ?? 0, output: p.output ?? 0 } : null, fmt: (v) => { const i = v.input || 1; return `${(v.cacheRead / i).toFixed(1)} : 1 : ${(v.output / i).toFixed(2)}` } },
   { label: '$/1M',     pick: () => null, fmt: () => '—', stub: 'cost data wires post-ingest' },
 ]
 function renderTrends(data, subIdx = 0) {
-  const { active } = data
+  const { active } = data ?? {}
   const budget = H() - 4
   let used = 0
   const emit = (s = '') => { if (used < budget) { writeln(s); used++ } }
@@ -683,16 +732,23 @@ function renderTrends(data, subIdx = 0) {
 
   if (sub === 'You' || sub === 'Platform') {
     const rows = sub === 'You'
-      ? (active.length ? [{ platform: 'you', windows: active[0]?.windows }] : [])  // primary cascade
-      : active
+      ? ((active?.length) ? [{ platform: 'you', windows: active[0]?.windows }] : [])  // primary cascade
+      : (active ?? [])
     if (!rows.length) { emit(`  ${dim('  reading your cascade… (press [R] to refresh)')}`); }
-    for (const d of rows) {
-      if (used >= budget - 2) break
+    // A3 (2026-06-27): count metric/rank rows dropped by the height budget so we can show a
+    // "+N more — resize / scroll" note instead of silently truncating. Each rendered block wants
+    // TREND_METRICS.length metric rows + 1 rank row. (Fit logic below unchanged — observe only.)
+    let trendsDropped = 0
+    for (let ri = 0; ri < rows.length; ri++) {
+      const d = rows[ri]
+      if (used >= budget - 2) { trendsDropped += (rows.length - ri) * (TREND_METRICS.length + 1); break }
       emit(`  ${bold(sub === 'You' ? 'Your trajectory' : cyan(d.platform))}`)
       // FIX G1: window column headers (mirror renderCompare) — one header row, then
       // values in fixed-width columns below. No per-value `w:` prefix.
       emit(`    ${trendHeader()}`)
-      for (const m of TREND_METRICS) {
+      let mi = 0
+      for (; mi < TREND_METRICS.length; mi++) {
+        const m = TREND_METRICS[mi]
         if (used >= budget - 2) break
         if (m.stub) {
           emit(`    ${padEnd(dim(m.label), 10)}  ${dim('▁▁▁▁  calculating… (' + m.stub + ')')}`)
@@ -700,10 +756,14 @@ function renderTrends(data, subIdx = 0) {
           emit(`    ${padEnd(cyan(m.label), 10)}  ${metricSpark(d, m.pick, m.fmt)}`)
         }
       }
+      trendsDropped += (TREND_METRICS.length - mi)   // metrics this block couldn't fit
       // rank trend — wired later; honest placeholder for now
       if (used < budget - 1) emit(`    ${padEnd(dim('Rank'), 10)}  ${dim('▁▁▁▁  calculating… (rank history wires post-ingest)')}`)
+      else trendsDropped += 1
       emit()
     }
+    // A3: surface the dropped count instead of hiding it.
+    if (trendsDropped > 0) emit(`  ${dim(`  +${trendsDropped} more — resize / scroll`)}`)
   } else { // Field
     emit(`  ${dim('  Field-wide trends — calculating…')}`)
     emit(`  ${dim('  (needs per-window board history; materializes once live ingest lands)')}`)
@@ -807,12 +867,95 @@ function renderCompare(data) {
   }
 }
 
+// ── TAB 3: BOARD — submissions view (#8) ──────────────────────────────────────
+// Renders ALL submissions ranked (raw submission rows from GET /api/v1/submissions), not operator
+// aggregates. Columns: rank · codename · platform · window · Υ Yield · op_ratio · class · tokens.
+// Field names are read defensively (the endpoint is new) so a slightly different server shape still
+// renders. [Y] "just me" filtering + the you-highlight carry over from the leaderboard view.
+function renderSubmissions(boardData, window = '30d', filterCodename = null, highlightCodename = null) {
+  const rows = boardData?.submissions ?? boardData?.entries ?? boardData?.rows ??
+    (Array.isArray(boardData) ? boardData : [])
+  const w = W()
+  const budget = H() - 4
+  let used = 0
+  const emit = (s = '') => { if (used < budget) { writeln(s); used++ } }
+
+  // Defensive field readers (server shape is new / not yet pinned).
+  const gName = (e) => e.codename ?? e.operator_codename ?? '—'
+  const gPlat = (e) => e.platform ?? e.platform_primary ?? '—'
+  const gWin  = (e) => e.window ?? e.window_type ?? '—'
+  const gYield = (e) => e.yield_ ?? e.yield ?? e.y ?? null
+  const gOpRatio = (e) => e.op_ratio ?? e.operating_ratio ?? e.opRatio ?? null
+  const gClass = (e) => e.class_tier ?? e.class ?? e.class_ ?? '—'
+  const gTokens = (e) => e.tokens ?? e.total_tokens ?? e.token_total ?? null
+
+  const modeLabel = filterCodename ? `${dim(' · just you')}` : highlightCodename ? `${dim(' · you highlighted')}` : ''
+  emit()
+  emit(`  ${bold('Submissions')}  ${dim(`window: ${window}  ·  all submissions ranked by Υ Yield  ·  signalaf.com`)}${modeLabel}`)
+  emit()
+
+  if (!Array.isArray(rows) || rows.length === 0) {
+    emit(`  ${dim('  no submissions for this window')}`)
+    return
+  }
+
+  let sorted = [...rows].sort((a, b) => (gYield(b) ?? 0) - (gYield(a) ?? 0))
+  if (filterCodename) {
+    sorted = sorted.filter(e => (gName(e) ?? '').toLowerCase() === filterCodename.toLowerCase())
+    if (sorted.length === 0) {
+      emit(`  ${dim(`  you have no submissions in the ${window} window yet`)}`)
+      emit(`  ${dim('  press [S] from a read tab to submit your cascade')}`)
+      return
+    }
+  }
+
+  // op_ratio may arrive as a preformatted string ("3.5 : 1 : 0.50") or a number — render either.
+  const fmtOp = (v) => v == null ? '—' : (typeof v === 'string' ? v : (typeof v === 'number' ? v.toFixed(2) : String(v)))
+
+  const SH = [
+    padStart(hdr('#'), 4), padEnd(hdr('Codename'), 20), padEnd(hdr('Platform'), 10),
+    padEnd(hdr('Win'), 6), padStart(hdr('Υ Yield'), 9), padEnd(hdr('Op Ratio'), 18),
+    padEnd(hdr('Class'), 12), padStart(hdr('Tokens'), 9),
+  ]
+  emit(`    ${SH.join('  ')}`)
+  emit(`  ${dim('·'.repeat(Math.min(w - 4, 100)))}`)
+
+  let shown = 0
+  for (let idx = 0; idx < sorted.length; idx++) {
+    if (used >= budget) break
+    const e = sorted[idx]
+    const isYou = highlightCodename && (gName(e) ?? '').toLowerCase() === highlightCodename.toLowerCase()
+    const rk = idx === 0 ? gold(`#${idx+1}`) : idx < 3 ? cyan(`#${idx+1}`) : `#${idx+1}`
+    const nmRaw = trunc(gName(e), 20)
+    const nm = isYou
+      ? `${c.bgCyan}${c.boldCyan}${padEnd(` ${trunc(gName(e), 18)} `, 20)}${c.reset}`
+      : padEnd(nmRaw, 20)
+    const yv = gYield(e)
+    const yld = padStart(yv != null ? (yv > 10000 ? gold(fmtY(yv)) : fmtY(yv)) : '—', 9)
+    const cls = padEnd(colorCls(gClass(e)), 12)
+    const tk = gTokens(e)
+    const youMark = isYou ? ` ${c.bgCyan}${c.boldCyan}YOU${c.reset}` : ''
+    emit(`    ${padStart(rk, 4)}  ${nm}  ${padEnd(cyan(trunc(gPlat(e), 10)), 10)}  ${padEnd(dim(trunc(gWin(e), 6)), 6)}  ${yld}  ${padEnd(dim(fmtOp(gOpRatio(e))), 18)}  ${cls}  ${padStart(tk != null ? fmtTok(tk) : '—', 9)}${youMark}`)
+    shown++
+  }
+  // A3-style: if the height budget dropped rows, say so instead of silently truncating.
+  const dropped = sorted.length - shown
+  if (dropped > 0 && used < budget) emit(`  ${dim(`  +${dropped} more — resize / scroll`)}`)
+}
+
 // ── TAB 3: BOARD ─────────────────────────────────────────────────────────────
 // FIX I2: hybrid board model. `filterCodename` (non-null = "just me" mode) shows
 // ONLY the signed-in operator's rows. `highlightCodename` (non-null = global mode)
 // highlights the signed-in operator's row in the global board. Both come from the
 // signed-in identity's codename; the [Y] key toggles between the two modes.
 function renderBoard(boardData, window = '30d', filterCodename = null, highlightCodename = null) {
+  // #8 (2026-06-27): when the data came from the NEW /api/v1/submissions endpoint, render ALL
+  // submissions ranked (raw rows). Otherwise fall through to the existing leaderboard render
+  // (pre-deploy fallback). loadBoardData tags the payload with `_source`.
+  if (boardData?._source === 'submissions') {
+    renderSubmissions(boardData, window, filterCodename, highlightCodename)
+    return
+  }
   const entries = boardData?.entries ?? boardData?.operators ?? boardData ?? []
   const w = W()
   const budget = H() - 4
@@ -897,13 +1040,20 @@ function renderBoard(boardData, window = '30d', filterCodename = null, highlight
 // Explains what the live watcher does and why it's the point of the agent: it
 // re-reads your local logs on an interval and feeds your verified cascade to the
 // leaderboard. Launched (in its own window) with [Enter]; interval is tunable.
+// A5 (2026-06-27): Watch defaults to ALL active platforms × ALL windows (mirror the cli.mjs watch
+// change). `platform`/`win` are OPTIONAL focus filters — null/'all' means "everything". [P]/[W]
+// cycle the focus (including back to "all"); the spawned watcher + this copy show everything by default.
 function renderWatchInfo(platform, win, refresh) {
+  const platLabel = (!platform || platform === 'all') ? 'all active platforms' : platform
+  const winLabel  = (!win || win === 'all-windows') ? 'all windows' : win
+  const allDefault = platLabel === 'all active platforms' && winLabel === 'all windows'
   writeln()
   writeln(`  ${bold('Live Watch')}  ${dim('the agent that keeps your rank current')}`)
   writeln()
   writeln(`  ${dim('What it does')}`)
-  writeln(`    Re-reads your local ${cyan(platform)} token logs every ${gold(refresh + 's')} and recomputes`)
-  writeln(`    your cascade (Υ Yield · SNR · Leverage · class) live, on this machine.`)
+  writeln(`    Re-reads your local token logs for ${cyan(platLabel)} across ${cyan(winLabel)} every`)
+  writeln(`    ${gold(refresh + 's')} and recomputes each cascade (Υ Yield · SNR · Leverage · class) live, on`)
+  writeln(`    this machine. ${dim('By default it watches everything — every platform you actually use.')}`)
   writeln()
   writeln(`  ${dim('Why it matters')}`)
   writeln(`    Watch is how the board stays ${bold('current')}: each refresh submits your latest`)
@@ -911,9 +1061,10 @@ function renderWatchInfo(platform, win, refresh) {
   writeln(`    no manual re-submit. Tokens never leave your machine; only the metrics post.`)
   writeln()
   writeln(`  ${dim('Settings')}`)
-  writeln(`    ${dim('Platform')}  ${cyan(platform)}     ${dim('Window')}  ${cyan(win)}     ${dim('Refresh')}  ${gold(refresh + 's')}`)
+  writeln(`    ${dim('Platform')}  ${cyan(platLabel)}     ${dim('Window')}  ${cyan(winLabel)}     ${dim('Refresh')}  ${gold(refresh + 's')}`)
+  writeln(`    ${dim(allDefault ? 'watching everything (default)' : 'focused — press [P]/[W] to widen back to all')}`)
   writeln()
-  writeln(`    ${dim('[Enter]')} launch watcher (new window)   ${dim('[+]/[-]')} refresh ±5s   ${dim('[P]')} platform   ${dim('[W]')} window`)
+  writeln(`    ${dim('[Enter]')} launch watcher (new window)   ${dim('[+]/[-]')} refresh ±5s   ${dim('[P]')} platform focus   ${dim('[W]')} window focus`)
   writeln()
 }
 
@@ -946,74 +1097,66 @@ function renderConnect(id, codeBuf = '', msg = '') {
   if (msg) { writeln(); writeln(`  ${msg}`) }
 }
 
-// ── TAB 4: WATCH ─────────────────────────────────────────────────────────────
-async function renderWatch(platform = 'claude', win = '7d') {
+// ── TAB 4: WATCH (live grid) ──────────────────────────────────────────────────
+// A5 (2026-06-27): renders ALL active platforms × ALL windows by default (mirror the cli.mjs
+// watch grid), instead of a single platform/window. `platform`/`win` are OPTIONAL focus filters —
+// null/'all'/'all-windows' means "everything". Each row is a (platform, window) cascade cell:
+// Υ Yield + SNR/Lev/Vel/class. Iterates active platforms (input+output > 0 in any window).
+async function renderWatch(platform = 'all', win = 'all-windows') {
   const { tokenpullAny } = await import('./tokenpull.mjs')
-  const d = await tokenpullAny(platform).catch(() => null)
-  if (!d) { writeln(`  ${dim(`no data for ${platform}`)}`); return }
-
-  const wdata = d.windows?.find(x => x.window === win)
-  if (!wdata) { writeln(`  ${dim(`no data for ${win} window`)}`); return }
-
-  const p   = wdata.pillars
-  const cas = cascadeFrom(p)
-  const w   = W()
-
-  writeln()
-  writeln(`  ${bold('Live Watch')}  ${dim(`${platform} · ${win} window · ${d.files} files · ${wdata.messages?.toLocaleString()} msgs`)}`)
-  writeln()
-
-  if (!cas) { writeln(`  ${dim('  insufficient data to compute cascade')}`); return }
-
-  const clsFn = CLS[cas.class] ?? ((s) => s)
-
-  // big numbers
-  const metrics = [
-    { label: 'Υ Yield',   val: fmtY(cas.yield),           color: cas.yield > 1000 ? c.boldGold : c.boldCyan },
-    { label: 'Class',     val: cas.class,                  color: CLS[cas.class] ? c.boldGold : c.reset },
-    { label: 'SNR',       val: fmtSNR(cas.snr),           color: c.green },
-    { label: 'Leverage',  val: fmtLev(cas.leverage)+'×',  color: c.cyan },
-    { label: 'Velocity',  val: cas.velocity?.toFixed(2),   color: c.white },
-    { label: '10xDEV',    val: cas.dev10x?.toFixed(2),     color: c.magenta },
+  const ALL_PLATFORMS = [
+    'claude','codex','amp','gemini','kimi','qwen','goose','kilo',
+    'hermes','droid','codebuff','copilot','openclaw','pi',
   ]
+  const platFilter = (platform && platform !== 'all') ? platform : null
+  const winFilter  = (win && win !== 'all-windows') ? win : null
+  const WINS = winFilter ? [winFilter] : ['7d', '30d', '90d', 'all']
+  const w = W()
+  const budget = H() - 4
+  let used = 0
+  const emit = (s = '') => { if (used < budget) { writeln(s); used++ } }
 
-  for (const m of metrics) {
-    writeln(`    ${padEnd(dim(m.label), 12)}  ${paint(m.color, m.val ?? '—')}`)
+  // Detect active platforms (any window with input+output > 0), respecting an optional [P] focus.
+  const candidates = platFilter ? [platFilter] : ALL_PLATFORMS
+  const settled = await Promise.allSettled(candidates.map(p => tokenpullAny(p)))
+  const active = []
+  for (const r of settled) {
+    if (r.status !== 'fulfilled' || !r.value) continue
+    const d = r.value
+    if ((d.windows || []).some(ww => (ww.pillars.input + ww.pillars.output) > 0)) active.push(d)
   }
-  writeln()
+  // stable display order
+  active.sort((a, b) => ALL_PLATFORMS.indexOf(a.platform) - ALL_PLATFORMS.indexOf(b.platform))
 
-  // token pillars
-  writeln(`  ${hr()}`)
-  writeln()
-  writeln(`  ${bold('Token Pillars')}  ${dim(`${win} window`)}`)
-  writeln()
+  const scopeLabel = (platFilter || 'all active platforms') + ' · ' + (winFilter ? `${winFilter} window` : 'all windows')
+  emit()
+  emit(`  ${bold('Live Watch')}  ${dim(scopeLabel)}`)
+  emit(`  ${dim('·'.repeat(Math.min(w - 4, 80)))}`)
 
-  const pillarsData = [
-    { label: 'Input',       val: p.input,       color: c.cyan,    est: d.estimated },
-    { label: 'Output',      val: p.output,      color: c.green,   est: false },
-    { label: 'Cache Write', val: p.cacheCreate, color: c.blue,    est: d.estimated },
-    { label: 'Cache Read',  val: p.cacheRead,   color: c.boldGold,est: false },
-  ]
-  // Log scale: token pillars span 2–3 orders of magnitude (input ~8M, cacheRead ~1.9B).
-  // Linear scale crushes input/output bars to near-invisible. Log10 gives equal visual
-  // weight per order-of-magnitude step.
-  const maxLog = Math.log10(Math.max(...pillarsData.map(x => x.val ?? 0), 10))
-  for (const item of pillarsData) {
-    const v   = item.val ?? 0
-    const { bar } = logBar(v, maxLog, 40, item.color)
-    const est = item.est ? dim('~') : ''
-    writeln(`    ${padEnd(dim(item.label), 12)}  ${padEnd(bar, 40)}  ${est}${fmtTok(v)}`)
+  if (active.length === 0) {
+    emit()
+    emit(`  ${dim('  no active platforms detected — run some sessions, this picks them up automatically')}`)
+    return
   }
-  writeln(`  ${dim('log₁₀ scale — each step = 10× · absolute values right')}`)
-  writeln()
 
-  // trend across windows
-  writeln(`  ${hr()}`)
-  writeln()
-  writeln(`  ${bold('Υ Trend')}  ${dim('7d → 30d → 90d → all')}`)
-  writeln()
-  writeln(`    ${yieldSpark(d)}`)
-  writeln()
+  for (const d of active) {
+    if (used >= budget - 1) break
+    const byWin = {}
+    for (const ww of (d.windows || [])) byWin[ww.window] = ww
+    emit()
+    emit(`  ${cyan(d.platform)}${d.estimated ? dim(' (est)') : ''}`)
+    for (const wk of WINS) {
+      if (used >= budget - 1) break
+      const ww  = byWin[wk]
+      const cas = ww ? cascadeFrom(ww.pillars) : null
+      const winLabel = wk === 'all' ? 'all-time' : wk
+      if (!cas) { emit(`    ${padEnd(dim(winLabel), 9)}  ${dim('no data')}`); continue }
+      const clsFn = CLS[cas.class] ?? ((s) => s)
+      const yDisplay = cas.yield > 1000 ? gold(fmtY(cas.yield)) : cyan(fmtY(cas.yield))
+      const metrics = `${dim('SNR')} ${fmtSNR(cas.snr)}  ${dim('Lev')} ${cas.leverage != null ? fmtLev(cas.leverage) + '×' : '—'}  ${dim('Vel')} ${cas.velocity != null ? cas.velocity.toFixed(2) : '—'}  ${clsFn(cas.class)}`
+      emit(`    ${padEnd(dim(winLabel), 9)}  ${bold('Υ')} ${yDisplay}  ${metrics}`)
+    }
+  }
 }
 
 // ── SUBMIT PREVIEW (FIX I1 / FIX E) — see→confirm→send ───────────────────────
@@ -1070,6 +1213,7 @@ async function renderOnce(tabIdx = 0) {
   if (tabIdx === 0) renderDashboard(data, 'debug')
   else if (tabIdx === 1) renderCompare(data)
   else if (tabIdx === 2) renderBoard(data, '30d')
+  else if (tabIdx === 4) await renderWatch('all', 'all-windows')
   else if (tabIdx === 5) renderConnect(loadIdentity(), '', '')
   const lines = _screenBuf || []
   _screenBuf = null; _footerBuf = null
@@ -1201,8 +1345,11 @@ export async function runTui({ platform: initPlatform = 'claude', window: win =
   let compareData  = null
   let boardData    = null
   let boardWindow  = '30d'
-  let watchPlatform = platform
-  let watchWindow  = win
+  // A5 (2026-06-27): Watch defaults to "all" focus — all active platforms × all windows. [P]/[W]
+  // optionally narrow the focus and cycle back to 'all'. ('all-windows' is the window sentinel so
+  // it never collides with the real 'all' window bucket in the cli watcher's optional --window.)
+  let watchPlatform = 'all'
+  let watchWindow  = 'all-windows'
   let watchRefresh = 30        // [5] Watch poll interval (seconds) — [+]/[-] adjust
   let trendSub     = 0         // [2] Trends sub-view index (You/Platform/Field) — [T] cycles
   let loading      = true
@@ -1251,7 +1398,11 @@ export async function runTui({ platform: initPlatform = 'claude', window: win =
       setFooter(readFooter(`${hint}   ${dim('[T]')} view${submitHint}`))
     } else if (activeTab === 2) {                // Compare
       if (!compareData) {
-        writeln(`\n  ${dim(`loading compare (${platform})…`)}`)
+        // #9 (2026-06-27): Compare runs a FRESH on-demand pull of the external verifier sources
+        // (ccusage + tokscale + token-dashboard rescan) — it can take several seconds. Show a clear
+        // spinner line while it runs, instead of a bare "loading…".
+        writeln(`\n  ${bold('Source Comparison')}  ${dim(`platform: ${platform}`)}`)
+        writeln(`\n  ${gold('◇')} ${dim(`pulling fresh sources… (ccusage · tokscale · token-dash — this can take several seconds)`)}`)
       } else {
         renderCompare(compareData)
       }
@@ -1282,22 +1433,33 @@ export async function runTui({ platform: initPlatform = 'claude', window: win =
 
   // ── Initial data load
   const loadAll = async () => {
-    status = 'loading…'
+    // A2 (2026-06-27): paint the frame + a clear "reading your cascade…" status IMMEDIATELY,
+    // BEFORE the await — so the very first thing on screen is the table header + a live status,
+    // not a blank "loading dashboard…". renderDashboard tolerates this empty dashData (guarded).
+    status = 'reading your cascade…'
+    dashData = { active: [], _loading: true }
+    await redraw()
     // FIX 0: progressive Dashboard load — claude first (fast), render it, THEN fill
     // the other 13 platforms in the background + redraw. The user sees their cascade
     // within ~1 read instead of a 7s blank "loading dashboard…".
     dashData = await loadDashboardData().catch(e => { status = `dashboard error: ${e.message}`; return null })
     status = `last refreshed ${new Date().toLocaleTimeString('en-US', { hour12: false })}`
     await redraw()
-    // Kick off the rest + compare/board in parallel
-    ;[compareData, boardData] = await Promise.all([
-      loadCompareData(platform).catch(() => null),
-      loadBoardData(boardWindow).catch(() => null),
-    ])
+    // Keep a "filling other platforms…" status visible while fillDashboardRest runs.
+    // #9 (2026-06-27): Compare is NO LONGER eagerly loaded here — loadCompareData now runs the
+    // FRESH verifier pull (ccusage + tokscale + token-dash rescan, 5–60s), which would re-introduce
+    // a slow Dashboard load path. Compare loads lazily ON-DEMAND when the Compare tab is opened.
+    // Board still preloads (fast, cached) in parallel with the platform fill.
     if (dashData?._remaining) {
-      await fillDashboardRest(dashData)
+      status = 'claude ready · filling other platforms…'
       await redraw()
     }
+    ;[, boardData] = await Promise.all([
+      dashData?._remaining ? fillDashboardRest(dashData) : Promise.resolve(false),
+      loadBoardData(boardWindow).catch(() => null),
+    ])
+    status = `last refreshed ${new Date().toLocaleTimeString('en-US', { hour12: false })}`
+    await redraw()
   }
 
   // Always restore terminal on unexpected exit
@@ -1481,6 +1643,17 @@ 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
 
+      // #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.
+      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()
+        return
+      }
+
       // Trends tab: [T] cycles the sub-view (You · Platform · Field)
       if (activeTab === 1 && k === 't') { trendSub = (trendSub + 1) % 3; await redraw(); return }
 
@@ -1492,36 +1665,48 @@ export async function runTui({ platform: initPlatform = 'claude', window: win =
       // Compare reloads compareData for the new platform; Watch just re-renders.
       const CYCLE_PLATFORMS = ['claude','codex','amp','gemini','kimi','qwen','goose','kilo','hermes','droid','codebuff','copilot','openclaw','pi']
       if (k === 'p' && (activeTab === 2 || activeTab === 4)) {
-        const cur = activeTab === 2 ? platform : watchPlatform
-        const idx = CYCLE_PLATFORMS.indexOf(cur)
-        const next = CYCLE_PLATFORMS[(idx + 1) % CYCLE_PLATFORMS.length]
         if (activeTab === 2) {
-          platform = next
+          // Compare: real platforms only (no 'all' — Compare is per-platform by design).
+          const idx = CYCLE_PLATFORMS.indexOf(platform)
+          platform = CYCLE_PLATFORMS[(idx + 1) % CYCLE_PLATFORMS.length]
+          // #9: clearing compareData makes redraw show the "pulling fresh sources…" spinner
+          // for the new platform while the fresh on-demand verifier pull runs.
+          compareData = null
           status = `loading ${platform}…`
           await redraw()
           compareData = await loadCompareData(platform).catch(() => null)
           status = `last refreshed ${new Date().toLocaleTimeString('en-US', { hour12: false })}`
         } else {
-          watchPlatform = next
+          // A5: Watch [P] cycles 'all' → claude → codex → … → 'all' (optional focus; default 'all').
+          const WATCH_PLAT_CYCLE = ['all', ...CYCLE_PLATFORMS]
+          const idx = WATCH_PLAT_CYCLE.indexOf(watchPlatform)
+          watchPlatform = WATCH_PLAT_CYCLE[(idx + 1) % WATCH_PLAT_CYCLE.length]
         }
         await redraw(); return
       }
 
-      // FIX J: [W] cycles window on Watch tab (was a dead hinted key). Board tab's
-      // [W] (activeTab === 3) is handled below — it reloads boardData.
+      // FIX J / A5: [W] cycles window FOCUS on the Watch tab. 'all-windows' (default) → 7d → 30d →
+      // 90d → all → back to 'all-windows'. Board tab's [W] (activeTab === 3) is handled below.
       if (k === 'w' && activeTab === 4) {
-        const windows = ['7d', '30d', '90d', 'all']
-        const idx = windows.indexOf(watchWindow)
-        watchWindow = windows[(idx + 1) % windows.length]
+        const WATCH_WIN_CYCLE = ['all-windows', '7d', '30d', '90d', 'all']
+        const idx = WATCH_WIN_CYCLE.indexOf(watchWindow)
+        watchWindow = WATCH_WIN_CYCLE[(idx + 1) % WATCH_WIN_CYCLE.length]
         await redraw(); return
       }
 
       if (activeTab === 4 && (key === '\r' || key === '\n')) {
-        // Launch the live watcher in its own window, passing the chosen refresh interval.
+        // A5 (2026-06-27): launch the live watcher in its own window. By default (focus = 'all')
+        // pass NO --platform/--window so the cli watcher auto-loads ALL active platforms × ALL
+        // windows. Only add a filter flag when the user has set an explicit [P]/[W] focus.
         try {
-          const watchCmd = `sigrank watch --platform ${watchPlatform} --window ${watchWindow} --refresh ${watchRefresh}`
+          let watchCmd = 'sigrank watch'
+          if (watchPlatform && watchPlatform !== 'all') watchCmd += ` --platform ${watchPlatform}`
+          if (watchWindow && watchWindow !== 'all-windows') watchCmd += ` --window ${watchWindow}`
+          watchCmd += ` --refresh ${watchRefresh}`
           execSync(`osascript -e 'tell application "Terminal" to do script "${watchCmd}"'`, { stdio: 'ignore' })
-          status = `watcher launched (${watchRefresh}s) in a new window`
+          const scope = (!watchPlatform || watchPlatform === 'all') && (!watchWindow || watchWindow === 'all-windows')
+            ? 'all platforms × all windows' : 'focused'
+          status = `watcher launched (${scope}, ${watchRefresh}s) in a new window`
         } catch { status = 'could not open Terminal.app — run: sigrank watch' }
         await redraw()
         return
@@ -1529,6 +1714,16 @@ export async function runTui({ platform: initPlatform = 'claude', window: win =
 
       if (k === 'r') {
         status = 'refreshing…'
+        // #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()
+          return
+        }
         await redraw()
         await loadAll()
         return