unsnooze 1.12.2 → 1.14.0

package/src/dashboard/App.js

@@ -0,0 +1,390 @@
+import React, { useState, useEffect, useCallback, useRef } from 'react';
+import { Box, Text, useApp, useInput, useWindowSize } from 'ink';
+import { Logo } from './Logo.js';
+import { theme } from './theme.js';
+import { StatusTab } from './tabs/StatusTab.js';
+import { UsageTab } from './tabs/UsageTab.js';
+import { SessionsTab } from './tabs/SessionsTab.js';
+import { DoctorTab } from './tabs/DoctorTab.js';
+import { LogsTab } from './tabs/LogsTab.js';
+import { FleetTab } from './tabs/FleetTab.js';
+import { PromptsTab } from './tabs/PromptsTab.js';
+import {
+  loadStatusSnapshot,
+  loadUsageSnapshot,
+  loadSessionsSnapshot,
+  loadDoctorSnapshot,
+  loadLogsSnapshot,
+  loadFleetSnapshot,
+  flattenFleetStopped,
+} from './data.js';
+import { TAGLINE } from './mark.js';
+import { MouseProvider, useMouse, useMouseWheel, Clickable } from './mouse.js';
+import { isMouseNoise } from './mouse-protocol.js';
+import { remoteAction } from '../fleet.js';
+
+const h = React.createElement;
+
+const TABS = [
+  { id: 'status', label: 'Status', key: '1' },
+  { id: 'usage', label: 'Usage', key: '2' },
+  { id: 'sessions', label: 'Sessions', key: '3' },
+  { id: 'doctor', label: 'Doctor', key: '4' },
+  { id: 'logs', label: 'Logs', key: '5' },
+  { id: 'fleet', label: 'Fleet', key: '6' },
+  { id: 'prompts', label: 'Prompts', key: '7' },
+];
+
+const HELP_ROWS = [
+  ['1–7', 'switch tab'],
+  ['tab / shift-tab', 'next / prev tab'],
+  ['j k / ↓ ↑', 'move selection'],
+  ['r', 'refresh now'],
+  ['R / C', 'fleet: resume / cancel selected remote session'],
+  ['m', 'toggle mouse (click tabs/rows, wheel scroll)'],
+  ['shift+click', 'select text while mouse is on (Option in iTerm2)'],
+  ['?', 'toggle this help'],
+  ['q', 'quit'],
+];
+
+function TabRow({ active, onSelect }) {
+  return h(Box, { flexDirection: 'row' },
+    ...TABS.map((t, i) =>
+      h(Clickable, { key: t.id, onClick: () => onSelect(i), flexDirection: 'row' },
+        h(Text, { color: i === active ? theme.accent : theme.muted, bold: i === active },
+          ` ${t.key} `),
+        h(Text, {
+          color: i === active ? 'black' : theme.muted,
+          backgroundColor: i === active ? theme.accent : undefined,
+          bold: i === active,
+        }, `${t.label}`),
+        h(Text, null, '  '),
+      ),
+    ),
+  );
+}
+
+function HelpOverlay({ cols, rows }) {
+  const w = 40;
+  const hgt = HELP_ROWS.length + 4;
+  return h(Box, {
+    position: 'absolute',
+    top: Math.max(1, Math.floor((rows - hgt) / 2)),
+    left: Math.max(1, Math.floor((cols - w) / 2)),
+    width: w,
+    flexDirection: 'column',
+    borderStyle: 'round',
+    borderColor: theme.accent,
+    paddingX: 2,
+    paddingY: 1,
+  },
+    h(Text, { color: theme.accent, bold: true }, 'keys'),
+    ...HELP_ROWS.map(([k, desc], i) =>
+      h(Text, { key: i },
+        h(Text, { color: theme.bright }, k.padEnd(17)),
+        h(Text, { color: theme.muted }, desc),
+      ),
+    ),
+  );
+}
+
+function Dashboard({ initialTab = 'status' } = {}) {
+  const { exit } = useApp();
+  const { columns, rows: winRows } = useWindowSize();
+  const cols = columns || process.stdout.columns || 80;
+  const rows = winRows || process.stdout.rows || 24;
+
+  const startIdx = Math.max(0, TABS.findIndex(t => t.id === initialTab));
+  const [tab, setTab] = useState(startIdx >= 0 ? startIdx : 0);
+  const [selected, setSelected] = useState(0);
+  const [logScroll, setLogScroll] = useState(0);
+  const [showHelp, setShowHelp] = useState(false);
+  const [lastRefresh, setLastRefresh] = useState(Date.now());
+  const [nowTick, setNowTick] = useState(Date.now());
+  const [statusData, setStatusData] = useState(null);
+  const [usageData, setUsageData] = useState(null);
+  const [sessionsData, setSessionsData] = useState(null);
+  const [doctorData, setDoctorData] = useState(null);
+  const [logsData, setLogsData] = useState(null);
+  const [fleetData, setFleetData] = useState(null);
+  const [usageBusy, setUsageBusy] = useState(false);
+  const [fleetBusy, setFleetBusy] = useState(false);
+  const [err, setErr] = useState(null);
+  // Prompts tab's add-form owns raw keyboard input while a TextInput/step
+  // selector has focus (typing "r" or "1" into a prompt must not refresh or
+  // switch tabs underneath it) — set true while that form is open, false the
+  // instant it closes or unmounts. No pre-existing suppression flag: the `?`
+  // help overlay doesn't actually gate any keys today, it only toggles its
+  // own visibility — so this is a new, narrowly-scoped mechanism rather than
+  // an extension of one.
+  const [inputCaptured, setInputCaptured] = useState(false);
+  const tabRef = useRef(tab);
+  tabRef.current = tab;
+
+  const refreshStatus = useCallback(() => {
+    try {
+      setStatusData(loadStatusSnapshot());
+      setLastRefresh(Date.now());
+      setErr(null);
+    } catch (e) {
+      setErr(e.message);
+    }
+  }, []);
+
+  const refreshUsage = useCallback(async () => {
+    setUsageBusy(true);
+    try {
+      setUsageData(await loadUsageSnapshot());
+      setLastRefresh(Date.now());
+      setErr(null);
+    } catch (e) {
+      setErr(e.message);
+    } finally {
+      setUsageBusy(false);
+    }
+  }, []);
+
+  const refreshSessions = useCallback(async () => {
+    try {
+      setSessionsData(await loadSessionsSnapshot());
+      setLastRefresh(Date.now());
+    } catch (e) {
+      setErr(e.message);
+    }
+  }, []);
+
+  const refreshDoctor = useCallback(async () => {
+    try {
+      setDoctorData(await loadDoctorSnapshot());
+      setLastRefresh(Date.now());
+    } catch (e) {
+      setErr(e.message);
+    }
+  }, []);
+
+  const refreshLogs = useCallback(() => {
+    try {
+      setLogsData(loadLogsSnapshot({ maxLines: 200 }));
+      setLastRefresh(Date.now());
+    } catch (e) {
+      setErr(e.message);
+    }
+  }, []);
+
+  // ssh fan-out — timeout-bounded per host inside fetchFleet, but still a
+  // real network round trip. Awaited like loadUsageSnapshot; a busy flag
+  // keeps the header honest without blocking other tabs (the interval below
+  // only fires this on the fleet tab, every 15 ticks, or on-demand via `r`).
+  const refreshFleet = useCallback(async () => {
+    setFleetBusy(true);
+    try {
+      setFleetData(await loadFleetSnapshot());
+      setLastRefresh(Date.now());
+      setErr(null);
+    } catch (e) {
+      setErr(e.message);
+    } finally {
+      setFleetBusy(false);
+    }
+  }, []);
+
+  const refreshActive = useCallback(() => {
+    refreshStatus();
+    const id = TABS[tabRef.current]?.id;
+    if (id === 'usage') refreshUsage();
+    else if (id === 'sessions') refreshSessions();
+    else if (id === 'doctor') refreshDoctor();
+    else if (id === 'logs') refreshLogs();
+    else if (id === 'fleet') refreshFleet();
+  }, [refreshStatus, refreshUsage, refreshSessions, refreshDoctor, refreshLogs, refreshFleet]);
+
+  useEffect(() => {
+    refreshStatus();
+    const id = TABS[tab]?.id;
+    if (id === 'usage') refreshUsage();
+    else if (id === 'sessions') refreshSessions();
+    else if (id === 'doctor') refreshDoctor();
+    else if (id === 'logs') refreshLogs();
+    else if (id === 'fleet') refreshFleet();
+    setSelected(0);
+    setLogScroll(0);
+  }, [tab]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  useEffect(() => {
+    let n = 0;
+    const id = setInterval(() => {
+      n += 1;
+      setNowTick(Date.now());
+      refreshStatus();
+      const tid = TABS[tabRef.current]?.id;
+      if (tid === 'logs' && n % 2 === 0) refreshLogs();
+      if (tid === 'usage' && n % 5 === 0) refreshUsage();
+      if (tid === 'sessions' && n % 3 === 0) refreshSessions();
+      if (tid === 'fleet' && n % 15 === 0) refreshFleet();
+    }, 1000);
+    return () => clearInterval(id);
+  }, [refreshStatus, refreshUsage, refreshSessions, refreshLogs, refreshFleet]);
+
+  const mouse = useMouse();
+
+  // Fire-and-forget: remote resume/cancel act on marks only (the remote's
+  // own daemon does the typing under its own gates — see src/fleet.js).
+  // Result surfaces in the header error slot like any other dashboard error.
+  const handleFleetAction = useCallback((verb) => {
+    const rows = flattenFleetStopped(fleetData);
+    if (rows.length === 0) return;
+    const row = rows[Math.min(selected, rows.length - 1)];
+    if (!row) return;
+    const { host, dest, entry, session } = row;
+    const id8 = session.key ? session.key.slice(0, 8) : (session.sessionId || '').slice(0, 8);
+    // Prefer the full host descriptor (carries auth/source/etc) so a
+    // password-auth host resumed/cancelled from the dashboard actually uses
+    // its configured auth instead of silently falling back to key auth —
+    // a bare dest string loses those fields.
+    remoteAction(host, entry || dest, verb, session.key)
+      .then((res) => {
+        setErr(res.ok
+          ? `fleet: ${verb} ${host}/${id8} ok`
+          : `fleet: ${verb} ${host}/${id8} failed — ${res.error}`);
+      })
+      .catch((e) => setErr(`fleet: ${verb} ${host}/${id8} failed — ${e.message}`));
+  }, [fleetData, selected]);
+
+  useInput((input, key) => {
+    if (isMouseNoise(input)) return;   // leaked SGR fragments are not keys
+    // Prompts tab's add-form has raw keyboard focus (a TextInput or a step
+    // selector) — every one of the globals below (including q) must stay
+    // silent so typing "quit" or "7pm" into a field can't quit or jump tabs.
+    if (inputCaptured) return;
+    if (input === 'm') { mouse.toggle(); return; }
+    if (input === 'q') { exit(); return; }
+    if (input === '?') { setShowHelp(s => !s); return; }
+    if (key.escape && showHelp) { setShowHelp(false); return; }
+    if (input === 'r') { refreshActive(); return; }
+    if (key.tab) {
+      setTab(t => (key.shift ? (t + TABS.length - 1) % TABS.length : (t + 1) % TABS.length));
+      return;
+    }
+    if (input >= '1' && input <= '7') { setTab(Number(input) - 1); return; }
+    if (TABS[tabRef.current]?.id === 'fleet' && input === 'R') { handleFleetAction('resume'); return; }
+    if (TABS[tabRef.current]?.id === 'fleet' && input === 'C') { handleFleetAction('cancel'); return; }
+    if (input === 'j' || key.downArrow) { setSelected(s => s + 1); return; }
+    if (input === 'k' || key.upArrow) { setSelected(s => Math.max(0, s - 1)); }
+  });
+
+  useMouseWheel((ev) => {
+    if (!ev.wheel) return;
+    const id = TABS[tabRef.current]?.id;
+    if (id === 'status' || id === 'sessions' || id === 'fleet') {
+      if (ev.wheel === 'down') setSelected(s => s + 1);
+      else setSelected(s => Math.max(0, s - 1));
+    } else if (id === 'logs') {
+      setLogScroll(s => ev.wheel === 'up' ? s + 3 : Math.max(0, s - 3));
+    }
+  });
+
+  const listLen = TABS[tab]?.id === 'status'
+    ? (statusData?.sessions?.length || 0)
+    : TABS[tab]?.id === 'sessions'
+      ? (sessionsData?.length || 0)
+      : TABS[tab]?.id === 'fleet'
+        ? flattenFleetStopped(fleetData).length
+        : TABS[tab]?.id === 'prompts'
+          ? (statusData?.promptQueue?.length || 0)
+          : 0;
+  const sel = listLen ? Math.min(selected, listLen - 1) : 0;
+  const ago = Math.max(0, Math.round((nowTick - lastRefresh) / 1000));
+  const active = TABS[tab];
+  const statusWithNow = statusData ? { ...statusData, now: nowTick } : null;
+
+  // Floor test: full 6-row mark needs vertical room; short terminals get the
+  // one-line compact mark so data keeps the space.
+  const fullLogo = rows >= 24;
+  // Wordmark: chevron(8) + z(10) + UNSNOOZE(71) + right meta(~26) — needs width.
+  const showWordmark = fullLogo && cols >= 118;
+  const headerRows = (fullLogo ? 6 : 1) + 1 + (showWordmark ? 1 : 0); // + margin + tagline
+  const bodyRows = Math.max(3, rows - headerRows - 4); // tab row + rules + footer
+
+  let main;
+  switch (active?.id) {
+    case 'usage': main = h(UsageTab, { data: usageData }); break;
+    case 'sessions': main = h(SessionsTab, { data: sessionsData, selected: sel, onSelect: setSelected }); break;
+    case 'doctor': main = h(DoctorTab, { data: doctorData }); break;
+    case 'logs': main = h(LogsTab, { data: logsData, maxRows: bodyRows - 2, scroll: logScroll }); break;
+    case 'fleet': main = h(FleetTab, { data: fleetData, selected: sel, onSelect: setSelected }); break;
+    case 'prompts': main = h(PromptsTab, {
+      data: statusData?.promptQueue, now: nowTick, sessions: statusData?.sessions,
+      selected: sel, onSelect: setSelected, onRefresh: refreshStatus, onStatus: setErr,
+      onFormOpenChange: setInputCaptured,
+    }); break;
+    default: main = h(StatusTab, { data: statusWithNow, selected: sel, onSelect: setSelected });
+  }
+
+  const daemon = statusData?.daemonRunning
+    ? h(Text, null, h(Text, { color: theme.ok }, '● '), h(Text, { color: theme.muted }, `daemon ${statusData.resumerPid}`))
+    : h(Text, null, h(Text, { color: theme.crit }, '○ '), h(Text, { color: theme.muted }, 'daemon off'));
+
+  return h(Box, {
+    flexDirection: 'column',
+    width: cols,
+    height: rows,
+    paddingX: 1,
+  },
+    // Header: animated mark + live meta (breathing room above the tab row)
+    h(Box, { flexDirection: 'row', justifyContent: 'space-between', alignItems: 'flex-start', marginBottom: showWordmark ? 0 : 1 },
+      h(Logo, { compact: !fullLogo, wordmark: showWordmark }),
+      h(Box, { flexDirection: 'column', alignItems: 'flex-end' },
+        // The big wordmark says it already — keep the title only when hidden
+        showWordmark ? null : h(Text, null,
+          h(Text, { color: theme.accent, bold: true }, 'unsnooze'),
+          h(Text, { color: theme.muted }, '  live dashboard'),
+        ),
+        daemon,
+        h(Text, { color: theme.muted, dimColor: true },
+          `refreshed ${ago}s ago${usageBusy || fleetBusy ? ' · scanning…' : ''}`),
+      ),
+    ),
+    showWordmark
+      ? h(Box, { marginBottom: 1 },
+        h(Text, { color: theme.accent, bold: true }, '❯ '),
+        h(Text, { color: theme.muted }, TAGLINE.slice(2)),
+      )
+      : null,
+    // Tab row over a dim rule
+    h(TabRow, { active: tab, onSelect: setTab }),
+    h(Text, { color: theme.muted, dimColor: true }, '─'.repeat(Math.max(0, cols - 2))),
+    // Body
+    h(Box, { flexDirection: 'column', flexGrow: 1, paddingX: 1, paddingTop: 1 },
+      err ? h(Text, { color: theme.crit }, `error: ${err}`) : null,
+      main,
+    ),
+    // Footer: context keys + brand mark
+    h(Text, { color: theme.muted, dimColor: true }, '─'.repeat(Math.max(0, cols - 2))),
+    h(Box, { flexDirection: 'row', justifyContent: 'space-between' },
+      h(Box, { flexDirection: 'row' },
+        h(Text, { color: theme.muted }, ' 1-7 tabs · j/k move · '),
+        h(Clickable, { onClick: refreshActive }, h(Text, { color: theme.muted }, 'r refresh')),
+        h(Text, { color: theme.muted }, ' · '),
+        h(Clickable, { onClick: () => setShowHelp(s => !s) },
+          h(Text, { color: theme.muted }, h(Text, { color: theme.bright }, '?'), ' help')),
+        h(Text, { color: theme.muted }, ' · '),
+        h(Clickable, { onClick: () => mouse.toggle() },
+          h(Text, { color: theme.muted }, `m mouse ${mouse.enabled ? '✓' : '✗'}`)),
+        h(Text, { color: theme.muted }, ' · '),
+        h(Clickable, { onClick: exit }, h(Text, { color: theme.muted }, 'q quit')),
+      ),
+      h(Text, { color: theme.accent, bold: true }, '❯ '),
+    ),
+    showHelp
+      ? h(Clickable, {
+        onClick: () => setShowHelp(false),
+        position: 'absolute', top: 0, left: 0, width: cols, height: rows,
+      }, h(HelpOverlay, { cols, rows }))
+      : null,
+  );
+}
+
+export function App({ initialTab = 'status', mouseEnabled = true } = {}) {
+  return h(MouseProvider, { initialEnabled: mouseEnabled },
+    h(Dashboard, { initialTab }));
+}

package/src/dashboard/Logo.js

@@ -0,0 +1,74 @@
+import React from 'react';
+import { Box, Text, useAnimation, useIsScreenReaderEnabled } from 'ink';
+import { CHEVRON, Z_FRAMES, WORDMARK, WORDMARK_SPLIT, MARK_LINE, markPlainText } from './mark.js';
+import { theme } from './theme.js';
+
+const h = React.createElement;
+
+/*
+ * Animated brand mark: big "❯" chevron + z's rising off its tip.
+ * Slow idle loop (~2.7s cycle) — chrome animation should whisper, not flicker.
+ * Static under screen readers (frame pinned so the mark stays announceable).
+ */
+
+const FRAME_MS = 450;
+
+export function Logo({ compact = false, wordmark = false } = {}) {
+  const screenReader = useIsScreenReaderEnabled();
+  const { frame } = useAnimation({ interval: FRAME_MS, isActive: !screenReader && !compact });
+
+  if (compact) {
+    return h(Box, { flexDirection: 'row' },
+      h(Text, { color: theme.accent, bold: true }, '❯ '),
+      h(Text, { color: theme.accent2 }, 'z z z'),
+    );
+  }
+
+  const zs = screenReader ? Z_FRAMES[2] : Z_FRAMES[frame % Z_FRAMES.length];
+
+  return h(Box, { flexDirection: 'row', alignItems: 'flex-start' },
+    h(Box, { flexDirection: 'column' },
+      ...CHEVRON.map((line, i) =>
+        h(Text, { key: 'c' + i, color: theme.accent, bold: true }, line),
+      ),
+    ),
+    h(Box, { flexDirection: 'column', marginLeft: 1 },
+      ...zs.map((line, i) =>
+        h(Text, {
+          key: 'z' + i,
+          color: theme.accent2,
+          // The big Z leading the drift reads bright; freshly-spawned z's dim
+          bold: /Z/.test(line),
+          dimColor: /z/.test(line) && i >= 2,
+        }, line || ' '),
+      ),
+    ),
+    wordmark
+      ? h(Box, { flexDirection: 'column', marginLeft: 2 },
+        // "UN" amber, "SNOOZE" bright — the banner's two-tone treatment
+        ...WORDMARK.map((line, i) =>
+          h(Text, { key: 'w' + i },
+            h(Text, { color: theme.accent, bold: true }, line.slice(0, WORDMARK_SPLIT)),
+            h(Text, { color: theme.bright, bold: true }, line.slice(WORDMARK_SPLIT)),
+          ),
+        ),
+      )
+      : null,
+  );
+}
+
+export function logoContainsBrand() {
+  const blob = CHEVRON.join('\n') + Z_FRAMES.flat().join('\n');
+  return {
+    prompt: '❯',
+    hasZ: /z/i.test(blob),
+    hasChevron: /█|▀|▄/.test(blob),
+    frames: Z_FRAMES,
+  };
+}
+
+export function logoPlainText() {
+  return markPlainText();
+}
+
+export { MARK_LINE };

package/src/dashboard/components/TextInput.js

@@ -0,0 +1,63 @@
+// Minimal controlled single-line text input — Ink ships no text-input
+// primitive, and pulling in a dependency for one field type isn't worth it.
+// `applyKey` is the pure edit reducer (the unit-test surface); the component
+// is just useInput + a thin cursor-position wrapper around it.
+import React, { useState } from 'react';
+import { Text, useInput } from 'ink';
+import { theme } from '../theme.js';
+
+const h = React.createElement;
+
+// Control bytes (incl. DEL) stripped from any inserted text — paste can
+// arrive as a multi-char chunk carrying \n/\t/escape fragments; a single-line
+// field never wants any of them, typed or pasted.
+const CONTROL_RE = /[\x00-\x1f\x7f]/g; // eslint-disable-line no-control-regex
+
+// state = {value, cursor}. Enter/Escape are submit/cancel signals owned by
+// the component (not edits) — the reducer leaves state untouched for them.
+export function applyKey(state, input, key) {
+  const { value, cursor } = state;
+  if (key.return || key.escape) return { value, cursor };
+  if (key.leftArrow) return { value, cursor: Math.max(0, cursor - 1) };
+  if (key.rightArrow) return { value, cursor: Math.min(value.length, cursor + 1) };
+  if (key.home || (key.ctrl && input === 'a')) return { value, cursor: 0 };
+  if (key.end || (key.ctrl && input === 'e')) return { value, cursor: value.length };
+  if (key.ctrl || key.meta) return { value, cursor }; // no other modifier combos edit
+  if (key.backspace || key.delete) {
+    if (cursor === 0) return { value, cursor };
+    return { value: value.slice(0, cursor - 1) + value.slice(cursor), cursor: cursor - 1 };
+  }
+  if (!input) return { value, cursor };
+  const clean = input.replace(CONTROL_RE, '');
+  if (!clean) return { value, cursor };
+  return { value: value.slice(0, cursor) + clean + value.slice(cursor), cursor: cursor + clean.length };
+}
+
+export function TextInput({ value = '', onChange, onSubmit, onCancel, focus = true, placeholder = '' }) {
+  const [cursor, setCursor] = useState(value.length);
+  const c = Math.min(cursor, value.length);
+
+  useInput((input, key) => {
+    if (key.return) { onSubmit?.(value); return; }
+    if (key.escape) { onCancel?.(); return; }
+    const next = applyKey({ value, cursor: c }, input, key);
+    if (next.cursor !== c) setCursor(next.cursor);
+    if (next.value !== value) onChange?.(next.value);
+  }, { isActive: focus });
+
+  if (!value) {
+    return h(Text, { color: theme.muted, dimColor: true }, placeholder || (focus ? '█' : ' '));
+  }
+
+  const before = value.slice(0, c);
+  const after = value.slice(c + 1);
+  const atCursor = c < value.length ? value[c] : null;
+
+  return h(Text, null,
+    before,
+    atCursor != null
+      ? h(Text, { inverse: true }, atCursor)
+      : (focus ? '█' : ''),
+    after,
+  );
+}

package/src/dashboard/data.js

@@ -0,0 +1,143 @@
+import { readFileSync, existsSync, statSync } from 'node:fs';
+import { readState } from '../state.js';
+import { getConfig } from '../settings.js';
+import { LOG_FILE } from '../config.js';
+import { queueList } from '../prompt-queue.js';
+import {
+  buildUsageReport,
+  collectClaudeSamples,
+  collectCodexSamples,
+  readExactClaudeFromStatusline,
+  parseUsageWarnAt,
+  readUsageStore,
+} from '../usage.js';
+import { listOwnedSessions } from '../reap.js';
+import { runDoctor } from '../doctor.js';
+import { fetchFleet, readHosts } from '../fleet.js';
+
+function pidAlive(pid) {
+  if (!pid) return false;
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+export function loadStatusSnapshot() {
+  const state = readState();
+  const sessions = Object.values(state.sessions || {});
+  const daemonRunning = pidAlive(state.resumerPid);
+  return {
+    sessions,
+    // A recorded pid that no longer answers is stale — never show it as live.
+    resumerPid: daemonRunning ? state.resumerPid : null,
+    daemonRunning,
+    paused: !getConfig('autoResume'),
+    now: Date.now(),
+    promptQueue: queueList(),
+  };
+}
+
+export async function loadUsageSnapshot() {
+  const now = Date.now();
+  const state = readState();
+  const store = readUsageStore();
+  // Throttled cold scan — callers should not fire more than every ~5s
+  const claudeSamples = collectClaudeSamples({ now });
+  const codexSamples = collectCodexSamples({ now });
+  const exactClaude = readExactClaudeFromStatusline({ now });
+  const report = buildUsageReport({
+    now,
+    claudeSamples: [
+      ...(store.samples || []).filter(s => s.agent === 'claude' && s.weighted != null),
+      ...claudeSamples,
+    ],
+    codexSamples: [
+      ...(store.samples || []).filter(s => s.agent === 'codex' && s.primary),
+      ...codexSamples,
+    ],
+    calibration: state.calibration || {},
+    exactClaude,
+    ewma: store.ewma || {},
+    sessions: state.sessions,
+    exactPctHistory: store.exactPct?.claude5h || [],
+  });
+  report.daemonRunning = (() => {
+    if (!state.resumerPid) return false;
+    try { process.kill(state.resumerPid, 0); return true; } catch { return false; }
+  })();
+  report.warnAt = parseUsageWarnAt(getConfig('usageWarnAt'));
+  return report;
+}
+
+export async function loadSessionsSnapshot() {
+  return listOwnedSessions();
+}
+
+export async function loadDoctorSnapshot() {
+  return runDoctor({});
+}
+
+// Thin wrapper over fetchFleet() — ssh fan-out is per-host timeout-bounded
+// there, so this can just be awaited like loadUsageSnapshot. `dest` and the
+// full host `entry` (descriptor: dest/auth/source/env/service/account/cmd)
+// are stitched back onto each result (fetchHost doesn't carry either) so
+// tabs can build ssh -t attach hints and so App.js's R/C actions can pass
+// the whole descriptor into remoteAction — a bare dest string loses the
+// auth fields, which silently downgrades password hosts to key auth.
+export async function loadFleetSnapshot() {
+  const hosts = readHosts();
+  const results = await fetchFleet({ hosts });
+  return results.map(r => ({ ...r, dest: hosts[r.host]?.dest, entry: hosts[r.host] }));
+}
+
+// Flat (host, dest, entry, session) rows for every stopped session across
+// the fleet, in host order — the single source of truth for row ordering so
+// FleetTab's rendered list and App's selection/keybinding math never drift
+// apart. `entry` (the full host descriptor) rides along so R/C actions can
+// hand remoteAction auth-aware args instead of a bare dest string.
+export function flattenFleetStopped(fleetData) {
+  if (!fleetData) return [];
+  const out = [];
+  for (const r of fleetData) {
+    const sessions = (r.envelope?.sessions ?? []).filter(s => s.status === 'stopped');
+    for (const s of sessions) out.push({ host: r.host, dest: r.dest || r.host, entry: r.entry, session: s });
+  }
+  return out;
+}
+
+export function loadLogsSnapshot({ maxLines = 40 } = {}) {
+  if (!existsSync(LOG_FILE)) return { lines: [], path: LOG_FILE, missing: true };
+  try {
+    const text = readFileSync(LOG_FILE, 'utf-8');
+    const lines = text.split('\n').filter(Boolean).slice(-maxLines);
+    return { lines, path: LOG_FILE, missing: false, size: statSync(LOG_FILE).size };
+  } catch (err) {
+    return { lines: [`(read error: ${err.message})`], path: LOG_FILE, missing: false };
+  }
+}
+
+export function fmtCountdown(ms) {
+  if (ms <= 0) return 'due now';
+  const m = Math.round(ms / 60_000);
+  if (m < 60) return `${m}m`;
+  const h = Math.floor(m / 60);
+  return `${h}h ${m % 60}m`;
+}
+
+// Gauge with eighth-block partials for sub-cell precision (▏▎▍▌▋▊▉█).
+const EIGHTHS = ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉'];
+
+export function bar(pct, width = 16) {
+  const p = Number.isFinite(pct) ? Math.min(100, Math.max(0, pct)) : 0;
+  const cells = (p / 100) * width;
+  const full = Math.floor(cells);
+  const rem = Math.round((cells - full) * 8);
+  const partial = full < width ? EIGHTHS[Math.min(rem, 7)] : '';
+  const used = full + (partial ? 1 : 0);
+  return '█'.repeat(full) + partial + '░'.repeat(Math.max(0, width - used));
+}
+
+export function countdownPct(resetAt, now = Date.now(), windowMs = 5 * 3_600_000) {
+  if (!Number.isFinite(resetAt)) return null;
+  const remain = resetAt - now;
+  if (remain <= 0) return 100;
+  return Math.min(100, Math.max(0, 100 - (remain / windowMs) * 100));
+}