sigrank 0.16.0 → 0.17.0

package/tokenpull.mjs

@@ -15,22 +15,22 @@
  * the same { platform, defaultRoot(), messages(root) } contract — Claude is just the first.
  */
 
-import { readdir, readFile, lstat } from 'node:fs/promises'
-import { existsSync } from 'node:fs'
-import { execFile } from 'node:child_process'
-import { join, dirname } from 'node:path'
-import { homedir } from 'node:os'
-import { fileURLToPath } from 'node:url'
-import { ADAPTERS } from './adapters.mjs'
+import { readdir, readFile, lstat } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { execFile } from "node:child_process";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { ADAPTERS } from "./adapters.mjs";
 
-const DAY_MS = 86_400_000
+const DAY_MS = 86_400_000;
 
 // Resolve the package root for finding bundled binaries (ccusage, tokscale, etc.)
-const _pkgRoot = join(dirname(fileURLToPath(import.meta.url)))
-const _localBin = join(_pkgRoot, 'node_modules', '.bin')
+const _pkgRoot = join(dirname(fileURLToPath(import.meta.url)));
+const _localBin = join(_pkgRoot, "node_modules", ".bin");
 // Prepend local node_modules/.bin to PATH so bundled deps are found even when
 // not globally installed (e.g., npx sigrank, local dev).
-const _envPath = `${_localBin}${process.env.PATH ? ':' + process.env.PATH : ''}`
+const _envPath = `${_localBin}${process.env.PATH ? ":" + process.env.PATH : ""}`;
 
 // 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,
@@ -43,11 +43,20 @@ function execFileAsync(cmd, args, timeoutMs) {
   return new Promise((resolve, reject) => {
     // NOTE: execFile does not accept a `stdio` option (it always pipes + buffers
     // stdout/stderr against maxBuffer) — a previous `stdio` key here was silently ignored.
-    execFile(cmd, args, { timeout: timeoutMs, maxBuffer: 10 * 1024 * 1024, env: { ...process.env, PATH: _envPath } }, (err, stdout) => {
-      if (err) reject(err)
-      else resolve(stdout.toString())
-    })
-  })
+    execFile(
+      cmd,
+      args,
+      {
+        timeout: timeoutMs,
+        maxBuffer: 10 * 1024 * 1024,
+        env: { ...process.env, PATH: _envPath },
+      },
+      (err, stdout) => {
+        if (err) reject(err);
+        else resolve(stdout.toString());
+      },
+    );
+  });
 }
 
 // Background tooling that runs under your account but is NOT your work — memory plugins,
@@ -57,20 +66,20 @@ function execFileAsync(cmd, args, timeoutMs) {
 // token-dashboard / tokscale boards; SigRank filters them, so SigRank stays honest.
 // subagents/ are KEPT (real work). Future-robust signal: also drop entrypoint=sdk-cli.
 export const EXCLUDE_TOOLING =
-  /(^|[/-])(claude-mem|mem0|claude-self-reflect|basic-memory|memento|cipher-mem|memory-keeper)\b|observer-(sessions|archive)/i
+  /(^|[/-])(claude-mem|mem0|claude-self-reflect|basic-memory|memento|cipher-mem|memory-keeper)\b|observer-(sessions|archive)/i;
 
 /** The four windows, in days. `all` = unbounded. */
 export const WINDOWS = [
-  { key: '7d', days: 7 },
-  { key: '30d', days: 30 },
-  { key: '90d', days: 90 },
-  { key: 'all', days: Infinity },
-]
+  { key: "7d", days: 7 },
+  { key: "30d", days: 30 },
+  { key: "90d", days: 90 },
+  { key: "all", days: Infinity },
+];
 
 /** Hard cap: stop walking after this many .jsonl files to prevent OOM on
  *  accidentally huge or circularly-symlinked directory trees.
  *  Override via SIGRANK_MAX_JSONL_FILES env var. */
-const MAX_JSONL_FILES = Number(process.env.SIGRANK_MAX_JSONL_FILES) || 10_000
+const MAX_JSONL_FILES = Number(process.env.SIGRANK_MAX_JSONL_FILES) || 10_000;
 
 /** Recursively yield every *.jsonl path under dir (any depth), sorted. Must be
  *  recursive: Claude Code stores sub-agent transcripts in `<project>/subagents/`
@@ -80,22 +89,30 @@ const MAX_JSONL_FILES = Number(process.env.SIGRANK_MAX_JSONL_FILES) || 10_000
  *  Hardened: skips symlinked directories (prevents circular traversal) and stops
  *  after MAX_JSONL_FILES files (prevents OOM on pathological trees). */
 async function* _walkJsonl(dir, _counter = { n: 0 }) {
-  if (_counter.n >= MAX_JSONL_FILES) return
-  let entries
-  try { entries = await readdir(dir, { withFileTypes: true }) } catch { return }
+  if (_counter.n >= MAX_JSONL_FILES) return;
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
   for (const e of entries.sort((a, b) => (a.name < b.name ? -1 : 1))) {
-    if (_counter.n >= MAX_JSONL_FILES) return
-    const full = join(dir, e.name)
+    if (_counter.n >= MAX_JSONL_FILES) return;
+    const full = join(dir, e.name);
     if (e.isDirectory()) {
       // Skip symlinked directories — prevents circular traversal on machines where
       // ~/.claude/projects/ contains a symlink to a large or self-referential tree.
-      let stat
-      try { stat = await lstat(full) } catch { continue }
-      if (stat.isSymbolicLink()) continue
-      yield* _walkJsonl(full, _counter)
-    } else if (e.isFile() && e.name.endsWith('.jsonl')) {
-      _counter.n++
-      yield full
+      let stat;
+      try {
+        stat = await lstat(full);
+      } catch {
+        continue;
+      }
+      if (stat.isSymbolicLink()) continue;
+      yield* _walkJsonl(full, _counter);
+    } else if (e.isFile() && e.name.endsWith(".jsonl")) {
+      _counter.n++;
+      yield full;
     }
   }
 }
@@ -107,23 +124,31 @@ async function* _walkJsonl(dir, _counter = { n: 0 }) {
  * caller can dedup by (session_id, message_id) like token-dashboard.
  */
 export const claudeAdapter = {
-  platform: 'claude',
-  defaultRoot: () => join(homedir(), '.claude', 'projects'),
+  platform: "claude",
+  defaultRoot: () => join(homedir(), ".claude", "projects"),
   async *messages(root) {
     for await (const path of _walkJsonl(root)) {
-      let text
-      try { text = await readFile(path, 'utf8') } catch { continue }
-      const rel = path.startsWith(root) ? path.slice(root.length + 1) : path
-      if (EXCLUDE_TOOLING.test(rel)) continue // skip claude-mem observer & other background tooling
-      for (const line of text.split('\n')) {
-        const s = line.trim()
-        if (!s) continue
-        let ev
-        try { ev = JSON.parse(s) } catch { continue }
-        const m = ev && ev.message
-        if (!m || typeof m !== 'object') continue
-        const u = m.usage
-        if (!u || typeof u !== 'object') continue
+      let text;
+      try {
+        text = await readFile(path, "utf8");
+      } catch {
+        continue;
+      }
+      const rel = path.startsWith(root) ? path.slice(root.length + 1) : path;
+      if (EXCLUDE_TOOLING.test(rel)) continue; // skip claude-mem observer & other background tooling
+      for (const line of text.split("\n")) {
+        const s = line.trim();
+        if (!s) continue;
+        let ev;
+        try {
+          ev = JSON.parse(s);
+        } catch {
+          continue;
+        }
+        const m = ev && ev.message;
+        if (!m || typeof m !== "object") continue;
+        const u = m.usage;
+        if (!u || typeof u !== "object") continue;
         yield {
           id: m.id || null,
           sid: ev.sessionId || null,
@@ -133,11 +158,11 @@ export const claudeAdapter = {
           cacheCreate: Number(u.cache_creation_input_tokens) || 0,
           cacheRead: Number(u.cache_read_input_tokens) || 0,
           file: rel,
-        }
+        };
       }
     }
   },
-}
+};
 
 /**
  * Pull local usage and slice it into the four windows of raw pillars.
@@ -145,25 +170,27 @@ export const claudeAdapter = {
  * Returns { platform, root, generatedAt, files, totalMessages, windows:[{window,pillars,messages}] }.
  */
 export async function tokenpull({ adapter = claudeAdapter, root, now } = {}) {
-  const r = root || adapter.defaultRoot()
-  const nowMs = now == null ? Date.now() : (typeof now === 'number' ? now : Date.parse(now))
+  const r = root || adapter.defaultRoot();
+  const nowMs =
+    now == null ? Date.now() : typeof now === "number" ? now : Date.parse(now);
 
   // Dedup by (session_id, message_id), keeping the FINAL snapshot — matches
   // token-dashboard: Claude Code writes 2-3 partial→final lines per response with
   // the same message.id; only the final tally matches billing. No-id records each
   // get a unique synthetic key so they always count.
-  const seen = new Map()
-  const files = new Set()
-  let noId = 0
+  const seen = new Map();
+  const files = new Set();
+  let noId = 0;
   for await (const msg of adapter.messages(r)) {
-    const key = msg.sid && msg.id ? `${msg.sid}|${msg.id}` : (msg.id || `__noid_${noId++}`)
-    seen.set(key, msg) // keep-last (final snapshot wins)
-    if (msg.file) files.add(msg.file)
+    const key =
+      msg.sid && msg.id ? `${msg.sid}|${msg.id}` : msg.id || `__noid_${noId++}`;
+    seen.set(key, msg); // keep-last (final snapshot wins)
+    if (msg.file) files.add(msg.file);
   }
-  const msgs = [...seen.values()]
+  const msgs = [...seen.values()];
 
   const windows = WINDOWS.map((w) => {
-    const cutoff = w.days === Infinity ? -Infinity : nowMs - w.days * DAY_MS
+    const cutoff = w.days === Infinity ? -Infinity : nowMs - w.days * DAY_MS;
     // NULL-TIMESTAMP WINDOW ASYMMETRY: the `all` window returns true unconditionally,
     // so records whose adapter cannot supply a timestamp (ts: null or unparseable)
     // appear in all-time but disappear from 7d/30d/90d. This is intentional — we do
@@ -173,23 +200,32 @@ export async function tokenpull({ adapter = claudeAdapter, root, now } = {}) {
     // reflects the log file, not the session, and would misattribute old sessions
     // to recent file-touch times.
     const inWin = msgs.filter((m) => {
-      if (w.days === Infinity) return true
-      const t = m.ts ? Date.parse(m.ts) : NaN
-      return Number.isFinite(t) && t >= cutoff && t <= nowMs
-    })
+      if (w.days === Infinity) return true;
+      const t = m.ts ? Date.parse(m.ts) : NaN;
+      return Number.isFinite(t) && t >= cutoff && t <= nowMs;
+    });
     const pillars = inWin.reduce(
-      (a, m) => ({ input: a.input + m.input, output: a.output + m.output, cacheCreate: a.cacheCreate + m.cacheCreate, cacheRead: a.cacheRead + m.cacheRead }),
+      (a, m) => ({
+        input: a.input + m.input,
+        output: a.output + m.output,
+        cacheCreate: a.cacheCreate + m.cacheCreate,
+        cacheRead: a.cacheRead + m.cacheRead,
+      }),
       { input: 0, output: 0, cacheCreate: 0, cacheRead: 0 },
-    )
-    return { window: w.key, pillars, messages: inWin.length }
-  })
+    );
+    return { window: w.key, pillars, messages: inWin.length };
+  });
 
   // Auto-detect background tooling we excluded → report it (the MCP "asks" by telling).
-  let excludedTooling = []
+  let excludedTooling = [];
   try {
-    const top = await readdir(r, { withFileTypes: true })
-    excludedTooling = top.filter((d) => d.isDirectory() && EXCLUDE_TOOLING.test(d.name)).map((d) => d.name)
-  } catch { /* ignore */ }
+    const top = await readdir(r, { withFileTypes: true });
+    excludedTooling = top
+      .filter((d) => d.isDirectory() && EXCLUDE_TOOLING.test(d.name))
+      .map((d) => d.name);
+  } catch {
+    /* ignore */
+  }
 
   return {
     platform: adapter.platform,
@@ -199,7 +235,7 @@ export async function tokenpull({ adapter = claudeAdapter, root, now } = {}) {
     totalMessages: msgs.length,
     excludedTooling,
     windows,
-  }
+  };
 }
 
 // ── Codex ──────────────────────────────────────────────────────────────────
@@ -210,38 +246,48 @@ export async function tokenpull({ adapter = claudeAdapter, root, now } = {}) {
 // The input/cacheCreate split is WINDOW-level (estInput = output × io_ratio), so Codex
 // has its own pull (tokenpullCodex) instead of the per-message claude pipeline.
 export const codexAdapter = {
-  platform: 'codex',
-  defaultRoot: () => join(homedir(), '.codex'),
+  platform: "codex",
+  defaultRoot: () => join(homedir(), ".codex"),
   async *records(root) {
-    for (const sub of ['sessions', 'archived_sessions']) {
+    for (const sub of ["sessions", "archived_sessions"]) {
       for await (const path of _walkJsonl(join(root, sub))) {
-        let text
-        try { text = await readFile(path, 'utf8') } catch { continue }
-        const rel = path.startsWith(root) ? path.slice(root.length + 1) : path
+        let text;
+        try {
+          text = await readFile(path, "utf8");
+        } catch {
+          continue;
+        }
+        const rel = path.startsWith(root) ? path.slice(root.length + 1) : path;
         // Apply the same background-tooling exclusion as the Claude adapter — skips
         // memory plugins / observers running under the Codex account.
-        if (EXCLUDE_TOOLING.test(rel)) continue
-        for (const line of text.split('\n')) {
-          if (!line.includes('"token_count"')) continue
-          let ev
-          try { ev = JSON.parse(line) } catch { continue }
-          const p = ev && ev.payload
-          if (!p || p.type !== 'token_count') continue
-          const u = (p.info || {}).last_token_usage || {}
-          const inputIncl = Number(u.input_tokens) || 0
-          const cached = Number(u.cached_input_tokens) || 0
+        if (EXCLUDE_TOOLING.test(rel)) continue;
+        for (const line of text.split("\n")) {
+          if (!line.includes('"token_count"')) continue;
+          let ev;
+          try {
+            ev = JSON.parse(line);
+          } catch {
+            continue;
+          }
+          const p = ev && ev.payload;
+          if (!p || p.type !== "token_count") continue;
+          const u = (p.info || {}).last_token_usage || {};
+          const inputIncl = Number(u.input_tokens) || 0;
+          const cached = Number(u.cached_input_tokens) || 0;
           yield {
             ts: ev.timestamp || null,
-            output: (Number(u.output_tokens) || 0) + (Number(u.reasoning_output_tokens) || 0),
+            output:
+              (Number(u.output_tokens) || 0) +
+              (Number(u.reasoning_output_tokens) || 0),
             cacheRead: cached,
             uncached: Math.max(0, inputIncl - cached), // (true input + cache-write), split window-level
             file: rel,
-          }
+          };
         }
       }
     }
   },
-}
+};
 
 /**
  * Pull local Codex usage → the 4 windows of CANONICAL pillars (always estimated).
@@ -249,32 +295,63 @@ export const codexAdapter = {
  * input/output ratio; Alpha = 2.0 default), cacheCreate = max(0, uncached − input).
  * Inject ioRatio/root/now/adapter for tests.
  */
-export async function tokenpullCodex({ adapter = codexAdapter, root, now, ioRatio = 2.0 } = {}) {
-  const r = root || adapter.defaultRoot()
-  const nowMs = now == null ? Date.now() : (typeof now === 'number' ? now : Date.parse(now))
-  const recs = []
-  const files = new Set()
-  for await (const m of adapter.records(r)) { recs.push(m); if (m.file) files.add(m.file) }
+export async function tokenpullCodex({
+  adapter = codexAdapter,
+  root,
+  now,
+  ioRatio = 2.0,
+} = {}) {
+  const r = root || adapter.defaultRoot();
+  const nowMs =
+    now == null ? Date.now() : typeof now === "number" ? now : Date.parse(now);
+  const recs = [];
+  const files = new Set();
+  for await (const m of adapter.records(r)) {
+    recs.push(m);
+    if (m.file) files.add(m.file);
+  }
 
   const windows = WINDOWS.map((w) => {
-    const cutoff = w.days === Infinity ? -Infinity : nowMs - w.days * DAY_MS
+    const cutoff = w.days === Infinity ? -Infinity : nowMs - w.days * DAY_MS;
     // NULL-TIMESTAMP WINDOW ASYMMETRY: see tokenpull() above — same behavior.
     // Records without a parseable ts appear in `all` only, not in 7d/30d/90d.
     const inWin = recs.filter((m) => {
-      if (w.days === Infinity) return true
-      const t = m.ts ? Date.parse(m.ts) : NaN
-      return Number.isFinite(t) && t >= cutoff && t <= nowMs
-    })
+      if (w.days === Infinity) return true;
+      const t = m.ts ? Date.parse(m.ts) : NaN;
+      return Number.isFinite(t) && t >= cutoff && t <= nowMs;
+    });
     const sum = inWin.reduce(
-      (a, m) => ({ output: a.output + m.output, cacheRead: a.cacheRead + m.cacheRead, uncached: a.uncached + m.uncached }),
+      (a, m) => ({
+        output: a.output + m.output,
+        cacheRead: a.cacheRead + m.cacheRead,
+        uncached: a.uncached + m.uncached,
+      }),
       { output: 0, cacheRead: 0, uncached: 0 },
-    )
-    const input = Math.floor(sum.output * ioRatio) // estimated true input
-    const cacheCreate = Math.max(0, sum.uncached - input) // split cache-write out of the combined input
-    return { window: w.key, messages: inWin.length, pillars: { input, output: sum.output, cacheCreate, cacheRead: sum.cacheRead } }
-  })
+    );
+    const input = Math.floor(sum.output * ioRatio); // estimated true input
+    const cacheCreate = Math.max(0, sum.uncached - input); // split cache-write out of the combined input
+    return {
+      window: w.key,
+      messages: inWin.length,
+      pillars: {
+        input,
+        output: sum.output,
+        cacheCreate,
+        cacheRead: sum.cacheRead,
+      },
+    };
+  });
 
-  return { platform: 'codex', root: r, generatedAt: new Date(nowMs).toISOString(), files: files.size, totalMessages: recs.length, estimated: true, ioRatio, windows }
+  return {
+    platform: "codex",
+    root: r,
+    generatedAt: new Date(nowMs).toISOString(),
+    files: files.size,
+    totalMessages: recs.length,
+    estimated: true,
+    ioRatio,
+    windows,
+  };
 }
 
 /**
@@ -288,37 +365,48 @@ export async function tokenpullCodex({ adapter = codexAdapter, root, now, ioRati
  * source's log format doesn't expose token counts at all.
  */
 export async function tokenpullAny(platform, opts = {}) {
-  if (!platform || platform === 'claude') return tokenpull({ adapter: claudeAdapter, ...opts })
-  if (platform === 'codex') {
+  if (!platform || platform === "claude")
+    return tokenpull({ adapter: claudeAdapter, ...opts });
+  if (platform === "codex") {
     // Auto-derive io_ratio from the operator's Claude data when not explicitly provided.
-    let ioRatio = opts.ioRatio || 2.0
+    let ioRatio = opts.ioRatio || 2.0;
     if (!opts.ioRatio) {
       try {
         // Forward root/now from opts so the Beta-ratio derivation is testable
         // (without this, it always reads the real ~/.claude and can't be injected).
-        const c = await tokenpull({ adapter: claudeAdapter, root: opts.root, now: opts.now })
-        const all = c.windows.find((w) => w.window === 'all')
-        if (all && all.pillars.output > 0) ioRatio = all.pillars.input / all.pillars.output
-      } catch { /* no Claude data → Alpha 2.0 */ }
+        const c = await tokenpull({
+          adapter: claudeAdapter,
+          root: opts.root,
+          now: opts.now,
+        });
+        const all = c.windows.find((w) => w.window === "all");
+        if (all && all.pillars.output > 0)
+          ioRatio = all.pillars.input / all.pillars.output;
+      } catch {
+        /* no Claude data → Alpha 2.0 */
+      }
     }
-    return tokenpullCodex({ ioRatio, ...opts })
+    return tokenpullCodex({ ioRatio, ...opts });
   }
   // Cloud agents (Devin, etc.) run server-side — no local JSONL to read
-  const CLOUD_AGENTS = { devin: 'Cognition/Devin', }
+  const CLOUD_AGENTS = { devin: "Cognition/Devin" };
   if (platform in CLOUD_AGENTS) {
     throw new Error(
       `"${platform}" (${CLOUD_AGENTS[platform]}) runs in the cloud — sessions are not written to local JSONL files. ` +
-      `There is no local data source to read. If ${CLOUD_AGENTS[platform]} exposes a usage API in future, an adapter can be added.`
-    )
+        `There is no local data source to read. If ${CLOUD_AGENTS[platform]} exposes a usage API in future, an adapter can be added.`,
+    );
   }
-  const adapter = ADAPTERS[platform]
-  if (!adapter) throw new Error(`Unknown platform "${platform}". Valid platforms: claude, codex, ${Object.keys(ADAPTERS).join(', ')}`)
-  const result = await tokenpull({ adapter, ...opts })
+  const adapter = ADAPTERS[platform];
+  if (!adapter)
+    throw new Error(
+      `Unknown platform "${platform}". Valid platforms: claude, codex, ${Object.keys(ADAPTERS).join(", ")}`,
+    );
+  const result = await tokenpull({ adapter, ...opts });
   // Surface adapter-level flags
-  if (adapter.estimated) result.estimated = true
-  if (adapter.dataGap)   result.dataGap   = adapter.dataGap
-  if (adapter.setupNote) result.setupNote = adapter.setupNote
-  return result
+  if (adapter.estimated) result.estimated = true;
+  if (adapter.dataGap) result.dataGap = adapter.dataGap;
+  if (adapter.setupNote) result.setupNote = adapter.setupNote;
+  return result;
 }
 
 // ── Fresh verifier pull (#9 / C1) ─────────────────────────────────────────────
@@ -339,36 +427,52 @@ export async function tokenpullAny(platform, opts = {}) {
 // 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') {
+async function _freshCcusage(platform = "claude") {
   try {
-    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()
-    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
+    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();
+    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
+        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 }
+      result[win] = { input: i, output: o, cacheCreate: cw, cacheRead: cr };
     }
-    let i = 0, o = 0, cw = 0, cr = 0
+    let i = 0,
+      o = 0,
+      cw = 0,
+      cr = 0;
     for (const r of rows) {
-      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
+      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['all'] = { input: i, output: o, cacheCreate: cw, cacheRead: cr }
-    return result
-  } catch { return null }
+    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
@@ -378,21 +482,35 @@ async function _freshCcusage(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')
+async function _freshTokendash(platform = "claude") {
+  if (platform !== "claude") return null;
+  const dbPath = join(homedir(), ".claude", "token-dashboard.db");
   // Read the token-dashboard DB directly with sqlite3 (no external python scan
   // needed — the DB is created by the tokendash dashboard, now bundled as a dep).
   // all-time only; the db doesn't expose windowing here.
-  if (!existsSync(dbPath)) return null
+  if (!existsSync(dbPath)) return null;
   try {
-    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 }
+    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;
+  }
 }
 
 // tokscale: run `tokscale models --json` (bundled as npm dep — no bunx needed)
@@ -405,24 +523,37 @@ async function _freshTokendash(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') {
+async function _freshTokscale(platform = "claude") {
   try {
-    const raw = await execFileAsync('tokscale', ['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) =>
-      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 }
+    const raw = await execFileAsync("tokscale", ["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) =>
+        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;
+  }
 }
 
 /**
@@ -434,14 +565,20 @@ async function _freshTokscale(platform = 'claude') {
  *   - 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'
+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 }
+    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 };
 }