sigrank 0.19.0 → 1.0.2

package/presentation/tui.mjs

@@ -0,0 +1,3316 @@
+/**
+ * tui.mjs — SigRank full tabbed TUI.
+ *
+ * Tabs: [1] Dashboard  [2] Compare  [3] Board  [4] Watch
+ * Navigation: ← → arrow keys, 1-4 number keys, or tab letter shortcuts.
+ * No external dependencies — pure ANSI/Node.js stdin raw mode.
+ *
+ * Architecture:
+ *   - State machine: activeTab + per-tab data cache.
+ *   - On tab switch: clear screen, redraw active tab.
+ *   - Board + Watch tabs auto-refresh on a timer.
+ *   - Dashboard + Compare load once, refresh on [R].
+ */
+
+import { callTool, DEFAULT_API_BASE, pullActivePlatforms } from "../tools.mjs";
+import { ALL_PLATFORMS } from "../adapters.mjs";
+import { cascade, CLASS_TIERS, UNCLASSED, tierOf } from "../cascade.mjs";
+import { freshVerifierPillars } from "../tokenpull.mjs";
+import { isSignedIn, isCodeChar } from "../connect.mjs";
+import { loadIdentity, clearIdentity } from "../keystore.mjs";
+import { execFile } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import os from "os";
+import path from "path";
+import { pathToFileURL } from "node:url";
+import { pkgVersion } from "../lib/pkg-version.mjs";
+import { LEADERBOARD_METRIC } from "../lib/constants.mjs";
+
+// Version read from the shared pkg-version helper (single source of truth —
+// matches cli.mjs; never hardcode, that's what caused the version drift).
+const VERSION = pkgVersion();
+
+// Expensive platform readers that the Dashboard only runs on explicit user
+// request. They remain in ALL_PLATFORMS and are still available to me, watch,
+// Compare, and MCP tool calls when the caller explicitly selects the platform.
+export const DASHBOARD_MANUAL_PLATFORMS = Object.freeze(["omp"]);
+export function dashboardAutoPlatforms(platforms = ALL_PLATFORMS) {
+  return platforms.filter((p) => !DASHBOARD_MANUAL_PLATFORMS.includes(p));
+}
+export function dashboardEnabledPlatforms({
+  includeManual = false,
+  platforms = ALL_PLATFORMS,
+} = {}) {
+  const automatic = dashboardAutoPlatforms(platforms);
+  if (!includeManual) return automatic;
+  return [
+    ...automatic,
+    ...DASHBOARD_MANUAL_PLATFORMS.filter((p) => platforms.includes(p)),
+  ];
+}
+
+// ── ANSI ───────────────────────────────────────────────────────────────────
+// Theme system: colors are centralized in tui-themes.mjs (tokscale-inspired).
+// The `c` object is a live proxy to the current theme — changing the theme
+// via setTheme() updates all colors. Supports dark/light/high-contrast/monochrome.
+import * as _themeMod from "./tui-themes.mjs";
+import { platformColor } from "./tui-themes.mjs";
+const ESC = "\x1b[";
+// `c` is a live proxy — reads currentTheme at access time so theme switches
+// take effect immediately. The helper functions below (paint/bold/dim/etc.)
+// read from `c` at call time, so they always use the active theme's colors.
+const c = new Proxy({}, {
+  get(_target, prop) {
+    return _themeMod.currentTheme[prop];
+  },
+});
+const setTheme = _themeMod.setTheme;
+const paint = (col, s) => `${col}${s}${c.reset}`;
+const bold = (s) => paint(c.bold, s);
+const dim = (s) => paint(c.dim, s);
+const gold = (s) => paint(c.boldGold, s);
+const cyan = (s) => paint(c.boldCyan, s);
+const hdr = (s) => paint(c.boldCyan, s); // table column-header label color (readability)
+const green = (s) => paint(c.green, s);
+const red = (s) => paint(c.red, s);
+
+const CLEAR = `${ESC}H${ESC}2J`; // home + erase visible area
+const CLEAR_SB = `${ESC}3J`; // clear scrollback/saved lines (prevents scroll-up past TUI)
+const ENTER_ALT = `${ESC}?1049h`; // enter alternate screen buffer
+const EXIT_ALT = `${ESC}?1049l`; // exit alternate screen buffer (restores original)
+const HIDE = `${ESC}?25l`;
+const SHOW = `${ESC}?25h`;
+const UP = (n) => `${ESC}${n}A`;
+const ERLINE = `${ESC}2K`;
+const GOTO = (r, col = 1) => `${ESC}${r};${col}H`; // absolute cursor position
+
+const W = () => process.stdout.columns || 100;
+// FIX 0b: safe default 24 (not 40) when rows is undefined (non-TTY / IDE terminals).
+// A 40-row assumption into a 24-row window scrolls the alt-screen → footer smears off.
+const H = () => process.stdout.rows || 24;
+
+// ── Screen buffer: collect lines, then paint only what fits ─────────────
+// Render functions call write/writeln as before; the buffer captures them.
+// flushScreen() paints to the real terminal using absolute cursor positioning
+// so the TUI never scrolls — it's a locked frame like tokscale.
+let _screenBuf = null; // null = direct mode (unbuffered); string[] = buffered
+const write = (s) => {
+  if (_screenBuf) {
+    const parts = s.split("\n");
+    if (parts.length === 1) {
+      _screenBuf[_screenBuf.length - 1] += s;
+    } else {
+      _screenBuf[_screenBuf.length - 1] += parts[0];
+      for (let i = 1; i < parts.length; i++) _screenBuf.push(parts[i]);
+    }
+  } else {
+    process.stdout.write(s);
+  }
+};
+const writeln = (s = "") => {
+  if (_screenBuf) {
+    _screenBuf[_screenBuf.length - 1] += s;
+    _screenBuf.push("");
+  } else {
+    process.stdout.write(s + "\n");
+  }
+};
+
+let _footerBuf = null; // footer lines pinned to bottom
+function startBuffer() {
+  _screenBuf = [""];
+  _footerBuf = null;
+}
+function setFooter(lines) {
+  _footerBuf = lines;
+}
+function flushScreen() {
+  if (!_screenBuf) return;
+  const lines = _screenBuf;
+  const footer = _footerBuf || [];
+  _screenBuf = null;
+  _footerBuf = null;
+  const h = H();
+  const w = W();
+  // FIX 0b: footer is SACROSANCT. Clamp CONTENT to h - footer.length first, then
+  // always append every footer line. The footer must NEVER be the thing dropped
+  // (it was — footer painted last, clamp cut the tail = footer first → lost hints
+  // + lost lower cascade rows, together, because they're the same tail of the frame).
+  const contentRows = Math.max(0, h - footer.length);
+  const content = lines.slice(0, contentRows);
+  const frame = [...content, ...footer];
+  const maxRows = Math.min(frame.length, h);
+  let out = "";
+  for (let i = 0; i < maxRows; i++) {
+    out += GOTO(i + 1) + ERLINE + ansiTrunc(frame[i], w);
+  }
+  // Clear any rows below the frame left over from a taller previous frame.
+  for (let i = maxRows; i < h; i++) {
+    out += GOTO(i + 1) + ERLINE;
+  }
+  process.stdout.write(out);
+}
+
+function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+// ANSI-aware truncate: cut to `w` VISIBLE columns while keeping color escapes
+// intact (escapes don't count toward width, and we never slice mid-sequence).
+// Replaces raw `.slice(0, w)`, which corrupts color codes + miscounts width.
+function ansiTrunc(s, w) {
+  if (stripAnsi(s).length <= w) return s;
+  let out = "",
+    vis = 0,
+    i = 0;
+  while (i < s.length && vis < w) {
+    if (s[i] === "\x1b") {
+      const m = s.slice(i).match(/^\x1b\[[0-9;]*m/);
+      if (m) {
+        out += m[0];
+        i += m[0].length;
+        continue;
+      }
+    }
+    out += s[i];
+    vis++;
+    i++;
+  }
+  return out + c.reset; // reset so a cut mid-color doesn't bleed into next line
+}
+function padEnd(s, w) {
+  const v = stripAnsi(s).length;
+  return v >= w ? s : s + " ".repeat(w - v);
+}
+function padStart(s, w) {
+  const v = stripAnsi(s).length;
+  return v >= w ? s : " ".repeat(w - v) + s;
+}
+function trunc(s, w) {
+  return stripAnsi(s).length <= w ? s : s.slice(0, w - 1) + "…";
+}
+// Wrap a plain-text string into dim'd lines that fit within `maxW` columns.
+// Used for no-data/empty-state messages that can be long on narrow terminals.
+// Returns an array of strings (each already dim'd + indented) for emit().
+function wrapDim(text, indent = "  ", maxW) {
+  const w = maxW || W();
+  const avail = w - 2 - indent.length; // 2 = leading "  " from emit caller
+  if (avail < 20) return [`${indent}${dim(text)}`]; // too narrow to wrap — let it be
+  const words = text.split(" ");
+  const lines = [];
+  let line = "";
+  for (const word of words) {
+    if ((line + " " + word).trim().length > avail) {
+      if (line) lines.push(`${indent}${dim(line.trim())}`);
+      line = word;
+    } else {
+      line = (line + " " + word).trim();
+    }
+  }
+  if (line) lines.push(`${indent}${dim(line.trim())}`);
+  return lines;
+}
+function hr(ch = "─") {
+  return dim(ch.repeat(Math.max(0, W() - 4)));
+}
+
+// ── Number formatters ───────────────────────────────────────────────────────
+const fmtY = (y) =>
+  y == null
+    ? "—"
+    : y >= 10000
+      ? `${(y / 1000).toFixed(1)}K`
+      : y >= 1000
+        ? `${(y / 1000).toFixed(2)}K`
+        : y.toFixed(1);
+const fmtLev = (l) =>
+  l == null ? "—" : l >= 1000 ? `${(l / 1000).toFixed(1)}K` : l.toFixed(0);
+const fmtSNR = (n) => (n == null ? "—" : `${(n * 100).toFixed(1)}%`);
+const fmtTok = (n) =>
+  n == null
+    ? "—"
+    : n >= 1e9
+      ? `${(n / 1e9).toFixed(1)}B`
+      : n >= 1e6
+        ? `${(n / 1e6).toFixed(1)}M`
+        : n >= 1e3
+          ? `${(n / 1e3).toFixed(1)}K`
+          : String(n);
+const fmtMov = (n) =>
+  n == null || n === 0 ? dim("—") : n > 0 ? green(`+${n}`) : red(`${n}`);
+
+// ── Class tier colors ────────────────────────────────────────────────────────
+// Color is keyed on the BASE TIER (8 entries in CLASS_TIERS). classify() returns
+// a full sub-stage string (e.g. "REFINER II") — tierOf() extracts the base tier
+// for color lookup. TRANSMITTER is not a class — it's a temporary peak badge.
+const CLS = {
+  "ARCH+": (s) => paint(c.boldCyan, s),
+  ARCH: (s) => paint(c.cyan, s),
+  POWER: (s) => paint(c.boldWhite, s),
+  BASE: (s) => paint(c.white, s),
+  SEEKER: (s) => paint(c.magenta, s),
+  REFINER: (s) => paint(c.blue, s),
+  BEARER: (s) => paint(c.dim, s),
+  IGNITER: (s) => paint(c.dim, s),
+  [UNCLASSED]: (s) => paint(c.dim, s),
+};
+const colorCls = (cls) => (CLS[tierOf(cls)] ?? CLS[UNCLASSED] ?? ((s) => s))(cls);
+
+// Guard: every canonical tier must have a color, so a new tier added in
+// analytics/cascade.mjs can't silently render uncolored here.
+for (const t of CLASS_TIERS) {
+  if (!CLS[t]) {
+    // eslint-disable-next-line no-console
+    console.warn(`[tui] CLS map missing color for tier "${t}"`);
+  }
+}
+
+// ── Cascade math ───────────────────────────────────────────────────────────
+// Fix 3: the inline cascadeFrom() (a third copy of the cascade math with its
+// own null-guard policy) is replaced by the single shared cascade() from
+// analytics/cascade.mjs. CLI, TUI, and MCP tools now report identical Υ for
+// identical tokens. cascadeFrom() keeps the old name as a thin alias so the
+// many call sites below don't need rewriting; it forwards to the shared
+// implementation and returns null only when there are no pillars at all.
+function cascadeFrom(p) {
+  if (!p) return null;
+  return cascade(p);
+}
+
+// ── Unicode bar chart (no dep) ───────────────────────────────────────────────
+const BLOCKS = " ▏▎▍▌▋▊▉█";
+
+// Log-scale bar — use when values span multiple orders of magnitude (e.g. token pillars
+// where cacheRead >> input). Maps log10(v) to bar width so each 10x = same visual step.
+// minLog floor prevents zero/tiny values from going negative. WIRED into the Dashboard
+// Token Composition section (logTokenBar) so cache-heavy operators like MOSES (1000×
+// scale differences between pillars) render every pillar visibly instead of one pillar
+// erasing the other three.
+function logBar(v, maxLog, width = 40, colorCode = c.cyan) {
+  if (!v || v <= 0) return { bar: dim("·".repeat(width)), pct: 0 };
+  const log = Math.log10(v);
+  const pct = Math.min(log / maxLog, 1);
+  const full = Math.floor(pct * width);
+  const frac = Math.floor((pct * width - full) * 8);
+  const bar = paint(
+    colorCode,
+    "█".repeat(full) + (frac > 0 ? BLOCKS[frac] : ""),
+  );
+  return { bar, pct };
+}
+
+// ── Sparkline (no dep) ────────────────────────────────────────────────────────
+const SPARK = "▁▂▃▄▅▆▇█";
+function sparkline(values) {
+  const valid = values.filter((v) => v != null && Number.isFinite(v));
+  if (valid.length === 0) return dim("no data");
+  // With only 1 valid point there's no trend to show — render a flat marker
+  // at the mid-height so it doesn't look like a rising/falling edge.
+  if (valid.length === 1) {
+    return values
+      .map((v) =>
+        v != null && Number.isFinite(v) ? SPARK[4] : dim(" "),
+      )
+      .join("");
+  }
+  const min = Math.min(...valid),
+    max = Math.max(...valid);
+  return values
+    .map((v) => {
+      if (v == null || !Number.isFinite(v)) return dim(" "); // gap, not a fake low point
+      const idx = max === min ? 4 : Math.round(((v - min) / (max - min)) * 7);
+      return SPARK[idx];
+    })
+    .join("");
+}
+
+// ── Data sources ─────────────────────────────────────────────────────────────
+// (0.12.1 FIX 4) The local verifier readers (ccusage / tokscale / token-dashboard)
+// moved to `freshVerifierPillars()` in tokenpull.mjs — FRESH on-demand pulls used by
+// the Compare tab (#9). The old in-tui copies were dead after A1 removed the Dashboard
+// verifierMap loop and #9 routed Compare through the fresh helper; removed here.
+// (tools.mjs keeps its own `_ccusagePillars`/`_tokscalePillars`/`_tokenDashPillars` —
+// still used by the `tokenpull_compare` MCP tool.)
+
+async function loadDashboardData({ includeOmp = false } = {}) {
+  const boardPromise = Promise.race([
+    fetch(`${DEFAULT_API_BASE}/api/v1/leaderboard?window=30d&metric=${LEADERBOARD_METRIC}`, {
+      headers: { accept: "application/json" },
+    })
+      .then((r) => (r.ok ? r.json() : null))
+      .catch(() => null),
+    new Promise((r) => setTimeout(() => r(null), 5000)),
+  ]);
+
+  // Batched windows: fetch the signed-in operator's rolled-forward totals
+  // (never decrease when platforms delete old logs). Only fetched when signed in.
+  const id = loadIdentity();
+  const batchedPromise = (id && isSignedIn(id))
+    ? Promise.race([
+        fetch(`${DEFAULT_API_BASE}/api/v1/operators/${encodeURIComponent(id.codename)}`, {
+          headers: { accept: "application/json" },
+        })
+          .then((r) => (r.ok ? r.json() : null))
+          .then((d) => d?.batched ?? null)
+          .catch(() => null),
+        new Promise((r) => setTimeout(() => r(null), 5000)),
+      ])
+    : Promise.resolve(null);
+
+  // FIX 0 + unify (0.14): progressive load via the SHARED loader (pullActivePlatforms) — paint the
+  // primary platform (claude) FAST, then fill the rest in fillDashboardRest. This is the SAME loader
+  // `me` and `watch` use, so the three views can't drift apart. (Verifier comparison still runs
+  // FRESH + on-demand in the Compare tab — see loadCompareData — never on this Dashboard path.)
+  const active = await pullActivePlatforms({ platforms: ["claude"] }).catch(
+    () => [],
+  );
+
+  const boardData = await boardPromise;
+  const batchedData = await batchedPromise;
+  return {
+    active,
+    verifierMap: {},
+    tdPillars: null,
+    boardData,
+    batchedData,
+    _loading: true,
+    _remaining: dashboardEnabledPlatforms({
+      includeManual: includeOmp,
+    }).filter((p) => p !== "claude"),
+    _ompAvailable: true,
+    _ompEnabled: includeOmp,
+    _ompLoading: false,
+    _ompScanned: false,
+  };
+}
+
+const dashboardPlatformRank = (p) =>
+  p === "claude" ? -2 : p === "codex" ? -1 : ALL_PLATFORMS.indexOf(p);
+
+async function pullDashboardPlatform(dashData, platform) {
+  try {
+    const active = await pullActivePlatforms({ platforms: [platform] });
+    for (const d of active) {
+      if (!dashData.active.find((a) => a.platform === d.platform))
+        dashData.active.push(d);
+    }
+    dashData.active.sort(
+      (a, b) =>
+        dashboardPlatformRank(a.platform) - dashboardPlatformRank(b.platform),
+    );
+    return { ok: true, found: active.some((d) => d.platform === platform) };
+  } catch {
+    return { ok: false, found: false };
+  }
+}
+
+/**
+ * FIX 0: fill the remaining platforms after the primary render. Mutates
+ * dashData.active and calls onPlatformLoaded after each individual scan so the
+ * TUI can paint rows progressively.
+ */
+async function fillDashboardRest(
+  dashData,
+  { shouldLoadPlatform, onPlatformStarted, onPlatformLoaded } = {},
+) {
+  if (!dashData?._remaining) return false;
+  // Pull all remaining platforms IN PARALLEL. The old sequential approach took
+  // 25s+ (18 platforms × ~1.5s each, most returning nothing). Parallel cuts
+  // total wait to the slowest single platform (~2-3s).
+  const toLoad = dashData._remaining.filter(
+    (p) => !shouldLoadPlatform || shouldLoadPlatform(p),
+  );
+  await Promise.all(
+    toLoad.map(async (platform) => {
+      await onPlatformStarted?.(platform);
+      const result = await pullDashboardPlatform(dashData, platform);
+      await onPlatformLoaded?.(platform, result);
+    }),
+  );
+  dashData._loading = false;
+  dashData._remaining = null;
+  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);
+  // 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") {
+  // Primary: submissions endpoint (ranked submission rows).
+  try {
+    const res = await fetch(
+      `${DEFAULT_API_BASE}/api/v1/submissions?window=${window}&metric=${LEADERBOARD_METRIC}`,
+      {
+        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=${LEADERBOARD_METRIC}`,
+      {
+        headers: { accept: "application/json" },
+      },
+    );
+    if (!res.ok) return null;
+    const data = await res.json();
+    return { ...data, _source: "leaderboard" };
+  } catch {
+    return null;
+  }
+}
+
+// ── TAB BAR ──────────────────────────────────────────────────────────────────
+const TABS = [
+  { key: "1", label: "Dashboard", short: "D" },
+  { key: "2", label: "Trends", short: "T" }, // every metric across windows (sub-views: You/Platform/Field)
+  { key: "3", label: "Compare", short: "C" },
+  { key: "4", label: "Board", short: "B" },
+  { key: "5", label: "Watch", short: "W" }, // in-TUI landing panel; [Enter] launches the watcher
+  { key: "6", label: "Connect", short: "N" }, // sign in / switch device — the whole app is the TUI
+];
+
+// Four Degrees of Leverage — reference values matching signalaf.com/wiki/four-degrees.
+//   base  = AA baseline (7:2:1 modeled reference, static)
+//   hcm   = Human Center of Mass (median of all real operators)
+//   power = Power users (median of top 100 real operators)
+//   top   = Top Evals (single top real operator)
+// STATIC fallback values match the web app's GoldColumn fallbacks (lib/marketing/top-operator-column.ts).
+// Goes live (hcm/power/top computed from the board) once there's real user volume.
+const TD = {
+  base:  { yield: 1.75, snr: 0.33, vel: 0.50, lev: 3.5,   d10: 0.54 },
+  hcm:   { yield: 1.57, snr: 0.33, vel: 0.50, lev: 3.2,   d10: 0.50 },
+  power: { yield: 1.51, snr: 0.07, vel: 0.08, lev: 22.3,  d10: 1.35 },
+  top:   { yield: 488.65, snr: 0.58, vel: 1.36, lev: 360.2, d10: 2.56 },
+};
+
+function renderTabBar(activeIdx) {
+  const w = W();
+  const ts = new Date().toLocaleTimeString("en-US", { hour12: false });
+
+  // logo
+  const logo = `  ${gold("⊙ SigRank")}`;
+  // tabs
+  const tabStr = TABS.map((t, i) => {
+    const lbl = ` ${t.key}:${t.label} `;
+    return i === activeIdx
+      ? `${c.bgCyan}${c.boldCyan}${lbl}${c.reset}`
+      : `${c.bgDim}${c.dim}${lbl}${c.reset}`;
+  }).join("");
+  // right side — version (single source of truth) · site · clock
+  const right = dim(
+    `${gold("v" + VERSION)}${c.reset}${c.dim}  ·  signalaf.com  ·  ${ts}`,
+  );
+
+  const logoVis = stripAnsi(logo).length;
+  const tabsVis = TABS.reduce((a, t) => a + t.label.length + 4, 0);
+  const rightVis = stripAnsi(right).length;
+  const gap = Math.max(1, w - logoVis - tabsVis - rightVis - 2);
+
+  writeln(`${logo}  ${tabStr}${" ".repeat(gap)}${right}`);
+  writeln(`  ${hr()}`);
+}
+
+// ── GRAPHICS helpers ─────────────────────────────────────────────────────────
+
+// Horizontal stacked bar: input | cacheW | cacheR | output
+function tokenBar(p, width = 40) {
+  if (!p) return dim("  no data");
+  const total =
+    (p.input ?? 0) +
+    (p.output ?? 0) +
+    (p.cacheCreate ?? 0) +
+    (p.cacheRead ?? 0);
+  if (total === 0) return dim("  no data");
+  const seg = (val, colorCode) => {
+    const w = Math.round((val / total) * width);
+    return w > 0 ? paint(colorCode, "█".repeat(w)) : "";
+  };
+  const bar =
+    seg(p.input, c.cyan) +
+    seg(p.cacheCreate, c.blue) +
+    seg(p.cacheRead, c.boldGold) +
+    seg(p.output, c.green);
+  return bar;
+}
+
+// Log-scale per-pillar breakdown — 4 separate log10 bars (input / cacheW / cacheR / output)
+// so every pillar stays visible even when one dominates by 1000× (e.g. MOSES cacheRead
+// 2.5B vs input 1.25M). The linear tokenBar() above erases small pillars in that case;
+// this companion view shows the true shape. Returns an array of 4 lines:
+//   ["  I  ▏▎▍▌  1.25M", "  W  ▏▎▍▌▋  128M", "  R  ▏▎▍▌▋▊▉█  2.5B", "  O  ▏▎▍  11.3M"]
+// maxLog is derived from the largest pillar so the biggest pillar fills the bar.
+function logTokenBar(p, width = 36) {
+  if (!p) return [dim("  no data")];
+  const vals = [
+    { lbl: "I", v: p.input ?? 0, color: c.cyan },
+    { lbl: "W", v: p.cacheCreate ?? 0, color: c.blue },
+    { lbl: "R", v: p.cacheRead ?? 0, color: c.boldGold },
+    { lbl: "O", v: p.output ?? 0, color: c.green },
+  ];
+  const maxV = Math.max(...vals.map((x) => x.v), 1);
+  const maxLog = Math.log10(maxV);
+  if (maxLog <= 0) return [dim("  no data")]; // all pillars ≤ 1 → nothing to show
+  return vals.map(({ lbl, v, color }) => {
+    const { bar } = logBar(v, maxLog, width, color);
+    return `  ${paint(color, lbl)}  ${bar}  ${dim(fmtTok(v))}`;
+  });
+}
+
+// Generalized cascade-metric sparkline across windows (7d→30d→90d→all).
+// pick: (cas) => number · fmt: (v) => string. Used by the Trends tab for every metric.
+// FIX G1: window headers are rendered once at the top of each metric block (mirror
+// renderCompare's column layout). metricSpark returns sparkline + RIGHT-ALIGNED
+// values in fixed COL_W columns — NO per-value `w:` prefix (the header row
+// carries the window labels). Null windows render a dim `—` (columns stay aligned).
+const TREND_COL_W = 10;
+const TREND_WINS = ["7d", "30d", "90d", "all"];
+
+function trendHeader() {
+  return (
+    padEnd(dim(""), 12) +
+    TREND_WINS.map((w) => padStart(dim(w), TREND_COL_W)).join("  ")
+  );
+}
+
+function metricSpark(d, pick, fmt) {
+  const vals = TREND_WINS.map((w) => {
+    const wd = d.windows?.find((x) => x.window === w);
+    if (!wd) return null;
+    const cas = cascadeFrom(wd.pillars);
+    return cas ? pick(cas, wd.pillars) : null; // pick gets (cascade, pillars)
+  });
+  const cols = vals.map((v) =>
+    v != null ? padStart(fmt(v), TREND_COL_W) : padStart(dim("—"), TREND_COL_W),
+  );
+  // Non-numeric pick values (e.g. Op Ratio returns an object) can't sparkline —
+  // show just the formatted columns. Numeric values get the sparkline prefix.
+  const numericVals = vals.map((v) =>
+    v != null && Number.isFinite(v) ? v : null,
+  );
+  const hasNumeric = numericVals.some((v) => v != null);
+  if (!hasNumeric) return `  ${cols.join("  ")}`;
+  return sparkline(numericVals) + `  ${cols.join("  ")}`;
+}
+
+// ── TAB 1: DASHBOARD ─────────────────────────────────────────────────────────
+
+// SCROLL-VIEW (2026-06-27): section-scoped scroll for the cascade table.
+// The cascade section gets a real scroll viewport — up/down arrows scroll just
+// the cascade rows while the rest of the dashboard (header, token composition,
+// board, footer) stays pinned. This replaces the misleading "+N more — resize /
+// scroll" text (A3) which implied scroll existed but didn't (alt-screen locked
+// frame = no terminal scroll). The scroll is IN-SECTION only, on the Dashboard tab.
+
+const DASH_WINS = ["7d", "30d", "90d", "all"];
+
+// Count how many cascade rows the active platforms would produce (every window
+// with data across all active platforms). This is the "total wanted" count.
+function cascadeScrollableCount(active) {
+  return active.reduce(
+    (n, d) =>
+      n +
+      DASH_WINS.filter((wk) => {
+        const wd = d.windows?.find((x) => x.window === wk);
+        return wd && wd.pillars.input + wd.pillars.output > 0;
+      }).length,
+    0,
+  );
+}
+
+// Compute the max cascade rows that fit in the current terminal height budget.
+// Mirrors the calculation in renderDashboard (budget - used - sectionsBelow).
+function maxCascadeRowsFor(active) {
+  const budget = H() - 4; // 2 tab bar + 2 footer
+  const platformCount = active.length;
+  const barLines = 4 + platformCount + (platformCount > 1 ? 1 : 0);
+  const boardLines = 17;
+  const sectionsBelow = barLines + boardLines;
+  // used before cascade = header(2) + blank(1) + title(1) + blank(1) + col-header(1) + separator(1) = 7
+  const usedBeforeCascade = 7;
+  return Math.max(8, budget - usedBeforeCascade - sectionsBelow);
+}
+
+function renderDashboard(data, status = "", scrollOffset = 0) {
+  const w = W();
+  const budget = H() - 4; // 2 tab bar + 2 footer
+  const WINS = ["7d", "30d", "90d", "all"];
+  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.
+  // On very narrow terminals (<100), also hide Class and shorten cache headers
+  // to CW/CR so the core pillars + Υ/SNR/Lev still fit at 80 cols.
+  const narrow = w < 124;
+  const veryNarrow = w < 100;
+  const ultraNarrow = w < 90;
+  const gap = narrow ? " " : "  ";
+  const cwLabel = veryNarrow ? "CW" : "CacheW";
+  const crLabel = veryNarrow ? "CR" : "CacheR";
+  const renderRow = (label, colorFn, winKey, p, est = false) => {
+    const cas = cascadeFrom(p);
+    if (!cas) return;
+    const clsFn = CLS[cas.class] ?? ((s) => s);
+    const cols = [
+      padEnd(colorFn(label), 12),
+      padEnd(dim(winKey), 5),
+      padStart(est ? dim("~") + fmtTok(p.input) : fmtTok(p.input), 8),
+      padStart(fmtTok(p.output), 8),
+      padStart(
+        (p.cacheCreate ?? 0) > 0
+          ? est
+            ? dim("~") + fmtTok(p.cacheCreate)
+            : fmtTok(p.cacheCreate)
+          : dim("—"),
+        8,
+      ),
+      padStart((p.cacheRead ?? 0) > 0 ? fmtTok(p.cacheRead) : dim("—"), 9),
+      padStart(cas.yield > 10000 ? gold(fmtY(cas.yield)) : fmtY(cas.yield), 9),
+      ...(ultraNarrow ? [] : [padStart(fmtSNR(cas.snr), 7)]),
+      ...(ultraNarrow ? [] : [padStart(fmtLev(cas.leverage) + "×", 7)]),
+      ...(narrow
+        ? []
+        : [
+            padStart(cas.velocity?.toFixed(2) ?? "—", 6),
+            padStart(cas.dev10x?.toFixed(2) ?? "—", 6),
+          ]),
+      ...(veryNarrow ? [] : [padEnd(clsFn(cas.class), 13)]),
+    ];
+    emit(`    ${cols.join(gap)}`);
+  };
+
+  // ── Cascade table
+  emit();
+  emit(`  ${bold("Your Cascade")}  ${dim("all platforms · all windows")}`);
+  emit();
+
+  // header (matches renderRow's responsive column set + gap)
+  const CH = [
+    padEnd(hdr("Platform"), 12),
+    padEnd(hdr("Win"), 5),
+    padStart(hdr("Input"), 8),
+    padStart(hdr("Output"), 8),
+    padStart(hdr(cwLabel), 8),
+    padStart(hdr(crLabel), 9),
+    padStart(hdr("Υ Yield"), 9),
+    ...(ultraNarrow ? [] : [padStart(hdr("SNR"), 7)]),
+    ...(ultraNarrow ? [] : [padStart(hdr("Lev"), 7)]),
+    ...(narrow ? [] : [padStart(hdr("Vel"), 6), padStart(hdr("10x"), 6)]),
+    ...(veryNarrow ? [] : [padEnd(hdr("Class"), 13)]),
+  ];
+  emit(`    ${CH.join(gap)}`);
+  emit(`  ${dim("·".repeat(Math.max(0, Math.min(w - 4, narrow ? (ultraNarrow ? 70 : veryNarrow ? 80 : 96) : 114))))}`);
+
+  if (active.length === 0) {
+    // Count is derived from the registry — a hardcoded number drifts every time an
+    // adapter is added (it read "14 platforms" while ALL_PLATFORMS held 17).
+    emit(
+      `  ${dim(`  reading token logs… (${dashboardAutoPlatforms().length} automatic · omp is manual [O])`)}`,
+    );
+  }
+
+  // Calculate how many cascade rows we can fit — reserve space for lower sections.
+  // (Υ-trend section moved to the Trends tab; its old `sparkLines` reservation is gone,
+  // which is what was starving codex's cascade rows after the Your-Read/Three-Degrees panels landed.)
+  const platformCount = active.length;
+  const barLines = 4 + platformCount + (platformCount > 1 ? 1 : 0); // Token Composition: hr + header + platforms + combined + note
+  // Your Read (hr+header+up to 4 wins+up to 5 gaps+summary = 13) + Four Degrees (blank+hr+header+col-header+5 rows+note = 10) + Lifetime Tokens (blank+hr+header+platforms+combined+note = ~7) + status
+  const boardLines = 24;
+  const sectionsBelow = barLines + boardLines;
+  const maxCascadeRows = Math.max(8, budget - used - sectionsBelow);
+
+  // SCROLL-VIEW (2026-06-27): Build the full list of cascade rows first, then
+  // slice by [scrollOffset, scrollOffset + maxCascadeRows]. This gives a real
+  // in-section scroll viewport — up/down arrows scroll just the cascade rows
+  // while the rest of the dashboard stays pinned. Replaces the A3 "+N more —
+  // resize / scroll" text which implied scroll existed but didn't.
+  let firstWin = {};
+  const allCascadeRows = []; // flat list: { platform, winKey, pillars, estimated }
+  for (const d of active) {
+    firstWin[d.platform] = WINS.find((wk) => {
+      const wd = d.windows?.find((w) => w.window === wk);
+      return wd && wd.pillars.input + wd.pillars.output > 0;
+    });
+    for (const wk of WINS) {
+      const wd = d.windows?.find((x) => x.window === wk);
+      if (!wd || wd.pillars.input + wd.pillars.output === 0) continue;
+      allCascadeRows.push({
+        platform: d.platform,
+        winKey: wk,
+        pillars: wd.pillars,
+        estimated: d.estimated,
+      });
+    }
+  }
+
+  const totalWanted = allCascadeRows.length;
+  const canScroll = totalWanted > maxCascadeRows;
+  // Clamp scroll offset to valid range [0, totalWanted - maxCascadeRows]
+  const maxOffset = Math.max(0, totalWanted - maxCascadeRows);
+  const effectiveOffset = Math.min(scrollOffset, maxOffset);
+  const visibleRows = allCascadeRows.slice(
+    effectiveOffset,
+    effectiveOffset + maxCascadeRows,
+  );
+
+  // ▲ indicator: rows above the current viewport
+  if (canScroll && effectiveOffset > 0) {
+    emit(
+      `  ${dim(`  ▲ ${effectiveOffset} row${effectiveOffset > 1 ? "s" : ""} above`)}`,
+    );
+  }
+
+  // Render the visible slice — group by platform (emit a blank line between platforms)
+  let lastPlatform = null;
+  for (const row of visibleRows) {
+    if (lastPlatform !== null && row.platform !== lastPlatform) emit();
+    renderRow(
+      row.platform,
+      (s) => {
+        const pc = platformColor(row.platform);
+        return row.winKey === firstWin[row.platform] ? bold(pc(s)) : dim(s);
+      },
+      row.winKey,
+      row.pillars,
+      row.estimated,
+    );
+    lastPlatform = row.platform;
+  }
+  if (visibleRows.length > 0) emit();
+
+  // ▼ indicator: rows below the current viewport
+  const rowsBelow = totalWanted - effectiveOffset - visibleRows.length;
+  if (canScroll && rowsBelow > 0) {
+    emit(
+      `  ${dim(`  ▼ ${rowsBelow} row${rowsBelow > 1 ? "s" : ""} below · ↑↓ scroll`)}${effectiveOffset > 0 ? dim(` · ${effectiveOffset}/${maxOffset}`) : ""}`,
+    );
+  }
+
+  // combined
+  if (active.length > 1 && used < budget - sectionsBelow) {
+    const lbl = active.map((d) => d.platform).join("+");
+    const hasEst = active.some((d) => d.estimated);
+    let fst = true;
+    for (const wk of WINS) {
+      const cp = { input: 0, output: 0, cacheCreate: 0, cacheRead: 0 };
+      let any = false;
+      for (const d of active) {
+        const wd = d.windows?.find((x) => x.window === wk);
+        if (!wd || wd.pillars.input + wd.pillars.output === 0) continue;
+        cp.input += wd.pillars.input ?? 0;
+        cp.output += wd.pillars.output ?? 0;
+        cp.cacheCreate += wd.pillars.cacheCreate ?? 0;
+        cp.cacheRead += wd.pillars.cacheRead ?? 0;
+        any = true;
+      }
+      if (!any) continue;
+      renderRow(lbl, (s) => (fst ? bold(cyan(s)) : dim(s)), wk, cp, hasEst);
+      fst = false;
+    }
+    emit();
+  }
+
+  // (Υ Trend moved to the dedicated Trends tab [2] — every metric, with sub-views.)
+
+  // ── Token bar charts (skip if no room)
+  if (used < budget - boardLines) {
+    emit(`  ${hr()}`);
+    emit(
+      `  ${bold("Token Composition")}  ${dim("█")}${paint(c.cyan, "I")}${dim(" in  █")}${paint(c.blue, "W")}${dim(" cW  █")}${paint(c.boldGold, "R")}${dim(" cR  █")}${paint(c.green, "O")}${dim(" out")}`,
+    );
+    for (const d of active) {
+      if (used >= budget - boardLines) break;
+      const all = d.windows?.find((w) => w.window === "all");
+      if (!all) continue;
+      emit(
+        `    ${padEnd(platformColor(d.platform)(d.platform), 10)}  ${tokenBar(all.pillars, 50)}  ${dim(fmtTok((all.pillars.input ?? 0) + (all.pillars.output ?? 0) + (all.pillars.cacheCreate ?? 0) + (all.pillars.cacheRead ?? 0)))}`,
+      );
+    }
+    if (active.length > 1) {
+      const cp = { input: 0, output: 0, cacheCreate: 0, cacheRead: 0 };
+      for (const d of active) {
+        const all = d.windows?.find((w) => w.window === "all");
+        if (!all) continue;
+        cp.input += all.pillars.input ?? 0;
+        cp.output += all.pillars.output ?? 0;
+        cp.cacheCreate += all.pillars.cacheCreate ?? 0;
+        cp.cacheRead += all.pillars.cacheRead ?? 0;
+      }
+      emit(
+        `    ${padEnd(bold(active.map((d) => d.platform).join("+")), 10)}  ${tokenBar(cp, 50)}  ${dim(fmtTok(cp.input + cp.output + cp.cacheCreate + cp.cacheRead))}`,
+      );
+    }
+    // Log-scale per-pillar breakdown — companion to the linear stacked bar above.
+    // The linear bar erases small pillars when one dominates by 1000× (MOSES-class:
+    // cacheRead 2.5B vs input 1.25M → input gets 0 width). The log view shows every
+    // pillar's true shape so the operator can see the full composition at a glance.
+    // Only renders for the combined row (or the single platform when there's one) to
+    // avoid blowing the height budget on multi-platform setups.
+    if (used < budget - boardLines - 5) {
+      const cp = { input: 0, output: 0, cacheCreate: 0, cacheRead: 0 };
+      for (const d of active) {
+        const all = d.windows?.find((w) => w.window === "all");
+        if (!all) continue;
+        cp.input += all.pillars.input ?? 0;
+        cp.output += all.pillars.output ?? 0;
+        cp.cacheCreate += all.pillars.cacheCreate ?? 0;
+        cp.cacheRead += all.pillars.cacheRead ?? 0;
+      }
+      const total = cp.input + cp.output + cp.cacheCreate + cp.cacheRead;
+      if (total > 0) {
+        emit(
+          `  ${dim("log-scale (each 10× = same step — every pillar visible)")}`,
+        );
+        for (const line of logTokenBar(cp, 36)) emit(line);
+      }
+    }
+  }
+
+  // ── Your insights + the Four Degrees panel (replaces the old top-3 mini board)
+  // The user's own cascade (the firstWin/combined row computed above) read against the
+  // Four Degrees reference so the Dashboard says "here's you, here's the field, here's the ceiling."
+  const you = (() => {
+    // Best available cascade for the user: prefer claude's first-window, else any computed row.
+    for (const d of active) {
+      const wk = firstWin[d.platform];
+      const wd = d.windows?.find((x) => x.window === wk);
+      const cas = wd && cascadeFrom(wd.pillars);
+      // cascadeFrom returns null only when wd.pillars is falsy; otherwise it
+      // forwards to cascade() which always returns an object (degenerate input
+      // surfaces as null fields + warnings[], not a null return). The guard
+      // below skips rows with no pillars at all; downstream `chk(val == null)`
+      // guards handle degenerate-but-present pillars.
+      if (cas) return cas;
+    }
+    return null;
+  })();
+
+  if (used < budget - 8) {
+    // ── Custom insights — comparison vs the field + a concrete tip for the weakest metric
+    emit(`  ${hr()}`);
+    emit(
+      `  ${bold("Your Read")}  ${dim("how your cascade sits vs the field")}`,
+    );
+    if (you) {
+      const wins = [],
+        gaps = [];
+      let aboveHcm = 0,
+        abovePower = 0,
+        totalMetrics = 0;
+      // Three-tier comparison: HCM (field median) → Power (top-100 median) → Top (best operator)
+      const chk = (label, val, hcm, power, top, fmt, tip) => {
+        if (val == null) return;
+        totalMetrics++;
+        if (val >= top * 0.9) {
+          wins.push(`${label} ${fmt(val)} — ${gold("top tier")}`);
+          aboveHcm++;
+          abovePower++;
+        } else if (val >= power) {
+          wins.push(`${label} ${fmt(val)} — ${paint(c.boldCyan, "power-user tier")}`);
+          aboveHcm++;
+          abovePower++;
+        } else if (val >= hcm) {
+          wins.push(`${label} ${fmt(val)} — above field, ${dim("approaching power-user")}`);
+          aboveHcm++;
+        } else {
+          gaps.push({
+            label,
+            txt: `${label} ${fmt(val)} — below field (${fmt(hcm)}): ${tip}`,
+            val,
+            hcm,
+          });
+        }
+      };
+      chk(
+        "Υ Yield",
+        you.yield,
+        TD.hcm.yield,
+        TD.power.yield,
+        TD.top.yield,
+        fmtY,
+        "compound more — reuse cache, raise output",
+      );
+      chk(
+        "SNR",
+        you.snr,
+        TD.hcm.snr,
+        TD.power.snr,
+        TD.top.snr,
+        fmtSNR,
+        "tighten prompts — less input per unit output",
+      );
+      chk(
+        "Leverage",
+        you.leverage,
+        TD.hcm.lev,
+        TD.power.lev,
+        TD.top.lev,
+        (v) => fmtLev(v) + "×",
+        "lean on cache-read — amplify prior context",
+      );
+      chk(
+        "Velocity",
+        you.velocity,
+        TD.hcm.vel,
+        TD.power.vel,
+        TD.top.vel,
+        (v) => v.toFixed(2),
+        "more output per input token",
+      );
+      chk(
+        "10xDEV",
+        you.dev10x,
+        TD.hcm.d10,
+        TD.power.d10,
+        TD.top.d10,
+        (v) => v.toFixed(2),
+        "raise leverage — every 10× lev adds 1 to 10xDEV",
+      );
+      for (const w of wins.slice(0, 4)) emit(`    ${paint(c.green, "▲")} ${w}`);
+      // all gaps shown; weakest gets the prescriptive tip
+      const sortedGaps = gaps.sort(
+        (a, b) => a.val / a.hcm - b.val / b.hcm,
+      );
+      for (let i = 0; i < sortedGaps.length; i++) {
+        const g = sortedGaps[i];
+        if (i === 0) emit(`    ${paint(c.magenta, "▽")} ${dim(g.txt)}`);
+        else emit(`    ${paint(c.magenta, "▽")} ${dim(g.label + " below field")}`);
+      }
+      if (!wins.length && !sortedGaps.length) emit(`    ${dim("  building your read…")}`);
+      // summary line — where you sit across all metrics
+      if (totalMetrics > 0) {
+        const hcmStr = `${aboveHcm}/${totalMetrics}`;
+        const pwrStr = `${abovePower}/${totalMetrics}`;
+        emit(
+          `    ${dim(`above HCM on ${bold(hcmStr)} · above Power on ${bold(pwrStr)}`)}`,
+        );
+      }
+    } else {
+      emit(`    ${dim("  reading your cascade… (press [R] to refresh)")}`);
+    }
+
+    // ── Four Degrees — AA baseline · Human Center of Mass · Power users · Top Evals
+    // Matches signalaf.com/wiki/four-degrees (expanded from 3 → 4 degrees 2026-07-17).
+    emit();
+    emit(`  ${hr()}`);
+    emit(
+      `  ${bold("Four Degrees")}  ${dim("AA · HCM · Power · Top Evals — signalaf.com/wiki")}`,
+    );
+    const tdHead = [
+      padEnd(hdr("Metric"), 10),
+      padStart(hdr("AA base"), 9),
+      padStart(hdr("HCM"), 9),
+      padStart(hdr("Power"), 9),
+      padStart(hdr("Top"), 9),
+    ];
+    emit(`    ${tdHead.join("  ")}`);
+    const white = (s) => paint(c.white, s);
+    const tdRow = (label, b, h, p, t, fmt) =>
+      emit(
+        `    ${padEnd(label, 10)}  ${padStart(dim(fmt(b)), 9)}  ${padStart(white(fmt(h)), 9)}  ${padStart(white(fmt(p)), 9)}  ${padStart(gold(fmt(t)), 9)}`,
+      );
+    tdRow("Υ Yield", TD.base.yield, TD.hcm.yield, TD.power.yield, TD.top.yield, fmtY);
+    tdRow("SNR", TD.base.snr, TD.hcm.snr, TD.power.snr, TD.top.snr, fmtSNR);
+    tdRow("Velocity", TD.base.vel, TD.hcm.vel, TD.power.vel, TD.top.vel, (v) =>
+      v.toFixed(2),
+    );
+    tdRow(
+      "Leverage",
+      TD.base.lev,
+      TD.hcm.lev,
+      TD.power.lev,
+      TD.top.lev,
+      (v) => fmtLev(v) + "×",
+    );
+    tdRow("10xDEV", TD.base.d10, TD.hcm.d10, TD.power.d10, TD.top.d10, (v) => v.toFixed(2));
+    emit(
+      `    ${dim("reference values until live user volume calibrates HCM · Power · Top")}`,
+    );
+  }
+
+  // ── Lifetime Tokens — submission-based rolled-forward totals (never decrease)
+  // Shows when the operator is signed in and has submission history. The batched
+  // data comes from the server (computeBatchedWindows over snapshot_submissions).
+  const batched = data?.batchedData;
+  if (batched && used < budget - 4) {
+    const fmtT = (n) => {
+      if (n >= 1e9) return (n / 1e9).toFixed(1) + "B";
+      if (n >= 1e6) return (n / 1e6).toFixed(1) + "M";
+      if (n >= 1e3) return (n / 1e3).toFixed(1) + "K";
+      return String(n);
+    };
+    const total = (p) => (p?.input ?? 0) + (p?.output ?? 0) + (p?.cacheCreate ?? 0) + (p?.cacheRead ?? 0);
+    emit();
+    emit(`  ${hr()}`);
+    emit(`  ${bold("Lifetime Tokens")}  ${dim("archived submissions · never decreases")}`);
+    const platforms = Object.entries(batched.per_platform ?? {});
+    for (const [plat, pw] of platforms) {
+      if (used >= budget - 2) break;
+      const pc = platformColor(plat);
+      const allT = total(pw.all);
+      const d90T = total(pw["90d"]);
+      emit(
+        `    ${padEnd(pc(plat), 10)}  ${padStart(fmtT(allT), 8)} total  ${dim("·")}  ${padStart(fmtT(d90T), 8)} in last 90d`,
+      );
+    }
+    if (platforms.length > 1) {
+      const cAll = total(batched.combined?.all);
+      const c90 = total(batched.combined?.["90d"]);
+      emit(
+        `    ${padEnd(bold("combined"), 10)}  ${padStart(bold(fmtT(cAll)), 8)} total  ${dim("·")}  ${padStart(bold(fmtT(c90)), 8)} in last 90d`,
+      );
+    }
+    // Find the earliest baseline date across platforms
+    const baselineDates = platforms.map(([, pw]) => pw.baseline_date).filter(Boolean).sort();
+    const subCounts = platforms.map(([, pw]) => pw.submission_count ?? 0);
+    const totalSubs = subCounts.reduce((a, b) => a + b, 0);
+    if (baselineDates.length > 0) {
+      emit(
+        `    ${dim(`${totalSubs} submission${totalSubs !== 1 ? "s" : ""} archived · baseline ${baselineDates[0].slice(0, 10)}`)}`,
+      );
+    }
+  }
+
+  if (status && used < budget) emit(`  ${dim(status)}`);
+}
+
+// ── TAB 2: TRENDS ─────────────────────────────────────────────────────────────
+// Every cascade metric (+ rank) as a 7d→30d→90d→all sparkline. Three sub-tabs:
+//   You      — your own trajectory (+ rank trend, "calculating" until wired)
+//   Platform — per-platform (claude / codex / combined)
+//   Field    — board-wide trend (calculating until window-history materializes)
+// Switch sub-tabs with [T] (cycles You · Platform · Field). Data: the same `active` the Dashboard loads.
+const TREND_SUBTABS = ["You", "Platform", "Field"];
+// All leaderboard metrics. Most derive from the per-window cascade (pick takes the
+// cascade obj + its pillars); §IGNA (proprietary composite) and $/1M (needs cost data)
+// aren't computed client-side yet → rendered "calculating", same honest pattern as Rank.
+const AA_EFF_BASELINE = 4.0; // efficiency is measured vs the AA 4.0 baseline (per the wiki)
+const TREND_METRICS = [
+  {
+    label: "∑ Total",
+    pick: (c, p) =>
+      (p.input ?? 0) +
+      (p.output ?? 0) +
+      (p.cacheCreate ?? 0) +
+      (p.cacheRead ?? 0),
+    fmt: fmtTok,
+  },
+  { label: "Υ Yield", pick: (c) => c.yield, fmt: fmtY },
+  { label: "SNR", pick: (c) => c.snr, fmt: fmtSNR },
+  { label: "Velocity", pick: (c) => c.velocity, fmt: (v) => v.toFixed(2) },
+  { label: "Leverage", pick: (c) => c.leverage, fmt: (v) => fmtLev(v) + "×" },
+  { 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)",
+  },
+  // 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 budget = H() - 4;
+  let used = 0;
+  const emit = (s = "") => {
+    if (used < budget) {
+      writeln(s);
+      used++;
+    }
+  };
+  const sub = TREND_SUBTABS[subIdx] ?? "You";
+
+  // sub-tab switcher row
+  const subBar = TREND_SUBTABS.map((t, i) =>
+    i === subIdx
+      ? `${c.bgCyan}${c.boldCyan} ${t} ${c.reset}`
+      : `${dim(` ${t} `)}`,
+  ).join(" ");
+  emit();
+  emit(
+    `  ${bold("Trends")}  ${dim("every metric across windows (7d → all)")}    ${subBar}`,
+  );
+  emit(`  ${dim("·".repeat(Math.min(W() - 4, 70)))}`);
+  emit();
+
+  if (sub === "You" || sub === "Platform") {
+    // FIX (2026-08-18): "You" previously took only active[0]?.windows (the first
+    // platform by sort order — usually claude). If that platform had no timestamps
+    // (NULL-TIMESTAMP WINDOW ASYMMETRY → 7d/30d/90d empty) or no local data, "You"
+    // showed nothing even when other platforms had data. Now aggregate ALL active
+    // platforms' windows into one combined "you" row, summing pillars per window
+    // so every platform contributes to every window it has data for.
+    const rows =
+      sub === "You"
+        ? active?.length
+          ? [
+              {
+                platform: "you",
+                windows: TREND_WINS.map((wk) => {
+                  let input = 0,
+                    output = 0,
+                    cacheCreate = 0,
+                    cacheRead = 0,
+                    messages = 0;
+                  for (const d of active) {
+                    const wd = d.windows?.find((x) => x.window === wk);
+                    if (wd) {
+                      input += wd.pillars.input ?? 0;
+                      output += wd.pillars.output ?? 0;
+                      cacheCreate += wd.pillars.cacheCreate ?? 0;
+                      cacheRead += wd.pillars.cacheRead ?? 0;
+                      messages += wd.messages ?? 0;
+                    }
+                  }
+                  return {
+                    window: wk,
+                    pillars: { input, output, cacheCreate, cacheRead },
+                    messages,
+                  };
+                }),
+              },
+            ]
+          : []
+        : (active ?? []);
+    if (!rows.length) {
+      emit(`  ${dim("  reading your cascade… (press [R] to refresh)")}`);
+    }
+    // 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()}`);
+      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 + ")")}`,
+          );
+        } else {
+          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.
+    // SCROLL-VIEW (2026-06-27): changed "resize / scroll" → "resize to see more"
+    // because these tabs don't have a real scroll viewport (only Dashboard cascade does).
+    if (trendsDropped > 0)
+      emit(`  ${dim(`  +${trendsDropped} more — resize to see more`)}`);
+  } else {
+    // Field
+    emit(`  ${dim("  Field-wide trends — calculating…")}`);
+    emit(
+      `  ${dim("  (needs per-window board history; materializes once live ingest lands)")}`,
+    );
+  }
+}
+
+// ── TAB 3: COMPARE ───────────────────────────────────────────────────────────
+function renderCompare(data) {
+  // FIX (2026-08-18): guard against null data — the debug renderOnce path
+  // (node tui.mjs --render 1) passes null when loadCompareData fails, and
+  // destructure of null throws. Coalesce to a safe empty shape.
+  const { tpData, cc, ts, td } = data ?? {};
+  const platform = data?.platform ?? "claude";
+  const WINS = ["7d", "30d", "90d", "all"];
+  const w = W();
+  // Compare tab needs more vertical space — 4 sources × 4 pillars = 16 rows
+  // + headers + cascade metrics. Use full terminal height (not H()-4) and
+  // fall back to a generous fixed minimum when rows is undefined (--render mode).
+  const budget = Math.max(H() - 2, 40);
+  let used = 0;
+  const emit = (s = "") => {
+    if (used < budget) {
+      writeln(s);
+      used++;
+    }
+  };
+
+  const tpPillars = {};
+  for (const win of tpData?.windows ?? []) tpPillars[win.window] = win.pillars;
+
+  const SOURCES = [
+    {
+      name: "tokenpull",
+      color: (s) => paint(c.boldCyan, s),
+      pillars: tpPillars,
+      note: "JSONL canon",
+    },
+    {
+      name: "ccusage",
+      color: (s) => paint(c.green, s),
+      pillars: cc ?? {},
+      note: "ccusage CLI",
+    },
+    {
+      name: "token-dash",
+      color: (s) => paint(c.magenta, s),
+      pillars: td ?? {},
+      note: "SQLite",
+    },
+    {
+      name: "tokscale",
+      color: (s) => paint(c.blue, s),
+      pillars: ts ?? {},
+      note: "report.json",
+    },
+  ].filter((s) => Object.keys(s.pillars).length > 0);
+
+  emit();
+  // Shorten the source list on narrow terminals to avoid header overflow.
+  const sourceList = w < 90
+    ? `${SOURCES.length} sources`
+    : "tokenpull vs ccusage vs token-dash vs tokscale";
+  emit(
+    `  ${bold("Source Comparison")}  ${dim(`platform: ${platform}`)}  ${dim(`·  ${sourceList}`)}`,
+  );
+
+  if (!tpData) {
+    emit(
+      `  ${dim("tokenpull: no JSONL data found — check ~/.claude/projects/")}`,
+    );
+  } else {
+    const all = tpPillars["all"];
+    if (all) {
+      emit(
+        `  ${dim("tokenpull all-time:")}  In ${cyan(fmtTok(all.input))}  Out ${green(fmtTok(all.output))}  CW ${paint(c.blue, fmtTok(all.cacheCreate))}  CR ${gold(fmtTok(all.cacheRead))}`,
+      );
+    }
+  }
+  // FIX (2026-08-18): surface WHY external verifiers are absent so the user knows
+  // it's a missing-tool issue, not a bug. Each verifier is null when its CLI/DB
+  // isn't installed or returned no data for this platform.
+  const missing = [];
+  if (!cc) missing.push("ccusage (npm i -g ccusage)");
+  if (!td) missing.push("token-dashboard (~/.claude/token-dashboard.db)");
+  if (!ts) missing.push("tokscale (npm i -g tokscale)");
+  if (missing.length)
+    for (const ln of wrapDim(`no data from: ${missing.join(" · ")}`)) emit(ln);
+  emit();
+
+  // FIX (2026-08-18): if ALL sources are empty (tokenpull has no windows AND all
+  // verifiers are null), show a clear empty-state message instead of bare headers
+  // with zero data rows.
+  if (SOURCES.length === 0) {
+    for (const ln of wrapDim(
+      "no source data available for this platform — install a verifier or check ~/.claude/projects/",
+    ))
+      emit(ln);
+    return;
+  }
+
+  const COL_W = 11;
+  const hcols = [
+    padEnd(dim("Source"), 12),
+    padEnd(dim("Pillar"), 10),
+    ...WINS.map((wn) => padStart(dim(wn), COL_W)),
+  ];
+  emit(`    ${hcols.join("  ")}`);
+  emit(
+    `  ${dim("·".repeat(Math.min(w - 4, 12 + 12 + WINS.length * (COL_W + 2))))}`,
+  );
+
+  const PILLARS = [
+    { key: "input", label: "Input" },
+    { key: "output", label: "Output" },
+    { key: "cacheWrite", label: "CacheW", dbKey: "cacheCreate" },
+    { key: "cacheRead", label: "CacheR" },
+  ];
+
+  // Reserve space for cascade metrics below (~8 lines)
+  const metricsLines = 6 + SOURCES.length;
+  for (const src of SOURCES) {
+    let firstRow = true;
+    for (const pil of PILLARS) {
+      if (used >= budget - metricsLines) break;
+      const dbKey = pil.dbKey ?? pil.key;
+      const cells = WINS.map((win) => {
+        const p = src.pillars[win];
+        const val = p?.[dbKey] ?? null;
+        if (val == null) return padStart(dim("—"), COL_W);
+        const baseVal = tpPillars[win]?.[dbKey];
+        if (src.name !== "tokenpull" && baseVal != null && baseVal > 0) {
+          const delta = ((val - baseVal) / baseVal) * 100;
+          const dStr =
+            delta === 0
+              ? ""
+              : delta > 0
+                ? green(` +${delta.toFixed(0)}%`)
+                : red(` ${delta.toFixed(0)}%`);
+          return padStart(`${fmtTok(val)}${dStr}`, COL_W);
+        }
+        return padStart(fmtTok(val), COL_W);
+      });
+      const srcLabel = firstRow
+        ? padEnd(src.color(src.name), 12)
+        : padEnd(dim(""), 12);
+      emit(
+        `    ${srcLabel}  ${padEnd(dim(pil.label), 10)}  ${cells.join("  ")}`,
+      );
+      firstRow = false;
+    }
+    emit();
+  }
+
+  // Fill the dead-space between the source table and cascade metrics with a
+  // log-scale Υ Yield comparison bar — owner wants more mini-graphs, and this
+  // gap was flagged as dead-space by the audit.
+  if (used < budget - 6 && SOURCES.length > 0) {
+    const yields = SOURCES.map((s) => {
+      const p = s.pillars["all"];
+      const cas = p ? cascadeFrom(p) : null;
+      return { name: s.name, color: s.color, yield: cas?.yield ?? 0 };
+    }).filter((y) => y.yield > 0);
+    if (yields.length > 0) {
+      const maxYield = Math.max(...yields.map((y) => y.yield));
+      const maxLog = Math.log10(maxYield) || 1;
+      const barW = Math.min(Math.max(w - 40, 15), 30);
+      emit(`  ${dim("Υ Yield comparison (log scale)")}`);
+      for (const y of yields) {
+        const { bar } = logBar(y.yield, maxLog, barW, c.cyan);
+        emit(`  ${padEnd(y.color(y.name), 12)} ${bar} ${fmtY(y.yield)}`);
+      }
+      emit();
+    }
+  }
+
+  if (used < budget - 4) {
+    emit(`  ${hr()}`);
+    emit(
+      `  ${bold("Cascade Metrics")}  ${dim("all-time · computed from each source")}`,
+    );
+    const MCH = [
+      padEnd(hdr("Source"), 12),
+      padStart(hdr("Υ Yield"), 9),
+      padStart(hdr("SNR"), 7),
+      padStart(hdr("Lev"), 8),
+      padStart(hdr("Vel"), 6),
+      padStart(hdr("10x"), 6),
+      padEnd(hdr("Class"), 13),
+    ];
+    emit(`    ${MCH.join("  ")}`);
+    emit(`  ${dim("·".repeat(Math.min(w - 4, 72)))}`);
+    for (const src of SOURCES) {
+      if (used >= budget) break;
+      const p = src.pillars["all"];
+      if (!p) continue;
+      const cas = cascadeFrom(p);
+      if (!cas) continue;
+      const clsFn = CLS[cas.class] ?? ((s) => s);
+      const cols = [
+        padEnd(src.color(src.name), 12),
+        padStart(
+          cas.yield > 10000 ? gold(fmtY(cas.yield)) : fmtY(cas.yield),
+          9,
+        ),
+        padStart(fmtSNR(cas.snr), 7),
+        padStart(fmtLev(cas.leverage) + "×", 8),
+        padStart(cas.velocity?.toFixed(2) ?? "—", 6),
+        padStart(cas.dev10x?.toFixed(2) ?? "—", 6),
+        padEnd(clsFn(cas.class), 13),
+      ];
+      emit(`    ${cols.join("  ")}`);
+    }
+  }
+}
+
+// ── 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.display_name || 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();
+  // Shorten the header on narrow terminals to avoid overflow.
+  const boardHeader = w < 90
+    ? `window: ${window}  ·  ranked by Υ Yield`
+    : `window: ${window}  ·  all submissions ranked by Υ Yield  ·  signalaf.com`;
+  emit(
+    `  ${bold("Submissions")}  ${dim(boardHeader)}${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);
+
+  // Responsive column hiding — the full table is 106 cols wide. Hide columns
+  // at narrower terminals so rows never overflow/wrap/garble.
+  //   w >= 120: all columns (106 cols fits)
+  //   w < 120:  hide Tokens (saves 11) → 95 cols
+  //   w < 100:  hide Tokens + Class (saves 14) → 81 cols
+  //   w < 90:   hide Tokens + Class + Op Ratio, shorten Codename 20→16 → 61 cols
+  const showTokens = w >= 120;
+  const showClass = w >= 100;
+  const showOpRatio = w >= 90;
+  const nameWidth = w < 90 ? 16 : 20;
+
+  const SH = [
+    padStart(hdr("#"), 4),
+    padEnd(hdr("Codename"), nameWidth),
+    padEnd(hdr("Platform"), 10),
+    padEnd(hdr("Win"), 6),
+    padStart(hdr("Υ Yield"), 9),
+    ...(showOpRatio ? [padEnd(hdr("Op Ratio"), 18)] : []),
+    ...(showClass ? [padEnd(hdr("Class"), 12)] : []),
+    ...(showTokens ? [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), nameWidth);
+    const nm = isYou
+      ? `${c.bgCyan}${c.boldCyan}${padEnd(` ${trunc(gName(e), nameWidth - 2)} `, nameWidth)}${c.reset}`
+      : padEnd(nmRaw, nameWidth);
+    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}` : "";
+    const cells = [
+      padStart(rk, 4),
+      nm,
+      padEnd(platformColor(gPlat(e))(trunc(gPlat(e), 10)), 10),
+      padEnd(dim(trunc(gWin(e), 6)), 6),
+      yld,
+      ...(showOpRatio ? [padEnd(dim(fmtOp(gOpRatio(e))), 18)] : []),
+      ...(showClass ? [cls] : []),
+      ...(showTokens ? [padStart(tk != null ? fmtTok(tk) : "—", 9)] : []),
+    ];
+    emit(`    ${cells.join("  ")}${youMark}`);
+    shown++;
+  }
+  // A3-style: if the height budget dropped rows, say so instead of silently truncating.
+  // SCROLL-VIEW (2026-06-27): changed "resize / scroll" → "resize to see more"
+  // (Board tab doesn't have a real scroll viewport — only Dashboard cascade does).
+  const dropped = sorted.length - shown;
+  if (dropped > 0 && used < budget)
+    emit(`  ${dim(`  +${dropped} more — resize to see more`)}`);
+}
+
+// ── 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;
+  let used = 0;
+  const emit = (s = "") => {
+    if (used < budget) {
+      writeln(s);
+      used++;
+    }
+  };
+
+  const modeLabel = filterCodename
+    ? `${dim(" · just you")}`
+    : highlightCodename
+      ? `${dim(" · you highlighted")}`
+      : "";
+  emit();
+  emit(
+    `  ${bold("Leaderboard")}  ${dim(`window: ${window}  ·  sorted by Υ Yield  ·  signalaf.com/leaderboard`)}${modeLabel}`,
+  );
+  emit();
+
+  if (!Array.isArray(entries) || entries.length === 0) {
+    emit(`  ${dim("  board unavailable")}`);
+    return;
+  }
+
+  // FIX I2: "just me" mode — filter to the signed-in operator's rows only.
+  let sorted = [...entries].sort((a, b) => (b.yield_ ?? 0) - (a.yield_ ?? 0));
+  if (filterCodename) {
+    sorted = sorted.filter(
+      (e) => (e.codename ?? "").toLowerCase() === filterCodename.toLowerCase(),
+    );
+    if (sorted.length === 0) {
+      emit(`  ${dim(`  you have no ranked rows in the ${window} window yet`)}`);
+      emit(`  ${dim("  press [S] from a read tab to submit your cascade")}`);
+      return;
+    }
+  }
+
+  // Per-column top-3 "shadowbox": medal bg-tint (gold/silver/bronze) on the 1st/2nd/3rd
+  // best DISTINCT value in each metric column, mirroring the website's podium boxes.
+  const MEDAL_BG = { 1: 220, 2: 250, 3: 130 }; // gold · silver · bronze (256-color)
+  const top3 = (pick) => {
+    const distinct = [
+      ...new Set(sorted.map(pick).filter((v) => v != null && isFinite(v))),
+    ].sort((a, b) => b - a);
+    const m = new Map();
+    distinct.slice(0, 3).forEach((v, i) => m.set(v, i + 1));
+    return m;
+  };
+  const pods = {
+    yield: top3((e) => e.yield_),
+    snr: top3((e) => e.snr ?? e.compression_ratio),
+    lev: top3((e) => e.leverage),
+    vel: top3((e) => e.velocity),
+    d10: top3((e) => e.dev10x),
+  };
+  // Wrap a padded cell in a medal bg-tint (dark fg on the medal color) when its value places top-3.
+  // Theme-aware: monochrome uses bold instead of color backgrounds.
+  const medal = (map, val, padded) => {
+    const place = val == null ? null : map.get(val);
+    if (!place) return padded;
+    const bgCode = c.medalBg?.[place];
+    if (bgCode != null) {
+      return `${ESC}48;5;${bgCode}m${c.medalFg}${padded}${c.reset}`;
+    }
+    // Monochrome / no medal bg — use bold
+    return `${c.bold}${padded}${c.reset}`;
+  };
+
+  const BH = [
+    padStart(hdr("#"), 4),
+    padEnd(hdr("Codename"), 22),
+    padEnd(hdr("Class"), 13),
+    padStart(hdr("Υ Yield"), 9),
+    padStart(hdr("SNR"), 7),
+    padStart(hdr("Lev"), 7),
+    padStart(hdr("Vel"), 6),
+    padStart(hdr("10x"), 6),
+    padStart(hdr("Pct"), 5),
+    padStart(hdr("7d↕"), 5),
+  ];
+  emit(`    ${BH.join("  ")}`);
+  emit(`  ${dim("·".repeat(Math.min(w - 4, 98)))}`);
+
+  for (let idx = 0; idx < sorted.length; idx++) {
+    if (used >= budget) break;
+    const e = sorted[idx];
+    // FIX I2: highlight the signed-in operator's row (global mode) with a cyan bg-tint.
+    const isYou =
+      highlightCodename &&
+      (e.codename ?? "").toLowerCase() === highlightCodename.toLowerCase();
+    const rk =
+      idx === 0
+        ? gold(`#${idx + 1}`)
+        : idx < 3
+          ? cyan(`#${idx + 1}`)
+          : `#${idx + 1}`;
+    const nmRaw = trunc(e.display_name || e.codename || "—", 22);
+    // FIX I2: pad the visible content INSIDE the ANSI codes so the cyan bg fills
+    // the full column width (padEnd after reset would leave uncolored trailing spaces).
+    const nm = isYou
+      ? `${c.bgCyan}${c.boldCyan}${padEnd(` ${nmRaw} `, 22)}${c.reset}`
+      : padEnd(nmRaw, 22);
+    const cls = padEnd(colorCls(e.class_tier ?? "—"), 13);
+    const snrVal = e.snr ?? e.compression_ratio;
+    // value cells: pad first, then medal-wrap so the tint fills the whole column width
+    const yld = medal(
+      pods.yield,
+      e.yield_,
+      padStart(e.yield_ != null ? fmtY(e.yield_) : "—", 9),
+    );
+    const snr = medal(
+      pods.snr,
+      snrVal,
+      padStart(snrVal != null ? fmtSNR(snrVal) : "—", 7),
+    );
+    const lev = medal(
+      pods.lev,
+      e.leverage,
+      padStart(e.leverage != null ? fmtLev(e.leverage) + "×" : "—", 7),
+    );
+    const vel = medal(
+      pods.vel,
+      e.velocity,
+      padStart(e.velocity != null ? e.velocity.toFixed(2) : "—", 6),
+    );
+    const d10 = medal(
+      pods.d10,
+      e.dev10x,
+      padStart(e.dev10x != null ? e.dev10x.toFixed(2) : "—", 6),
+    );
+    const pct = padStart(e.percentile != null ? `${e.percentile}%` : "—", 5);
+    const mv = padStart(fmtMov(e.movement_7d), 5);
+    const youMark = isYou ? ` ${c.bgCyan}${c.boldCyan}YOU${c.reset}` : "";
+    emit(
+      `    ${padStart(rk, 4)}  ${nm}  ${cls}  ${yld}  ${snr}  ${lev}  ${vel}  ${d10}  ${pct}  ${mv}${youMark}`,
+    );
+  }
+}
+
+// ── TAB 4: WATCH — landing panel (instructions + why it matters) ─────────────
+// 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";
+  const platColorFn = (!platform || platform === "all") ? cyan : platformColor(platform);
+  writeln();
+  writeln(
+    `  ${bold("Live Watch")}  ${dim("the agent that keeps your rank current")}`,
+  );
+  writeln();
+  writeln(`  ${dim("What it does")}`);
+  writeln(
+    `    Re-reads your local token logs for ${platColorFn(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`,
+  );
+  writeln(
+    `    verified cascade so ${cyan("signalaf.com/leaderboard")} ${bold("auto-updates")} as you work —`,
+  );
+  writeln(
+    `    no manual re-submit. Tokens never leave your machine; only the metrics post.`,
+  );
+  writeln();
+  writeln(`  ${dim("Settings")}`);
+  writeln(
+    `    ${dim("Platform")}  ${platColorFn(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 focus   ${dim("[W]")} window focus`,
+  );
+  writeln();
+}
+
+// ── TAB 6: CONNECT ───────────────────────────────────────────────────────────
+// Sign in (paste a connect code) / show signed-in status. The whole app lives in
+// the TUI; this replaces every "go run the CLI to enroll" hint. Uses only helpers
+// already defined above (bold/dim/cyan/green/red/hr/writeln).
+function renderConnect(id, codeBuf = "", msg = "") {
+  writeln();
+  if (isSignedIn(id)) {
+    writeln(`  ${bold("Connect")}  ${dim("your account")}`);
+    writeln(`  ${hr()}`);
+    writeln(`  ${green("✓")} Signed in as ${cyan(id.codename)}`);
+    writeln(`  ${dim(`device ${id.device_id}`)}`);
+    writeln();
+    writeln(
+      `  ${dim("Press")} ${bold("[S]")} ${dim("from any read tab to submit your runs to the board.")}`,
+    );
+    writeln();
+    writeln(
+      `  ${dim(W() < 90 ? 'Need a new key? signalaf.com → Settings → "New key", then paste here.' : 'Need a new key? Click "New key" at signalaf.com → Settings, then paste it here.')}`,
+    );
+    // Wrap the sign-out help across 2 lines on narrow terminals (the full
+    // sentence is 108 cols — overflows 100-col terminals by 8).
+    if (W() >= 110) {
+      writeln(
+        `  ${dim("Signed in on the wrong device, or want a fresh start?")} ${bold("[X]")} ${dim("signs out — next paste provisions a fresh device.")}`,
+      );
+    } else {
+      writeln(
+        `  ${dim("Signed in on the wrong device, or want a fresh start?")}`,
+      );
+      writeln(
+        `  ${bold("[X]")} ${dim("signs out — next paste provisions a fresh device.")}`,
+      );
+    }
+  } else {
+    writeln(`  ${bold("Log in to submit to board")}`);
+    writeln(`  ${hr()}`);
+    writeln(`  ${dim("status:")} ${red("not signed in")}`);
+    writeln();
+    writeln(`  ${dim("Paste your key, then")} ${bold("[Enter]")}${dim(":")}`);
+  }
+  writeln(`    ${cyan(">")} ${codeBuf}${dim("▏")}`);
+  writeln();
+  writeln(
+    `  ${dim('Get a key at signalaf.com → Settings → "New key" (or "Generate connect code").')}`,
+  );
+  if (msg) {
+    writeln();
+    writeln(`  ${msg}`);
+  }
+}
+
+// ── 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).
+// Load Watch data once — scan all candidate platforms for active sessions.
+// Separated from rendering (renderWatchData) so the headless audit can load
+// once and render across many sizes/themes without re-scanning the filesystem
+// each frame (each full scan is ~8s across 16 platforms; 16 frames × 8s would
+// be ~130s of pure re-scan otherwise). Mirrors how Dashboard/Compare/Board
+// already separate load from render.
+async function loadWatchData(platform = "all", win = "all-windows") {
+  // ../tokenpull.mjs — this file lives in presentation/, so "./tokenpull.mjs" resolved
+  // to presentation/tokenpull.mjs (nonexistent) and threw ERR_MODULE_NOT_FOUND for
+  // every row. Matches the static `../tokenpull.mjs` import at the top of this file.
+  const { tokenpullAny } = await import("../tokenpull.mjs");
+  const ALL_PLATFORMS = [
+    "claude",
+    "codex",
+    "amp",
+    "gemini",
+    "kimi",
+    "qwen",
+    "goose",
+    "kilo",
+    "hermes",
+    "droid",
+    "codebuff",
+    "copilot",
+    "openclaw",
+    "pi",
+    "omp",
+    "proxy",
+  ];
+  const platFilter = platform && platform !== "all" ? platform : null;
+  const winFilter = win && win !== "all-windows" ? win : null;
+  // 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);
+  }
+  // stable display order
+  active.sort(
+    (a, b) =>
+      ALL_PLATFORMS.indexOf(a.platform) - ALL_PLATFORMS.indexOf(b.platform),
+  );
+  return { active, platFilter, winFilter };
+}
+
+// Render the Watch tab from pre-loaded data. Sync — no scanning, safe to call
+// once per terminal size/theme in the audit.
+function renderWatchData(data) {
+  const { active, platFilter, winFilter } = data;
+  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++;
+    }
+  };
+
+  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)))}`);
+
+  if (active.length === 0) {
+    emit();
+    for (const ln of wrapDim(
+      "no active platforms detected — run some sessions, this picks them up automatically",
+    ))
+      emit(ln);
+    return;
+  }
+
+  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}`,
+      );
+    }
+  }
+}
+
+// Convenience: scan + render in one call (used by --render and --record, which
+// only render once). The audit uses loadWatchData + renderWatchData separately
+// to avoid re-scanning across its 16 frames.
+async function renderWatch(platform = "all", win = "all-windows") {
+  renderWatchData(await loadWatchData(platform, win));
+}
+
+// ── SUBMIT PREVIEW (FIX I1 / FIX E) — see→confirm→send ───────────────────────
+// Renders a platform × window grid of what submit_verified WOULD send, using the
+// already-loaded dashData. [Enter] confirms → fires submit_verified per platform;
+// [Esc] cancels → back to the read tab. Mirrors the Connect focused-field pattern.
+function renderSubmitPreview(dashData, id) {
+  const budget = H() - 4;
+  let used = 0;
+  const emit = (s = "") => {
+    if (used < budget) {
+      writeln(s);
+      used++;
+    }
+  };
+  const WINS = ["7d", "30d", "90d", "all"];
+  const COL_W = 14;
+
+  emit();
+  emit(`  ${bold("Submit Preview")}  ${dim("what will publish to the board")}`);
+  emit(
+    `  ${dim(`signed in as ${id?.codename ?? "—"} · device ${id?.device_id?.slice(0, 8) ?? "—"}…`)}`,
+  );
+  emit();
+  // header row: platform | 7d | 30d | 90d | all
+  const hcols = [
+    padEnd(hdr("Platform"), 12),
+    ...WINS.map((w) => padStart(hdr(w), COL_W)),
+  ];
+  emit(`    ${hcols.join("  ")}`);
+  emit(
+    `  ${dim("·".repeat(Math.min(W() - 4, 12 + WINS.length * (COL_W + 2))))}`,
+  );
+
+  const active = dashData?.active ?? [];
+  for (const d of active) {
+    if (used >= budget - 3) break;
+    const cells = WINS.map((w) => {
+      const wd = d.windows?.find((x) => x.window === w);
+      if (!wd || wd.pillars.input + wd.pillars.output === 0)
+        return padStart(dim("—"), COL_W);
+      const cas = cascadeFrom(wd.pillars);
+      if (!cas) return padStart(dim("—"), COL_W);
+      return padStart(gold(fmtY(cas.yield)), COL_W);
+    });
+    emit(`    ${padEnd(cyan(d.platform), 12)}  ${cells.join("  ")}`);
+  }
+  if (active.length === 0) {
+    emit(`  ${dim("  no platforms with data — press [R] to refresh")}`);
+  }
+  emit();
+  emit(
+    `  ${dim("[Enter]")} confirm + submit all platforms   ${dim("[Esc]")} cancel`,
+  );
+}
+
+// ── DEBUG: render a tab once (no TTY/alt-screen) + audit each line's visible
+// width vs terminal columns. Usage: `node tui.mjs --render [0-5]`. Tab indices
+// match the live TABS array: 0=Dashboard, 1=Trends, 2=Compare, 3=Board,
+// 4=Watch, 5=Connect. Prints a width report (>w = would overflow/wrap) then
+// the raw frame. For diagnosing layout overflow without an interactive session.
+async function renderOnce(tabIdx = 0) {
+  const w = W();
+  const data = {
+    0: await loadDashboardData().catch((e) => ({ error: e.message })),
+    1: await loadDashboardData().catch((e) => ({ error: e.message })),
+    2: await loadCompareData("claude").catch(() => null),
+    3: await loadBoardData("30d").catch(() => null),
+  }[tabIdx];
+  startBuffer();
+  if (tabIdx === 0) renderDashboard(data, "debug");
+  else if (tabIdx === 1) renderTrends(data, 0);
+  else if (tabIdx === 2) renderCompare(data);
+  else if (tabIdx === 3) 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;
+  process.stdout.write(
+    `\n=== WIDTH AUDIT (terminal w=${w}) — lines exceeding w wrap/overflow ===\n`,
+  );
+  lines.forEach((ln, i) => {
+    const vis = stripAnsi(ln).length;
+    if (vis > w)
+      process.stdout.write(
+        `  OVERFLOW line ${i}: visible=${vis} (>${w} by ${vis - w})  «${stripAnsi(ln).slice(0, 60)}…»\n`,
+      );
+  });
+  const maxVis = Math.max(0, ...lines.map((l) => stripAnsi(l).length));
+  process.stdout.write(
+    `  widest visible line = ${maxVis} (terminal w=${w}) → ${maxVis > w ? "OVERFLOWS" : "fits"}\n`,
+  );
+  process.stdout.write(`\n=== RAW FRAME (stripAnsi) ===\n`);
+  lines.forEach((ln) => process.stdout.write(stripAnsi(ln) + "\n"));
+}
+
+// ── OPENING SPLASH ───────────────────────────────────────────────────────────
+// Block-letter SIGRANK wordmark that flashes through colors CONTINUOUSLY until a
+// key is pressed (owner 2026-06-25: "keep the animation going"). Randomizes the
+// mode each launch (moses gold-shimmer / rainbow / chaos per-letter). Centered to
+// terminal width. Any key dismisses → the dashboard loads.
+const SPLASH_ART = [
+  "███████ ██  ██████  ██████   █████  ███    ██ ██   ██",
+  "██      ██ ██       ██   ██ ██   ██ ████   ██ ██  ██ ",
+  "███████ ██ ██   ███ ██████  ███████ ██ ██  ██ █████  ",
+  "     ██ ██ ██    ██ ██   ██ ██   ██ ██  ██ ██ ██  ██ ",
+  "███████ ██  ██████  ██   ██ ██   ██ ██   ████ ██   ██",
+];
+const SPLASH_RULE = "◈  ───────────────────────────────────────────  ◈";
+const MOSES_PAL = [220, 178, 214, 208, 222, 230];
+const RAINBOW_PAL = [196, 202, 226, 46, 51, 21, 201, 213];
+const col256 = (n, s) => `${ESC}38;5;${n}m${s}${c.reset}`;
+const stripA = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+const ctr = (s) => {
+  const pad = Math.max(0, Math.floor((W() - stripA(s).length) / 2));
+  return " ".repeat(pad) + s;
+};
+
+function splashFrame(mode) {
+  const pick = (a) => a[Math.floor(Math.random() * a.length)];
+  const out = ["", "", ctr(dim(SPLASH_RULE)), ""];
+  for (const line of SPLASH_ART) {
+    if (mode === "chaos") {
+      out.push(
+        ctr(
+          [...line]
+            .map((ch) =>
+              ch === " " ? " " : col256(Math.floor(Math.random() * 256), ch),
+            )
+            .join(""),
+        ),
+      );
+    } else {
+      const n = mode === "rainbow" ? pick(RAINBOW_PAL) : pick(MOSES_PAL);
+      out.push(ctr(col256(n, line)));
+    }
+  }
+  out.push("", ctr(dim(SPLASH_RULE)), "");
+  out.push(ctr(bold("For all builders, burners and 10xers")));
+  out.push(ctr(dim("signalaf")), "");
+  out.push(ctr(`${dim("powered by")}  ${gold("MO§ES™")}`));
+  out.push(ctr(dim("$ npx sigrank")), "");
+  out.push(ctr(`${gold("▸")} ${dim("press any key")} ${gold("◂")}`));
+  return out.join("\n");
+}
+
+// Animated splash. Controls: [P] pause/resume the color animation · [Enter] (or
+// any other key) enter the TUI · Ctrl-C quit. Mode (moses/rainbow/chaos) varies
+// per launch. Frozen frame keeps the last colors so a pause reads as intentional.
+function showSplash() {
+  const modes = ["moses", "rainbow", "chaos"];
+  const mode = modes[Math.floor((Date.now() / 1000) % modes.length)];
+  return new Promise((resolve) => {
+    let paused = false;
+    const interactive = !!process.stdin.isTTY; // can we read raw keypresses to dismiss?
+    const hint = () =>
+      interactive
+        ? `${dim("  [P]")} ${paused ? "resume" : "pause"}    ${dim("[Enter]")} enter`
+        : dim("  loading…");
+    // FIXED-WINDOW FIX (2026-06-27): paint the splash via the buffered flushScreen
+    // path (GOTO positioning), NOT raw write('\n'). Raw \n scrolls the alt-screen
+    // buffer, creating scrollback above the TUI — that's why you could scroll up
+    // to see what was above it. flushScreen uses absolute cursor positioning so
+    // nothing ever scrolls the buffer. This matches how tokscale renders its frame.
+    const paint = () => {
+      startBuffer();
+      const lines = splashFrame(mode).split("\n");
+      lines.forEach((ln) => writeln(ln));
+      writeln(ctr(hint()));
+      setFooter([]);
+      flushScreen();
+    };
+    paint();
+    let timer = setInterval(paint, 110);
+
+    // Non-interactive stdin (some IDE/integrated terminals): still SHOW the animated
+    // wordmark, but auto-advance after a short run instead of waiting for a key (which
+    // would never arrive → hang). ~2.2s of animation, then enter the TUI.
+    if (!interactive) {
+      setTimeout(() => {
+        clearInterval(timer);
+        write(CLEAR);
+        resolve();
+      }, 2200);
+      return;
+    }
+
+    process.stdin.setRawMode?.(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    const onKey = (key) => {
+      const k = key.toLowerCase();
+      if (k === "p") {
+        // toggle pause — don't enter
+        paused = !paused;
+        if (paused) {
+          clearInterval(timer);
+          timer = null;
+          paint();
+        } // freeze on current frame
+        else {
+          timer = setInterval(paint, 110);
+        } // resume animating
+        return;
+      }
+      if (timer) clearInterval(timer);
+      process.stdin.removeListener("data", onKey);
+      if (key === "\x03") {
+        write(SHOW);
+        write(EXIT_ALT);
+        process.exit(0);
+      } // Ctrl-C
+      resolve(); // Enter / any other key → enter the TUI
+    };
+    process.stdin.on("data", onKey);
+  });
+}
+
+// ── MAIN TUI LOOP ─────────────────────────────────────────────────────────────
+export async function runTui({
+  platform: initPlatform = "claude",
+  window: win = "7d",
+} = {}) {
+  // Theme selection — --theme <name> sets the color palette (dark/light/high-contrast/monochrome)
+  const themeIdx = process.argv.indexOf("--theme");
+  if (themeIdx !== -1 && process.argv[themeIdx + 1]) {
+    setTheme(process.argv[themeIdx + 1]);
+  }
+
+  // FIX J: platform is mutable — [P] cycles it on Compare + Watch tabs. Was a const
+  // param (permanently locked to 'claude'); now a let so the user can switch + [S]
+  // submits the selected platform (needed for Phase 4 multi-platform submit).
+  let platform = initPlatform;
+  // Debug render mode — non-interactive, dumps a tab + width audit, then exits.
+  const ri = process.argv.indexOf("--render");
+  if (ri !== -1) {
+    const tab = parseInt(process.argv[ri + 1] ?? "0", 10) || 0;
+    await renderOnce(tab);
+    return;
+  }
+
+  // Audit mode — headless review of every tab × every terminal size. Checks
+  // overflow, truncation, dead space, budget, color health, sparkline integrity,
+  // responsive design, visual weight. Supports golden frame snapshots
+  // (--golden-save / --golden-check), SVG export (--svg), and CI mode (--ci
+  // exits non-zero on HIGH severity issues).
+  const ai = process.argv.indexOf("--audit");
+  if (ai !== -1) {
+    let runAudit, formatAuditReport;
+    try {
+      ({ runAudit, formatAuditReport } = await import("../dev/tui-audit.mjs"));
+    } catch {
+      console.error("--audit is a development tool, not available in the npm package.");
+      console.error("Clone the repo to use it: https://github.com/SunrisesIllNeverSee/sigrank-mcp");
+      process.exit(1);
+    }
+    const auditData = await runAudit({
+      goldenSave: process.argv.includes("--golden-save"),
+      goldenCheck: process.argv.includes("--golden-check"),
+      svg: process.argv.includes("--svg"),
+      png: process.argv.includes("--png"),
+      ci: process.argv.includes("--ci"),
+    });
+    process.stdout.write(formatAuditReport(auditData) + "\n");
+    // Always exit in audit mode — a data load that timed out may still have a
+    // pending background promise (network fetch / local scan) that would keep
+    // the event loop alive after runTui returns. The audit is headless and must
+    // terminate; unconditional exit guarantees that regardless of ciExitCode.
+    process.exit(auditData.ciExitCode);
+  }
+
+  // Record mode — capture a TUI session as an animated GIF (headless, no TTY needed)
+  const recIdx = process.argv.indexOf("--record");
+  if (recIdx !== -1) {
+    let recordCli;
+    try {
+      ({ recordCli } = await import("../dev/tui-record.mjs"));
+    } catch {
+      console.error("--record is a development tool, not available in the npm package.");
+      console.error("Clone the repo to use it: https://github.com/SunrisesIllNeverSee/sigrank-mcp");
+      process.exit(1);
+    }
+    await recordCli(process.argv);
+    return;
+  }
+
+  write(ENTER_ALT); // switch to alternate screen — original terminal state preserved on exit
+  write(CLEAR_SB); // FIXED-WINDOW (2026-06-27): clear scrollback so nothing is above the TUI
+  write(HIDE);
+  write(CLEAR);
+
+  // Opening splash — animated SIGRANK wordmark.
+  // Gate on stdOUT.isTTY (can we draw the animation?), matching the launch guard —
+  // NOT stdin.isTTY, which was skipping the splash in terminals whose input isn't a
+  // raw TTY (some IDE/integrated terminals). showSplash() itself auto-advances when
+  // stdin can't be read raw, so it never hangs. (Skippable with --no-splash.)
+  if (!process.argv.includes("--no-splash") && process.stdout.isTTY) {
+    await showSplash();
+    write(CLEAR);
+  }
+
+  // ── State
+  let activeTab = 0;
+  let dashData = null;
+  let compareData = null;
+  let boardData = null;
+  let boardWindow = "30d";
+  // 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;
+  let status = "loading…";
+  let refreshTimer = null;
+  let codeBuf = ""; // [6] Connect tab in-place code field buffer
+  let connectMsg = ""; // [6] Connect last-action message (signed in / invalid code)
+  let submitMsg = ""; // [S] in-place submit result, shown in the read-tab footer
+  let submitPreview = false; // FIX I1: [S] opens a preview grid before sending (see→confirm→send)
+  let boardYouOnly = false; // FIX I2: [Y] toggles the Board to "just me" (hybrid model)
+  let cascadeScroll = 0; // SCROLL-VIEW (2026-06-27): cascade-section scroll offset (Dashboard only)
+  let ompEnabled = false; // Session-only Dashboard toggle; deliberately OFF on every launch.
+
+  // ── Redraw (buffered: renders into memory, then paints as a locked frame)
+  const redraw = async () => {
+    startBuffer();
+    renderTabBar(activeTab);
+
+    const hint = `  ${dim("← → or 1-6")} switch tabs   ${dim("[R]")} refresh   ${dim("[Q]")} quit`;
+    const submitHint = `   ${dim("[S]")} submit to board · ${dim("[C]")} sign in`;
+    // Read-tab footer: hr + hint, plus the in-place submit result line when present.
+    const readFooter = (hintLine) =>
+      submitMsg
+        ? [`  ${hr()}`, hintLine, `  ${submitMsg}`]
+        : [`  ${hr()}`, hintLine];
+
+    // FIX I1: submit preview is a focused overlay — renders INSTEAD of the tab
+    // content, with its own footer. [Enter] sends, [Esc] cancels.
+    if (submitPreview) {
+      renderSubmitPreview(dashData, loadIdentity());
+      setFooter([
+        `  ${hr()}`,
+        `  ${dim("[Enter]")} submit all platforms   ${dim("[Esc]")} cancel   ${dim("[Q]")} quit`,
+      ]);
+      flushScreen();
+      return;
+    }
+
+    if (activeTab === 0) {
+      // Dashboard
+      if (!dashData) {
+        writeln(`\n  ${dim("loading dashboard…")}`);
+      } else {
+        renderDashboard(dashData, status, cascadeScroll);
+      }
+      // SCROLL-VIEW: show ↑↓ hint only when there are cascade rows to scroll
+      const scrollHint =
+        dashData && Array.isArray(dashData.active)
+          ? cascadeScrollableCount(dashData.active) >
+            maxCascadeRowsFor(dashData.active)
+            ? `   ${dim("↑↓ scroll cascade")}`
+            : ""
+          : "";
+      const ompHint = !dashData?._ompAvailable
+        ? ""
+        : dashData._ompLoading
+          ? `   ${dim(ompEnabled ? "omp: on · scanning…" : "omp: off · finishing scan…")}`
+          : `   ${dim("[O]")} omp: ${ompEnabled ? "on" : "off"}`;
+      setFooter(readFooter(`${hint}${scrollHint}${ompHint}${submitHint}`));
+    } else if (activeTab === 1) {
+      // Trends
+      if (!dashData) {
+        writeln(`\n  ${dim("loading trends…")}`);
+      } else {
+        renderTrends(dashData, trendSub);
+      }
+      setFooter(readFooter(`${hint}   ${dim("[T]")} view${submitHint}`));
+    } else if (activeTab === 2) {
+      // Compare
+      if (!compareData) {
+        // #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);
+      }
+      setFooter(
+        readFooter(`${hint}   ${dim("[P]")} switch platform${submitHint}`),
+      );
+    } else if (activeTab === 3) {
+      // Board
+      if (!boardData) {
+        writeln(`\n  ${dim(`loading board (${boardWindow})…`)}`);
+      } else {
+        // FIX I2: hybrid board model — global board + your row highlighted, [Y]
+        // toggles "just me" (your placements only). Pass the signed-in codename so
+        // renderBoard can highlight/filter.
+        const id = loadIdentity();
+        renderBoard(
+          boardData,
+          boardWindow,
+          boardYouOnly ? id?.codename : null,
+          id?.codename ?? null,
+        );
+      }
+      const youHint = isSignedIn(loadIdentity())
+        ? `   ${dim("[Y]")} ${boardYouOnly ? "all" : "just me"}`
+        : "";
+      setFooter(
+        readFooter(`${hint}   ${dim("[W]")} window${youHint}${submitHint}`),
+      );
+    } else if (activeTab === 4) {
+      // Watch
+      renderWatchInfo(watchPlatform, watchWindow, watchRefresh);
+      setFooter(readFooter(`${hint}${submitHint}`));
+    } else if (activeTab === 5) {
+      // Connect
+      const connectId = loadIdentity();
+      renderConnect(connectId, codeBuf, connectMsg);
+      const signOutHint = isSignedIn(connectId)
+        ? `   ${dim("[X]")} sign out`
+        : "   " + dim("[X]") + " reset device";
+      setFooter([
+        `  ${hr()}`,
+        `  ${dim("[Enter]")} sign in   ${dim("[Esc]")} clear/back${signOutHint}   ${dim("← →")} tabs   ${dim("[Q]")} quit`,
+      ]);
+    }
+    flushScreen();
+  };
+
+  // ── Initial data load
+  const loadAll = async () => {
+    // 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).
+    // Animated signal pulse during initial load — shows the system is alive.
+    const INIT_PULSE = [
+      "▁▁▁▁▁", "▂▁▁▁▁", "▃▂▁▁▁", "▄▃▂▁▁", "▅▄▃▂▁",
+      "▆▅▄▃▂", "▇▆▅▄▃", "█▇▆▅▄", "▇█▇▆▅", "▆▇█▇▆",
+      "▅▆▇█▇", "▄▅▆▇█", "▃▄▅▆▇", "▂▃▄▅▆", "▁▂▃▄▅",
+      "▁▁▂▃▄", "▁▁▁▂▃", "▁▁▁▁▂",
+    ];
+    const initStart = Date.now();
+    let initIdx = 0;
+    const initTimer = setInterval(() => {
+      const elapsed = ((Date.now() - initStart) / 1000).toFixed(1);
+      const pulse = INIT_PULSE[initIdx % INIT_PULSE.length];
+      initIdx++;
+      status = `${gold(pulse)} reading your cascade… ${bold(`${elapsed}s`)}`;
+      redraw();
+    }, 150);
+    status = `${gold("▁▁▁▁▁")} reading your cascade…`;
+    dashData = { active: [], _loading: true };
+    await redraw();
+    // FIX 0: progressive Dashboard load — claude first (fast), render it, THEN fill
+    // the remaining ALL_PLATFORMS entries in the background + redraw. The user sees their cascade
+    // within ~1 read instead of a 7s blank "loading dashboard…".
+    dashData = await loadDashboardData({ includeOmp: ompEnabled }).catch((e) => {
+      status = `dashboard error: ${e.message}`;
+      return null;
+    });
+    clearInterval(initTimer);
+    status = `last refreshed ${new Date().toLocaleTimeString("en-US", { hour12: false })}`;
+    await redraw();
+    // 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) {
+      status = "claude ready · filling other platforms…";
+      await redraw();
+    }
+    // Animated signal pulse while the platform fill runs — shows the system
+    // is alive, not frozen. Uses a rotating signal-bar animation + elapsed timer.
+    const PULSE_FRAMES = [
+      "▁▁▁▁▁",
+      "▂▁▁▁▁",
+      "▃▂▁▁▁",
+      "▄▃▂▁▁",
+      "▅▄▃▂▁",
+      "▆▅▄▃▂",
+      "▇▆▅▄▃",
+      "█▇▆▅▄",
+      "▇█▇▆▅",
+      "▆▇█▇▆",
+      "▅▆▇█▇",
+      "▄▅▆▇█",
+      "▃▄▅▆▇",
+      "▂▃▄▅▆",
+      "▁▂▃▄▅",
+      "▁▁▂▃▄",
+      "▁▁▁▂▃",
+      "▁▁▁▁▂",
+    ];
+    const fillStart = Date.now();
+    let pulseIdx = 0;
+    const pulseTimer = setInterval(() => {
+      if (!dashData?._loading) return;
+      const elapsed = ((Date.now() - fillStart) / 1000).toFixed(1);
+      const pulse = PULSE_FRAMES[pulseIdx % PULSE_FRAMES.length];
+      pulseIdx++;
+      const platCount = dashData.active.length;
+      status = `${gold(pulse)} scanning platforms… ${bold(`${elapsed}s`)} ${dim(`· ${platCount} found`)}`;
+      redraw();
+    }, 150);
+    [, boardData] = await Promise.all([
+      dashData?._remaining
+        ? fillDashboardRest(dashData, {
+            shouldLoadPlatform: (platform) =>
+              platform !== "omp" || ompEnabled,
+            onPlatformStarted: async (platform) => {
+              if (platform !== "omp") return;
+              dashData._ompLoading = true;
+              status =
+                "omp is on · scanning history… large histories may take tens of seconds";
+              await redraw();
+            },
+            onPlatformLoaded: async (platform, result) => {
+              if (platform === "omp") {
+                dashData._ompLoading = false;
+                dashData._ompScanned = result.ok && ompEnabled;
+                if (!ompEnabled) {
+                  dashData.active = dashData.active.filter(
+                    (d) => d.platform !== "omp",
+                  );
+                  status = "omp: off · completed scan result discarded";
+                } else if (!result.ok) {
+                  status = "omp scan failed · switch [O] off, then on to retry";
+                } else if (!result.found) {
+                  status = "omp: on · scan complete · no usage data found";
+                } else {
+                  status = "omp: on · scan complete";
+                }
+              } else {
+                status = dashData._ompLoading
+                  ? `${platform} ready · omp scanning…`
+                  : `claude ready · ${platform} ready · filling other platforms…`;
+              }
+              await redraw();
+            },
+          })
+        : Promise.resolve(false),
+      loadBoardData(boardWindow).catch(() => null),
+    ]);
+    clearInterval(pulseTimer);
+    status = `last refreshed ${new Date().toLocaleTimeString("en-US", { hour12: false })}`;
+    await redraw();
+  };
+
+  // Always restore terminal on unexpected exit
+  const cleanup = () => {
+    write(SHOW);
+    write(EXIT_ALT);
+    process.exit(0);
+  };
+  process.once("SIGINT", cleanup);
+  process.once("SIGTERM", cleanup);
+
+  // FIX 0b: re-render on terminal resize so the frame refits the new dimensions.
+  process.stdout.on("resize", () => {
+    redraw().catch(() => {});
+  });
+
+  // Soft-landing: if not signed in, open on the Connect tab (a prompt, not a gate —
+  // the user can still tab away to read Board/Dashboard while signed out).
+  if (!isSignedIn(loadIdentity())) activeTab = 5;
+
+  // auto-refresh board every 30s
+  const startAutoRefresh = () => {
+    if (refreshTimer) clearInterval(refreshTimer);
+    refreshTimer = setInterval(async () => {
+      if (activeTab === 3) {
+        // Board tab (now index 3)
+        boardData = await loadBoardData(boardWindow).catch(() => null);
+        await redraw();
+      }
+    }, 30000);
+  };
+
+  // Draw the first frame, then load data in the background. Keyboard handling
+  // must be installed before this work completes: pullActivePlatforms() and the
+  // board request can take several seconds, and awaiting them here left a fully
+  // rendered TUI that silently discarded every key (including Ctrl-C in raw
+  // mode) until startup finished.
+  await redraw();
+  const initialLoad = loadAll().catch(async (e) => {
+    status = `dashboard error: ${e.message}`;
+    await redraw();
+  });
+  startAutoRefresh();
+
+  // ── Keyboard
+  if (!process.stdin.isTTY) {
+    await initialLoad;
+    return;
+  }
+
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.setEncoding("utf8");
+
+  // Esc-sequence buffer: some terminals (SSH, tmux, certain emulators) split an
+  // arrow key (\x1b[C) into two data events: \x1b then [C. Without buffering, the
+  // lone \x1b triggers the Esc handler (clearing the code buffer / leaving the tab)
+  // before the [C arrives. We hold \x1b for 25ms; if more bytes follow, we
+  // reassemble and deliver the full sequence. If nothing follows, it's a real Esc.
+  let escBuf = null;
+  let escTimer = null;
+  const ESC_HOLD_MS = 25;
+
+  await new Promise((resolve) => {
+    const handleKey = async (key) => {
+      const k = key.toLowerCase();
+
+      if (k === "q" || k === "\x03") {
+        if (refreshTimer) clearInterval(refreshTimer);
+        // Startup data work may still be in flight now that input is available
+        // immediately. Use the same hard cleanup as SIGINT/SIGTERM so pending
+        // fetch timeouts or platform readers cannot keep the CLI alive or redraw
+        // over the restored terminal after the user quits.
+        cleanup();
+        return;
+      }
+
+      // ── Connect tab is a FOCUSED code field (the one modal tab). Printable code
+      // chars feed the buffer; Enter signs in; Esc clears or leaves; arrows switch.
+      // Sits AFTER the quit block (so Q/Ctrl-C always escape) and BEFORE everything
+      // else (so single-letter hotkeys don't fire while you're typing a code).
+      if (activeTab === 5) {
+        if (key === "\r" || key === "\n") {
+          // [Enter] → sign in
+          const code = codeBuf.trim();
+          if (!code) {
+            connectMsg = dim("paste a connect code first");
+            await redraw();
+            return;
+          }
+          connectMsg = dim("signing in…");
+          await redraw();
+          try {
+            const out = await callTool("enroll", { code });
+            if (out.status === "enrolled") {
+              connectMsg = out.recovered
+                ? `${green("✓")} recovered account: ${cyan(out.codename || "(operator)")} ${dim("(device was already bound)")}`
+                : `${green("✓")} signed in as ${cyan(out.codename || "(operator)")}`;
+              codeBuf = "";
+            } else {
+              const reasons = {
+                code_invalid:
+                  "that code is invalid, expired, or already used — generate a fresh one.",
+                device_already_enrolled:
+                  'this device is already bound. Press [X] to reset the device, then paste a fresh code from signalaf.com → Settings → "New key".',
+                bad_request: "the code or device key was malformed.",
+                rate_limited:
+                  "too many attempts — wait a few minutes and retry.",
+                persistence_unavailable:
+                  "sign-in is temporarily unavailable — try again shortly.",
+              };
+              connectMsg = `${red("✗")} ${reasons[out.reason] || `sign-in failed (${out.reason || "unknown"}).`}`;
+              codeBuf = ""; // auto-clear on failure — the code is consumed/invalid
+            }
+          } catch (e) {
+            connectMsg = `${red("✗")} ${e.message}`;
+            codeBuf = ""; // auto-clear on error too
+          }
+          await redraw();
+          return;
+        }
+        if (key === "\x1b") {
+          // [Esc] → clear, or leave when empty
+          if (codeBuf) {
+            codeBuf = "";
+            connectMsg = "";
+          } else {
+            activeTab = 0;
+          }
+          await redraw();
+          return;
+        }
+        if (key === "\x1b[C") {
+          activeTab = Math.min(5, activeTab + 1);
+          await redraw();
+          return;
+        } // → tab
+        if (key === "\x1b[D") {
+          activeTab = Math.max(0, activeTab - 1);
+          await redraw();
+          return;
+        } // ← tab
+        if (key === "\x7f" || key === "\b") {
+          codeBuf = codeBuf.slice(0, -1);
+          await redraw();
+          return;
+        } // backspace
+        // [X] sign out / reset — only when the code field is empty (so 'x'/'X' typed
+        // mid-code still feeds the buffer — codes can contain X). The auto-clear on
+        // sign-in failure (above) ensures the buffer is empty after a failed attempt,
+        // so X works immediately when the user wants to reset. Drops the local
+        // credential so a server-revoked OR server-enrolled-but-locally-unbound device
+        // stops holding a stale device_id, and the next enroll provisions a fresh
+        // device_id (escapes the Frankenstein-identity / 409-re-enroll deadlock).
+        if (k === "x" && !codeBuf) {
+          const wasSignedIn = isSignedIn(loadIdentity());
+          clearIdentity();
+          codeBuf = "";
+          connectMsg = wasSignedIn
+            ? `${green("✓")} signed out — paste a new code to sign in`
+            : `${green("✓")} device reset — paste a new code to sign in`;
+          await redraw();
+          return;
+        }
+        // A typed code char (len 1) or a pasted code (one multi-char chunk). Exclude any
+        // escape sequence (↑/↓/etc.) so stray control bytes never pollute the buffer.
+        if (!key.startsWith("\x1b") && (key.length > 1 || isCodeChar(key))) {
+          codeBuf += key.split("").filter(isCodeChar).join("");
+          await redraw();
+          return;
+        }
+        return; // swallow any other key while focused (never falls through to global hotkeys)
+      }
+
+      // FIX I1: submit preview is a focused overlay (like Connect). [Enter] sends
+      // all platforms, [Esc] cancels. Intercepts keys BEFORE the tab/ESC handlers.
+      if (submitPreview) {
+        if (key === "\r" || key === "\n") {
+          // [Enter] → confirm + submit all platforms
+          submitPreview = false;
+          submitMsg = dim("submitting…");
+          await redraw();
+          const id = loadIdentity();
+          if (!isSignedIn(id)) {
+            submitMsg = `${red("✗")} sign in to submit`;
+            activeTab = 5;
+            await redraw();
+            return;
+          }
+          // FIX I1: submit every active platform (data already loaded for the Dashboard).
+          // Each platform is a separate submit_verified call → its own (platform, window) slot.
+          const platforms = (dashData?.active ?? []).map((d) => d.platform);
+          let totalVerified = 0,
+            totalReceived = 0,
+            hadFail = false,
+            didMulti = false;
+          for (const p of platforms) {
+            try {
+              const out = await callTool("submit_verified", { platform: p });
+              const ws = out.windows || [];
+              const received = ws.filter((w) => w.status === "received");
+              const verified = received.filter(
+                (w) => w.verification_tier === "verified",
+              );
+              totalReceived += received.length;
+              totalVerified += verified.length;
+              if (received.length > 0 && verified.length < received.length)
+                hadFail = true;
+            } catch {
+              hadFail = true;
+            }
+          }
+          // MULTI: the combined cross-platform cascade (claude+codex+… summed). Only
+          // meaningful with 2+ active platforms; submit_verified('multi') aggregates them.
+          if (platforms.length >= 2) {
+            try {
+              const out = await callTool("submit_verified", {
+                platform: "multi",
+              });
+              const ws = out.windows || [];
+              const received = ws.filter((w) => w.status === "received");
+              const verified = received.filter(
+                (w) => w.verification_tier === "verified",
+              );
+              totalReceived += received.length;
+              totalVerified += verified.length;
+              if (received.length > 0 && verified.length < received.length)
+                hadFail = true;
+              if (received.length > 0) didMulti = true;
+            } catch {
+              hadFail = true;
+            }
+          }
+          if (totalReceived && !hadFail && totalVerified === totalReceived) {
+            submitMsg = `${green("✓")} submitted · ${totalVerified} window${totalVerified > 1 ? "s" : ""} across ${platforms.length} platform${platforms.length > 1 ? "s" : ""}${didMulti ? " + combined" : ""} · verified`;
+          } else if (hadFail && totalReceived) {
+            submitMsg = `${red("✗")} device not verified — sign in again ([C])`;
+          } else if (totalReceived === 0) {
+            submitMsg = `${red("✗")} nothing to submit — no windows with data`;
+          } else {
+            submitMsg = `${red("✗")} submit failed`;
+          }
+          await redraw();
+          return;
+        }
+        if (key === "\x1b") {
+          // [Esc] → cancel
+          submitPreview = false;
+          await redraw();
+          return;
+        }
+        return; // swallow all other keys while the preview is open
+      }
+
+      // Session-only omp toggle. OFF removes the row and excludes omp from later
+      // refreshes; ON scans immediately and includes it until the TUI exits.
+      if (activeTab === 0 && k === "o" && dashData?._ompAvailable) {
+        // A filesystem traversal already in progress cannot be cancelled safely.
+        // Switching OFF marks its result for discard; switching back ON waits
+        // until that traversal finishes so two 10 GiB scans never overlap.
+        if (dashData._ompLoading) {
+          if (ompEnabled) {
+            ompEnabled = false;
+            dashData._ompEnabled = false;
+            status = "omp: off · current scan will be discarded when it finishes";
+          } else {
+            status = "omp: off · waiting for the current scan to finish";
+          }
+          await redraw();
+          return;
+        }
+
+        ompEnabled = !ompEnabled;
+        dashData._ompEnabled = ompEnabled;
+        if (!ompEnabled) {
+          dashData.active = dashData.active.filter((d) => d.platform !== "omp");
+          dashData._ompScanned = false;
+          status = "omp: off · excluded from Dashboard refreshes";
+          await redraw();
+          return;
+        }
+
+        const targetDashData = dashData;
+        targetDashData._ompLoading = true;
+        status =
+          "omp: on · scanning history… large histories may take tens of seconds";
+        await redraw();
+
+        const result = await pullDashboardPlatform(targetDashData, "omp");
+        targetDashData._ompLoading = false;
+        targetDashData._ompScanned = result.ok && ompEnabled;
+
+        if (!ompEnabled) {
+          targetDashData.active = targetDashData.active.filter(
+            (d) => d.platform !== "omp",
+          );
+        }
+
+        // [R] may replace dashData while this scan is running. Do not let the
+        // result or status from that stale Dashboard generation overwrite it.
+        if (dashData !== targetDashData) return;
+        status = !ompEnabled
+          ? "omp: off · completed scan result discarded"
+          : !result.ok
+            ? "omp scan failed · switch [O] off, then on to retry"
+            : result.found
+              ? `omp: on · loaded ${new Date().toLocaleTimeString("en-US", { hour12: false })}`
+              : "omp: on · scan complete · no usage data found";
+        await redraw();
+        return;
+      }
+
+      // ESC → go back to Dashboard from any tab
+      if (key === "\x1b" && activeTab !== 0) {
+        activeTab = 0;
+        await redraw();
+        return;
+      }
+
+      // SCROLL-VIEW (2026-06-27): ↑/↓ (or j/k) scroll the cascade section on the
+      // Dashboard tab ONLY. The rest of the dashboard stays pinned. Only active
+      // when there are more cascade rows than fit in the viewport.
+      if (activeTab === 0 && dashData && Array.isArray(dashData.active)) {
+        const total = cascadeScrollableCount(dashData.active);
+        const maxRows = maxCascadeRowsFor(dashData.active);
+        if (total > maxRows) {
+          const maxOff = total - maxRows;
+          if (key === "\x1b[A" || k === "k") {
+            // ↑ / k → scroll up
+            cascadeScroll = Math.max(0, cascadeScroll - 1);
+            await redraw();
+            return;
+          }
+          if (key === "\x1b[B" || k === "j") {
+            // ↓ / j → scroll down
+            cascadeScroll = Math.min(maxOff, cascadeScroll + 1);
+            await redraw();
+            return;
+          }
+          if (key === "\x1b[5~") {
+            // PageUp → scroll up by viewport
+            cascadeScroll = Math.max(0, cascadeScroll - maxRows);
+            await redraw();
+            return;
+          }
+          if (key === "\x1b[6~") {
+            // PageDown → scroll down by viewport
+            cascadeScroll = Math.min(maxOff, cascadeScroll + maxRows);
+            await redraw();
+            return;
+          }
+        }
+      }
+
+      // tab switching (6 tabs: 0=Dashboard 1=Trends 2=Compare 3=Board 4=Watch 5=Connect)
+      let switched = false;
+      if (key === "\x1b[C") {
+        activeTab = Math.min(5, activeTab + 1);
+        switched = true;
+      }
+      if (key === "\x1b[D") {
+        activeTab = Math.max(0, activeTab - 1);
+        switched = true;
+      }
+      if (k === "1") {
+        activeTab = 0;
+        switched = true;
+      }
+      if (k === "2") {
+        activeTab = 1;
+        switched = true;
+      }
+      if (k === "3") {
+        activeTab = 2;
+        switched = true;
+      }
+      if (k === "4") {
+        activeTab = 3;
+        switched = true;
+      }
+      if (k === "5") {
+        activeTab = 4;
+        switched = true;
+      } // Watch = an in-TUI landing panel
+      if (k === "6") {
+        activeTab = 5;
+        switched = true;
+      } // Connect = sign in / switch device
+      if (k === "c" && activeTab !== 5) {
+        activeTab = 5;
+        switched = true;
+      } // [C] → Connect from any read tab
+
+      // SCROLL-VIEW: reset cascade scroll when leaving the Dashboard tab
+      if (switched && activeTab !== 0) cascadeScroll = 0;
+
+      // #9 (2026-06-27): Compare loads its FRESH verifier pull ON-DEMAND when the tab opens
+      // (NOT on the Dashboard load path — that pull is a 5–60s scan). Paint the "pulling fresh
+      // sources…" spinner first (compareData null → redraw shows it), then run the pull + re-render.
+      // ASYNC FIX (2026-06-27): with execFile (async), the event loop keeps running during the
+      // pull — key presses are NOT blocked. Guard: only render the result if the user is still
+      // on the Compare tab (they may have switched away during the pull).
+      if (switched && activeTab === 2 && !compareData) {
+        submitMsg = "";
+        await redraw(); // show the spinner line before the (slow) fresh pull
+        // Animated spinner with elapsed timer — the fresh verifier pull takes
+        // 5-20s (ccusage CLI scans 1,700+ JSONL files). Without animation the
+        // user sees a frozen "pulling fresh sources…" line and thinks it hung.
+        const SPIN_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+        const BEAR_FRAMES = ["ʕ•ᴥ•ʔ", "ʕ•ᴥ•ʔﾉ", "ʕ•ᴥ•ʔ", "ʕ•ᴥ•ʔﾉ"];
+        const pullStart = Date.now();
+        let spinIdx = 0;
+        const spinTimer = setInterval(() => {
+          if (activeTab !== 2) return; // user switched away — don't repaint
+          const elapsed = ((Date.now() - pullStart) / 1000).toFixed(1);
+          const spin = SPIN_FRAMES[spinIdx % SPIN_FRAMES.length];
+          const bear = BEAR_FRAMES[spinIdx % BEAR_FRAMES.length];
+          spinIdx++;
+          // Repaint just the spinner line in-place (line 4 of the frame)
+          process.stdout.write(
+            GOTO(4, 1) + ERLINE +
+            `  ${gold(spin)} ${dim(`pulling fresh sources…`)} ${bold(`${elapsed}s`)} ${dim(`·`)} ${gold(bear)}`,
+          );
+        }, 200);
+        const result = await loadCompareData(platform).catch(() => null);
+        clearInterval(spinTimer);
+        if (activeTab === 2) {
+          // still on Compare? render the result
+          compareData = result;
+          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;
+      }
+
+      // Watch tab: [+]/[-] tune the refresh interval (5–600s), [Enter] launches the watcher
+      if (activeTab === 4 && (k === "+" || k === "=")) {
+        watchRefresh = Math.min(600, watchRefresh + 5);
+        await redraw();
+        return;
+      }
+      if (activeTab === 4 && (k === "-" || k === "_")) {
+        watchRefresh = Math.max(5, watchRefresh - 5);
+        await redraw();
+        return;
+      }
+
+      // FIX J: [P] cycles platform on Compare + Watch tabs (was a dead hinted key).
+      // Compare reloads compareData for the new platform; Watch just re-renders.
+      const CYCLE_PLATFORMS = [
+        "claude",
+        "codex",
+        "devin",
+        "amp",
+        "gemini",
+        "kimi",
+        "qwen",
+        "goose",
+        "kilo",
+        "hermes",
+        "droid",
+        "codebuff",
+        "copilot",
+        "openclaw",
+        "pi",
+        "omp",
+      ];
+      if (k === "p" && (activeTab === 2 || activeTab === 4)) {
+        if (activeTab === 2) {
+          // 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();
+          // Animated spinner (same as the initial Compare load — see above)
+          const SPIN_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+          const BEAR_FRAMES = ["ʕ•ᴥ•ʔ", "ʕ•ᴥ•ʔﾉ", "ʕ•ᴥ•ʔ", "ʕ•ᴥ•ʔﾉ"];
+          const pullStart = Date.now();
+          let spinIdx = 0;
+          const spinTimer = setInterval(() => {
+            if (activeTab !== 2) return;
+            const elapsed = ((Date.now() - pullStart) / 1000).toFixed(1);
+            const spin = SPIN_FRAMES[spinIdx % SPIN_FRAMES.length];
+            const bear = BEAR_FRAMES[spinIdx % BEAR_FRAMES.length];
+            spinIdx++;
+            process.stdout.write(
+              GOTO(4, 1) + ERLINE +
+              `  ${gold(spin)} ${dim(`pulling ${platform}…`)} ${bold(`${elapsed}s`)} ${dim(`·`)} ${gold(bear)}`,
+            );
+          }, 200);
+          // ASYNC FIX: guard — only render if still on Compare (user may have switched away)
+          const result = await loadCompareData(platform).catch(() => null);
+          clearInterval(spinTimer);
+          if (activeTab === 2) {
+            compareData = result;
+            status = `last refreshed ${new Date().toLocaleTimeString("en-US", { hour12: false })}`;
+          }
+        } else {
+          // A5: Watch [P] cycles 'all' → claude → codex → … → 'all' (optional focus; default 'all').
+          const WATCH_PLAT_CYCLE = ["all", ...CYCLE_PLATFORMS];
+          const idx = WATCH_PLAT_CYCLE.indexOf(watchPlatform);
+          watchPlatform = WATCH_PLAT_CYCLE[(idx + 1) % WATCH_PLAT_CYCLE.length];
+        }
+        await redraw();
+        return;
+      }
+
+      // 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 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")) {
+        // 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 {
+          let watchCmd = "sigrank watch";
+          if (watchPlatform && watchPlatform !== "all")
+            watchCmd += ` --platform ${watchPlatform}`;
+          if (watchWindow && watchWindow !== "all-windows")
+            watchCmd += ` --window ${watchWindow}`;
+          watchCmd += ` --refresh ${watchRefresh}`;
+          // ASYNC FIX (2026-06-27): execFile instead of execSync — no shell
+          // interpolation. osascript args passed as array (defense-in-depth).
+          execFile(
+            "osascript",
+            ["-e", `tell application "Terminal" to do script "${watchCmd}"`],
+            { stdio: "ignore" },
+            () => {},
+          );
+          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;
+      }
+
+      if (k === "r") {
+        if (dashData?._ompLoading) {
+          status = "omp scan already in progress · refresh is available when it finishes";
+          await redraw();
+          return;
+        }
+        status = "refreshing…";
+        cascadeScroll = 0; // SCROLL-VIEW: reset scroll on refresh
+        // #9: on the Compare tab, [R] re-runs the FRESH verifier pull for the current platform
+        // (loadAll no longer touches Compare). Clearing compareData shows the spinner first.
+        if (activeTab === 2) {
+          compareData = null;
+          await redraw();
+          // ASYNC FIX: guard — only render if still on Compare
+          const result = await loadCompareData(platform).catch(() => null);
+          if (activeTab === 2) {
+            compareData = result;
+            status = `last refreshed ${new Date().toLocaleTimeString("en-US", { hour12: false })}`;
+            await redraw();
+          }
+          return;
+        }
+        await redraw();
+        await loadAll();
+        return;
+      }
+
+      if (k === "s" && activeTab !== 5) {
+        // FIX I1/E: [S] opens a submit PREVIEW (see→confirm→send) instead of firing
+        // blind. The preview shows a platform × window grid of what will publish;
+        // [Enter] sends all platforms, [Esc] cancels. (On the Connect tab, 's' is a
+        // code char handled by the focused field above.)
+        const id = loadIdentity();
+        if (!isSignedIn(id)) {
+          // not signed in → open Connect, never error
+          activeTab = 5;
+          connectMsg = dim("sign in to submit to board");
+          await redraw();
+          return;
+        }
+        submitPreview = true;
+        submitMsg = "";
+        await redraw();
+        return;
+      }
+
+      // FIX I2: [Y] toggles the Board between global+highlighted and "just me"
+      // (hybrid model — owner decision 2026-06-26). Only when signed in.
+      if (k === "y" && activeTab === 3 && isSignedIn(loadIdentity())) {
+        boardYouOnly = !boardYouOnly;
+        await redraw();
+        return;
+      }
+
+      if (k === "w" && activeTab === 3) {
+        // Board tab (now index 3)
+        const windows = ["7d", "30d", "90d", "all"];
+        const idx = windows.indexOf(boardWindow);
+        boardWindow = windows[(idx + 1) % windows.length];
+        boardData = await loadBoardData(boardWindow).catch(() => null);
+      }
+
+      if (switched) submitMsg = ""; // submit result is tied to the tab it was sent from
+      if (switched || k === "w") await redraw();
+    };
+
+    // Buffered stdin listener: reassembles split Esc sequences before dispatch.
+    process.stdin.on("data", (chunk) => {
+      // If we have a pending \x1b held from a previous chunk, combine it with
+      // this chunk to reassemble the full escape sequence (\x1b + [C = \x1b[C).
+      if (escBuf) {
+        clearTimeout(escTimer);
+        const combined = escBuf + chunk;
+        escBuf = null;
+        escTimer = null;
+        // If the combined result is \x1b followed by more \x1b (rare), just
+        // deliver the first as Esc and re-buffer the second. Otherwise deliver
+        // the combined sequence.
+        if (combined.length > 1) {
+          handleKey(combined);
+          return;
+        }
+        // combined is still just \x1b (chunk was empty?) → fall through to hold
+      }
+
+      // Fast path: chunk doesn't start with \x1b → deliver immediately.
+      if (chunk[0] !== "\x1b") {
+        handleKey(chunk);
+        return;
+      }
+      // Chunk starts with \x1b and is longer than 1 byte → complete escape
+      // sequence → deliver immediately.
+      if (chunk.length > 1) {
+        handleKey(chunk);
+        return;
+      }
+      // Chunk is exactly \x1b → hold for ESC_HOLD_MS to see if more bytes follow.
+      escBuf = chunk;
+      escTimer = setTimeout(() => {
+        handleKey(escBuf);
+        escBuf = null;
+        escTimer = null;
+      }, ESC_HOLD_MS);
+    });
+  });
+
+  process.stdin.setRawMode(false);
+  process.stdin.pause();
+  writeln();
+}
+
+// ── Exports for the headless audit system (tui-audit.mjs) ──────────────────
+// These expose the render functions + buffer state so the audit module can
+// render tabs in-process (fast) instead of spawning child processes.
+export {
+  renderDashboard,
+  renderTrends,
+  renderCompare,
+  renderBoard,
+  renderConnect,
+  renderWatch,
+  renderWatchData,
+  loadWatchData,
+  loadDashboardData,
+  loadCompareData,
+  loadBoardData,
+  startBuffer,
+  stripAnsi,
+};
+// _screenBuf is a `let` — exporting it snapshots the value, not the binding.
+// Expose getter/setter so the audit module can read the live buffer after
+// startBuffer() + render() populate it, and reset it after capturing.
+export function _getScreenBuf() {
+  return _screenBuf;
+}
+export function _resetBuf() {
+  _screenBuf = null;
+  _footerBuf = null;
+}
+
+// Direct-run entry (e.g. `node tui.mjs --render 0`). Normal launch is via cli.mjs.
+// pathToFileURL resolves relative argv[1] (e.g. `presentation/tui.mjs`) to the
+// same absolute file:// URL that import.meta.url always carries — without it,
+// `node presentation/tui.mjs --audit` never matched the guard and runTui never
+// ran (silent no-op). This is the standard Node ESM main-module detection.
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  runTui().catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });
+}