sigrank 0.11.5 → 0.12.1

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

@@ -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
@@ -395,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
@@ -684,37 +695,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 +747,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 {
@@ -784,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([
@@ -792,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
@@ -825,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)
 
@@ -1213,11 +1277,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 +1402,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 +1444,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/package.json

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

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

@@ -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 {
@@ -113,6 +119,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 +255,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 +406,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 +488,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 +540,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.' }
       }