unsnooze 1.12.2 → 1.14.0

package/src/dashboard/mark.js

@@ -0,0 +1,51 @@
+// Brand mark: a big "❯" prompt chevron + rising z's — matches assets/banner.svg.
+// Pure data (no ink/react) so both the live dashboard (Logo.js) and the plain
+// CLI formatters (tui.js) can consume it.
+
+// Two diagonal strokes meeting in a point — reads as "❯" / ">".
+export const CHEVRON = [
+  '██▄    ',
+  ' ▀██▄  ',
+  '   ▀██▄',
+  '   ▄██▀',
+  ' ▄██▀  ',
+  '██▀    ',
+];
+
+// Rising z's, aligned row-for-row with CHEVRON: each z spawns at the chevron
+// tip and drifts up-right, growing as it goes — accumulate, then break off.
+export const Z_FRAMES = [
+  ['        ', '        ', ' z      ', '        ', '        ', '        '],
+  ['        ', '   z    ', ' z      ', '        ', '        ', '        '],
+  ['     Z  ', '   z    ', ' z      ', '        ', '        ', '        '],
+  ['       Z', '     z  ', '        ', '        ', '        ', '        '],
+  ['        ', '       z', '        ', '        ', '        ', '        '],
+  ['        ', '        ', ' z      ', '        ', '        ', '        '],
+];
+
+// UNSNOOZE wordmark — ANSI-shadow block caps (71 cols, 6 rows, same height
+// as the chevron). WORDMARK_SPLIT is where "UN" ends: amber to the left,
+// bright to the right — matches the banner treatment.
+export const WORDMARK = [
+  '██╗   ██╗███╗   ██╗███████╗███╗   ██╗ ██████╗  ██████╗ ███████╗███████╗',
+  '██║   ██║████╗  ██║██╔════╝████╗  ██║██╔═══██╗██╔═══██╗╚══███╔╝██╔════╝',
+  '██║   ██║██╔██╗ ██║███████╗██╔██╗ ██║██║   ██║██║   ██║  ███╔╝ █████╗  ',
+  '██║   ██║██║╚██╗██║╚════██║██║╚██╗██║██║   ██║██║   ██║ ███╔╝  ██╔══╝  ',
+  '╚██████╔╝██║ ╚████║███████║██║ ╚████║╚██████╔╝╚██████╔╝███████╗███████╗',
+  ' ╚═════╝ ╚═╝  ╚═══╝╚══════╝╚═╝  ╚═══╝ ╚═════╝  ╚═════╝ ╚══════╝╚══════╝',
+];
+export const WORDMARK_SPLIT = 19; // '██╗   ██╗' (U) + '███╗   ██╗' (N)
+
+export const TAGLINE = '❯ wakes every limit-stopped AI session the moment the limit resets';
+
+// One-line mark for compact chrome (footers, tiny terminals).
+export const MARK_LINE = '❯ z z z';
+
+export function markRows(frame = 2) {
+  const zs = Z_FRAMES[((frame % Z_FRAMES.length) + Z_FRAMES.length) % Z_FRAMES.length];
+  return CHEVRON.map((row, i) => ({ chevron: row, zs: zs[i] || '' }));
+}
+
+export function markPlainText(frame = 2) {
+  return markRows(frame).map(r => (r.chevron + ' ' + r.zs).trimEnd()).join('\n');
+}

package/src/dashboard/mouse-protocol.js

@@ -0,0 +1,75 @@
+// SGR-1006 mouse protocol — pure functions, no React/Ink imports.
+// Enable: button-event tracking (1002) + SGR encoding (1006). 1003 (any
+// motion) is deliberately never requested: it floods stdin and is the worst
+// leak class when cleanup is missed.
+export const MOUSE_ENABLE = '\x1b[?1002h\x1b[?1006h';
+// Disable every mode we (or a crashed predecessor) might have set — turning
+// off a mode that was never on is harmless (tcell does the same).
+export const MOUSE_DISABLE_ALL = '\x1b[?1003l\x1b[?1002l\x1b[?1000l\x1b[?1006l\x1b[?1015l';
+
+// \x1b[<b;x;yM (press/motion/wheel) or \x1b[<b;x;ym (release)
+const SGR_RE = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/g;
+
+// b bit layout: 0/1/2 = left/middle/right (or wheel dir), +4 shift, +8 meta,
+// +16 ctrl, +32 motion, +64 wheel.
+function decodeEvent(b, x1, y1, final) {
+  const base = b & 3;
+  const ev = {
+    x: x1 - 1,   // SGR is 1-based; everything downstream is 0-based
+    y: y1 - 1,
+    shift: (b & 4) !== 0,
+    meta: (b & 8) !== 0,
+    ctrl: (b & 16) !== 0,
+    wheel: null,
+    button: null,
+  };
+  if ((b & 64) !== 0 && b < 128) {
+    const wheel = base === 0 ? 'up' : base === 1 ? 'down' : null;
+    return { ...ev, type: 'wheel', wheel };
+  }
+  // b >= 128 means extra buttons (xterm 8-11); these map to button: null
+  const button = b >= 128 ? null : (base === 0 ? 'left' : base === 1 ? 'middle' : base === 2 ? 'right' : null);
+  if (final === 'm') return { ...ev, type: 'release', button };
+  if ((b & 32) !== 0) return { ...ev, type: button ? 'drag' : 'move', button };
+  return { ...ev, type: 'press', button };
+}
+
+// Parse every complete SGR report in `text`. A report can be split across
+// stdin chunks — `rest` returns the trailing partial (from its ESC) so the
+// caller can prepend it to the next chunk.
+export function parseSgrEvents(text) {
+  const events = [];
+  let lastEnd = 0;
+  SGR_RE.lastIndex = 0;
+  let m;
+  while ((m = SGR_RE.exec(text))) {
+    events.push(decodeEvent(parseInt(m[1], 10), parseInt(m[2], 10), parseInt(m[3], 10), m[4]));
+    lastEnd = m.index + m[0].length;
+  }
+  const tail = text.slice(lastEnd);
+  const escAt = tail.lastIndexOf('\x1b');
+  let rest = '';
+  if (escAt !== -1) {
+    const candidate = tail.slice(escAt);
+    // Only carry prefixes that can still become an SGR report.
+    // Cap at 32 chars to prevent unbounded growth on malformed input.
+    if (candidate.length <= 32 && /^\x1b(\[(<[\d;]*)?)?$/.test(candidate)) rest = candidate;
+  }
+  return { events, rest };
+}
+
+// Ink strips the ESC prefix from sequences its key parser can't resolve, so
+// useInput handlers can receive fragments like "[<35;10;5M". Guard with this.
+export function isMouseNoise(input) {
+  return /\[?<\d+;\d+;\d+[Mm]/.test(String(input ?? ''));
+}
+
+// Zones are plain rects ({x, y, width, height, ...payload}). Registration
+// order is stacking order: the LAST hit wins so overlays beat what's under.
+export function hitTest(rects, col, row) {
+  for (let i = rects.length - 1; i >= 0; i--) {
+    const r = rects[i];
+    if (col >= r.x && col < r.x + r.width && row >= r.y && row < r.y + r.height) return r;
+  }
+  return null;
+}

package/src/dashboard/mouse.js

@@ -0,0 +1,125 @@
+// Mouse context for the dashboard: enables SGR tracking, parses raw stdin,
+// hit-tests presses/wheels against zones registered by <Clickable>.
+// Keyboard parity is a hard rule — every click action has a key equivalent.
+import React, { createContext, useContext, useEffect, useRef, useState, useCallback } from 'react';
+import { Box, useStdin, useStdout, measureElement } from 'ink';
+import { MOUSE_ENABLE, MOUSE_DISABLE_ALL, parseSgrEvents, hitTest } from './mouse-protocol.js';
+
+const h = React.createElement;
+const MouseContext = createContext(null);
+
+let zoneSeq = 0;
+
+// Exported for tests: zones (insertion-ordered) → hitTest rects.
+// `measure` is injectable; production uses ink's measureElement.
+export function zonesToRects(zones, measure = measureElement) {
+  const rects = [];
+  for (const z of zones) {
+    if (!z.ref.current) continue;
+    let m;
+    try { m = measure(z.ref.current); } catch { continue; }
+    if (!m || m.width <= 0 || m.height <= 0) continue;
+    rects.push({ ...m, ...z });
+  }
+  return rects;
+}
+
+export function MouseProvider({ initialEnabled = true, children }) {
+  const { stdin, isRawModeSupported } = useStdin();
+  const { stdout } = useStdout();
+  const supported = Boolean(isRawModeSupported && stdin && stdout);
+  const [enabled, setEnabled] = useState(initialEnabled && supported);
+  const zones = useRef(new Map());        // id -> { id, ref, onClick, onWheel }
+  const wheelFallbacks = useRef(new Set());
+  const carry = useRef('');
+
+  const dispatch = useCallback((ev) => {
+    if (ev.type === 'press' && ev.button === 'left') {
+      const withClick = [...zones.current.values()].filter(z => z.onClick);
+      const hit = hitTest(zonesToRects(withClick), ev.x, ev.y);
+      if (hit?.onClick) hit.onClick(ev);
+      return;
+    }
+    if (ev.type === 'wheel') {
+      const withWheel = [...zones.current.values()].filter(z => z.onWheel);
+      const hit = hitTest(zonesToRects(withWheel), ev.x, ev.y);
+      if (hit?.onWheel) { hit.onWheel(ev); return; }
+      for (const fn of wheelFallbacks.current) fn(ev);
+    }
+    // release / drag / move: no consumers today — deliberately dropped.
+  }, []);
+
+  useEffect(() => {
+    if (!enabled || !supported) return undefined;
+    carry.current = '';
+    stdout.write(MOUSE_ENABLE);
+    const onData = (chunk) => {
+      const { events, rest } = parseSgrEvents(carry.current + String(chunk));
+      carry.current = rest;
+      for (const ev of events) dispatch(ev);
+    };
+    stdin.on('data', onData);
+    // Ctrl-Z suspend: ink restores raw mode/alt screen on resume, but mouse
+    // modes are ours — re-assert on SIGCONT (research: lazygit #1764 class).
+    const onCont = () => stdout.write(MOUSE_ENABLE);
+    process.on('SIGCONT', onCont);
+    return () => {
+      stdin.off('data', onData);
+      process.off('SIGCONT', onCont);
+      stdout.write(MOUSE_DISABLE_ALL);
+    };
+  }, [enabled, supported, stdin, stdout, dispatch]);
+
+  const toggle = useCallback(() => setEnabled(e => supported && !e), [supported]);
+  const registerZone = useCallback((zone) => {
+    zones.current.set(zone.id, zone);
+    return () => zones.current.delete(zone.id);
+  }, []);
+  const registerWheelFallback = useCallback((fn) => {
+    wheelFallbacks.current.add(fn);
+    return () => wheelFallbacks.current.delete(fn);
+  }, []);
+
+  return h(MouseContext.Provider, {
+    value: { enabled, supported, toggle, registerZone, registerWheelFallback },
+  }, children);
+}
+
+export function useMouse() {
+  const ctx = useContext(MouseContext);
+  return ctx
+    ? { enabled: ctx.enabled, supported: ctx.supported, toggle: ctx.toggle }
+    : { enabled: false, supported: false, toggle: () => {} };
+}
+
+export function useMouseWheel(handler) {
+  const ctx = useContext(MouseContext);
+  const ref = useRef(handler);
+  ref.current = handler;
+  useEffect(() => {
+    if (!ctx) return undefined;
+    return ctx.registerWheelFallback((ev) => ref.current?.(ev));
+  }, [ctx]);
+}
+
+// A Box whose on-screen rect is a mouse zone. All Box props pass through.
+export function Clickable({ onClick, onWheel, children, ...boxProps }) {
+  const ctx = useContext(MouseContext);
+  const ref = useRef(null);
+  const idRef = useRef(null);
+  if (idRef.current == null) idRef.current = `zone-${++zoneSeq}`;
+  const cbs = useRef({ onClick, onWheel });
+  cbs.current = { onClick, onWheel };
+  // Handler presence is fixed at mount (undefined→function post-mount is a no-op; remount to change).
+  // Handler identity stays fresh via cbs ref, so onClick/onWheel changes do not require re-registration.
+  useEffect(() => {
+    if (!ctx) return undefined;
+    return ctx.registerZone({
+      id: idRef.current,
+      ref,
+      onClick: cbs.current.onClick ? (ev) => cbs.current.onClick?.(ev) : cbs.current.onClick,
+      onWheel: cbs.current.onWheel ? (ev) => cbs.current.onWheel?.(ev) : cbs.current.onWheel,
+    });
+  }, [ctx]);
+  return h(Box, { ref, ...boxProps }, children);
+}

package/src/dashboard/run.js

@@ -0,0 +1,108 @@
+// Live full-screen dashboard — alternate screen until q / Ctrl+C.
+import React from 'react';
+import { render } from 'ink';
+import { App } from './App.js';
+import { MOUSE_DISABLE_ALL } from './mouse-protocol.js';
+import { getConfig } from '../settings.js';
+
+const h = React.createElement;
+
+// The alt-screen reset does NOT clear mouse tracking modes — a crash or
+// signal-kill without this leaves the user's shell with a hijacked mouse
+// (the lazygit #1764 / opencode #26198 failure class). `exit` doesn't fire
+// on signal default-kills and signal handlers don't cover process.exit(),
+// so install both. Idempotent: only the first install registers.
+let cleanupInstalled = false;
+export function installMouseCleanup(stdout = process.stdout) {
+  if (cleanupInstalled) return () => {};
+  cleanupInstalled = true;
+  let done = false;
+  const writeDisable = () => {
+    try { stdout.write(MOUSE_DISABLE_ALL); } catch { /* stream gone */ }
+  };
+  const off = () => {
+    if (done) return;
+    done = true;
+    writeDisable();
+  };
+  const onExit = () => off();
+  // process.exit() here routes through signal-exit's patched reallyExit
+  // (installed by Ink), which runs Ink's unmount — restoring the alt-screen —
+  // before the process actually terminates. Fragile coupling: if Ink ever
+  // stops patching reallyExit, exit() would terminate before unmount runs.
+  const onSignal = (sig) => () => {
+    off();
+    process.exit(sig === 'SIGINT' ? 130 : 143);
+  };
+  const onInt = onSignal('SIGINT');
+  const onTerm = onSignal('SIGTERM');
+  const onTstp = () => {
+    // Write mouse-off before ink suspends; MouseProvider re-enables on SIGCONT.
+    // Bypasses the `done` gate intentionally: SIGTSTP can fire repeatedly
+    // (stop/cont/stop) across a single process lifetime, unlike exit/INT/TERM.
+    writeDisable();
+    // Installing a SIGTSTP listener removes Node's default stop disposition,
+    // so an external `kill -TSTP` would otherwise no-op instead of suspending
+    // the process. Re-raise with SIGSTOP (uncatchable) to restore that
+    // behavior; SIGCONT resume re-enables the mouse via the provider's
+    // existing handler.
+    if (process.platform !== 'win32') process.kill(process.pid, 'SIGSTOP');
+  };
+  process.on('exit', onExit);
+  process.on('SIGINT', onInt);
+  process.on('SIGTERM', onTerm);
+  process.on('SIGTSTP', onTstp);
+  return () => {
+    done = true;
+    cleanupInstalled = false;
+    process.off('exit', onExit);
+    process.off('SIGINT', onInt);
+    process.off('SIGTERM', onTerm);
+    process.off('SIGTSTP', onTstp);
+  };
+}
+
+export function shouldUseDashboard({
+  force = null,
+  json = false,
+  isTTY = process.stdout?.isTTY && process.stdin?.isTTY,
+  env = process.env,
+} = {}) {
+  if (force === true) return true;
+  if (force === false) return false;
+  if (json) return false;
+  if (env.NO_COLOR != null && env.NO_COLOR !== '') return false;
+  if (env.CI === 'true' || env.CI === '1') return false;
+  if (env.TERM === 'dumb') return false;
+  return !!isTTY;
+}
+
+export async function runDashboard({ tab = 'status' } = {}) {
+  if (!shouldUseDashboard()) {
+    console.error('unsnooze dashboard: requires an interactive TTY (not a pipe/CI).');
+    // Still show the brand so users see the logo even when falling back
+    const { logoPlainText } = await import('./Logo.js');
+    console.error('\n' + logoPlainText() + '\n');
+    return 1;
+  }
+
+  installMouseCleanup(process.stdout);
+  const instance = render(h(App, { initialTab: tab, mouseEnabled: getConfig('mouse') !== false }), {
+    exitOnCtrlC: true,
+    // Full-screen: separate buffer like vim / htop / less — original scrollback restored on quit
+    alternateScreen: true,
+  });
+
+  await instance.waitUntilExit();
+  // Belt and braces: normal quit also clears modes (provider already did).
+  process.stdout.write(MOUSE_DISABLE_ALL);
+  return 0;
+}
+
+export async function cmdDashboard(args = []) {
+  const tabArg = args.find(a => !a.startsWith('-'));
+  const tab = ['status', 'usage', 'sessions', 'doctor', 'logs', 'fleet', 'prompts'].includes(tabArg)
+    ? tabArg
+    : 'status';
+  return runDashboard({ tab });
+}

package/src/dashboard/tabs/DoctorTab.js

@@ -0,0 +1,35 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import { theme } from '../theme.js';
+
+const h = React.createElement;
+
+export function DoctorTab({ data }) {
+  if (!data) return h(Text, { color: theme.muted }, 'Running checks…');
+  const legacy = data.findings.filter(f => f.kind === 'legacy');
+  const health = data.findings.filter(f => f.kind === 'health');
+  const info = data.findings.filter(f => f.kind === 'info');
+
+  if (data.healthy) {
+    return h(Box, { flexDirection: 'column' },
+      h(Text, { color: theme.ok }, '✓ install is healthy'),
+      ...info.map((f, i) => h(Text, { key: i, color: theme.muted }, `· ${f.title}`)),
+    );
+  }
+
+  return h(Box, { flexDirection: 'column' },
+    legacy.length ? h(Text, { color: theme.warn, bold: true }, 'legacy csg leftovers') : null,
+    ...legacy.map((f, i) => h(Box, { key: 'l' + i, flexDirection: 'column' },
+      h(Text, { color: theme.crit }, `✗ ${f.title}`),
+      f.detail ? h(Text, { color: theme.muted }, `  ${String(f.detail).split('\n')[0]}`) : null,
+    )),
+    health.length ? h(Text, { color: theme.warn, bold: true }, 'install health') : null,
+    ...health.map((f, i) => h(Box, { key: 'h' + i, flexDirection: 'column' },
+      h(Text, { color: theme.crit }, `✗ ${f.title}`),
+      f.detail ? h(Text, { color: theme.muted }, `  ${String(f.detail).split('\n')[0]}`) : null,
+    )),
+    ...info.map((f, i) => h(Text, { key: 'i' + i, color: theme.muted }, `· ${f.title}`)),
+    h(Text, null, ' '),
+    h(Text, { color: theme.muted }, 'Run `unsnooze doctor --fix` outside the dashboard to apply fixes.'),
+  );
+}

package/src/dashboard/tabs/FleetTab.js

@@ -0,0 +1,94 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import { fmtCountdown, flattenFleetStopped } from '../data.js';
+import { theme } from '../theme.js';
+import { Clickable } from '../mouse.js';
+import { attachHintRemote } from '../../fleet.js';
+
+const h = React.createElement;
+
+// Per-host auth badge: `key` (default) or `pw:<source>` (env/keychain/command/
+// prompt), so you can tell at a glance what a host authenticates with — and,
+// for a needs-auth host, why. Null when the descriptor is absent (legacy row).
+function authBadge(entry) {
+  if (!entry || !entry.auth) return null;
+  if (entry.auth === 'password') return `pw:${entry.source || 'prompt'}`;
+  return 'key';
+}
+
+// Host-header glyph/label/color for each fetchFleet() state.
+function hostHeader(r, now) {
+  if (r.state === 'online') {
+    const lat = r.latencyMs != null ? ` (${r.latencyMs}ms)` : '';
+    return { glyph: '●', color: theme.ok, label: `online${lat}` };
+  }
+  if (r.state === 'stale') {
+    const age = Number.isFinite(r.cachedAt) ? ` (${fmtCountdown(now - r.cachedAt)} old)` : '';
+    return { glyph: '◌', color: theme.muted, label: `stale${age}` };
+  }
+  if (r.state === 'skew') {
+    return { glyph: '△', color: theme.warn, label: 'version skew — update remote' };
+  }
+  if (r.state === 'needs-auth') {
+    return { glyph: '◐', color: theme.warn, label: `needs-auth${r.error ? ` (${r.error})` : ''}` };
+  }
+  if (r.state === 'unreachable') {
+    return { glyph: '○', color: theme.crit, label: `unreachable${r.error ? ` (${r.error})` : ''}` };
+  }
+  return { glyph: '○', color: theme.crit, label: `error${r.error ? ` (${r.error})` : ''}` };
+}
+
+export function FleetTab({ data, selected = 0, onSelect } = {}) {
+  if (!data) return h(Text, { color: theme.muted }, 'Loading…');
+  if (data.length === 0) {
+    return h(Box, { flexDirection: 'column' },
+      h(Text, { color: theme.muted }, 'No hosts registered.'),
+      h(Text, null, ' '),
+      h(Text, { color: theme.info }, '  unsnooze hosts add <name> [ssh-destination]'),
+    );
+  }
+
+  const now = Date.now();
+  // Shared with App.js's R/C keybinding math so the rendered order and the
+  // "selected row" the keys act on can never drift apart.
+  const indexOf = new Map(flattenFleetStopped(data).map((f, i) => [f.session, i]));
+
+  return h(Box, { flexDirection: 'column' },
+    h(Text, { color: theme.muted }, `${data.length} host(s)`),
+    h(Text, null, ' '),
+    ...data.map((r) => {
+      const head = hostHeader(r, now);
+      const badge = authBadge(r.entry);
+      const sessions = (r.envelope?.sessions ?? []).filter(s => s.status === 'stopped');
+      const queuedCount = (r.envelope?.queue ?? []).filter(e => e.status === 'pending' || e.status === 'launching').length;
+      return h(Box, { key: r.host, flexDirection: 'column', marginBottom: 1 },
+        h(Text, null,
+          h(Text, { color: head.color }, `${head.glyph} `),
+          h(Text, { color: theme.bright, bold: true }, r.host),
+          h(Text, { color: head.color }, ` ${head.label}`),
+          badge ? h(Text, { color: theme.muted, dimColor: true }, `  · ${badge}`) : null,
+          queuedCount > 0 ? h(Text, { color: theme.muted, dimColor: true }, `  · ${queuedCount} queued`) : null,
+        ),
+        sessions.length === 0
+          ? h(Text, { color: theme.muted, dimColor: true }, '    (no stopped sessions)')
+          : sessions.map((s) => {
+            const i = indexOf.get(s);
+            const sel = i === selected;
+            const id = s.sessionId ? s.sessionId.slice(0, 8) : (s.key ? s.key.slice(0, 8) : '(no id)');
+            const cd = Number.isFinite(s.resetAt) ? fmtCountdown(s.resetAt - now) : '?';
+            const hint = s.muxSession ? attachHintRemote(r.dest || r.host, s.mux || 'tmux', s.muxSession) : null;
+            return h(Clickable, { key: s.key || i, onClick: () => onSelect?.(i), flexDirection: 'column' },
+              h(Text, null,
+                h(Text, { color: theme.accent, bold: true }, sel ? '❯ ' : '  '),
+                h(Text, { color: theme.warn }, `● STOPPED `),
+                h(Text, { color: theme.bright, bold: sel }, ` ${id}`),
+                h(Text, { color: sel ? theme.bright : theme.muted }, `  ${(s.agent || 'claude').padEnd(6)}`),
+                h(Text, { color: theme.muted }, `  resets ${cd}`),
+              ),
+              hint ? h(Text, { color: theme.info }, `      attach: ${hint}`) : null,
+            );
+          }),
+      );
+    }),
+  );
+}

package/src/dashboard/tabs/LogsTab.js

@@ -0,0 +1,28 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import { theme } from '../theme.js';
+
+const h = React.createElement;
+
+export function LogsTab({ data, maxRows = 20, scroll = 0 }) {
+  if (!data) return h(Text, { color: theme.muted }, 'Loading logs…');
+  if (data.missing) return h(Text, { color: theme.muted }, `No log file yet (${data.path})`);
+  const fit = Math.max(1, maxRows - 2);
+  // Alt-screen has no scrollback — the wheel scrolls this window instead.
+  const maxScroll = Math.max(0, data.lines.length - fit);
+  const back = Math.min(scroll, maxScroll);
+  const end = data.lines.length - back;
+  const visible = data.lines.slice(Math.max(0, end - fit), end);
+  return h(Box, { flexDirection: 'column' },
+    h(Text, { color: theme.muted, dimColor: true },
+      data.path + (back > 0 ? `  · scrolled ↑${back} (wheel down for live tail)` : '')),
+    h(Text, null, ' '),
+    ...visible.map((line, i) =>
+      h(Text, {
+        key: i,
+        color: /\[hook\]|\[watcher\]/.test(line) ? theme.bright : theme.muted,
+        wrap: 'truncate-end',
+      }, line),
+    ),
+  );
+}