@addai/node 0.4.0 → 0.5.1

package/dist/tui/console-capture.js

@@ -7,20 +7,65 @@
 // every one of those lines lands in the middle of a frame, so the screen
 // appears to flicker between the UI and log output.
 //
-// Capturing rather than silencing: the lines are kept in a ring buffer, the
-// newest is surfaced in the UI, and the whole buffer is replayed to the real
-// stdout on exit, so running the daemon under the dashboard loses nothing
-// you would have seen without it.
+// Capturing rather than silencing: the lines are kept in a ring buffer that
+// the Logs screen reads, and appended to the daemon log file as they arrive.
+// Nothing is lost by running the daemon under the console — and because the
+// file is written live, nothing has to be dumped into your shell on the way
+// out either.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.captureConsole = captureConsole;
-const MAX_LINES = 500;
-function captureConsole() {
+const fs = __importStar(require("fs"));
+const MAX_LINES = 2000;
+function captureConsole(opts = {}) {
     const ring = [];
+    const listeners = [];
     const original = {
         log: console.log.bind(console),
         warn: console.warn.bind(console),
         error: console.error.bind(console),
     };
+    let sink = null;
+    if (opts.logFile) {
+        try {
+            sink = fs.openSync(opts.logFile, 'a');
+        }
+        catch {
+            sink = null;
+        }
+    }
     const format = (args) => args.map(a => {
         if (typeof a === 'string')
             return a;
@@ -34,9 +79,22 @@ function captureConsole() {
         }
     }).join(' ');
     const push = (level) => (...args) => {
-        ring.push({ level, text: format(args), at: Date.now() });
+        const line = { level, text: format(args), at: Date.now() };
+        ring.push(line);
         if (ring.length > MAX_LINES)
             ring.shift();
+        if (sink !== null) {
+            try {
+                fs.writeSync(sink, `${line.text}\n`);
+            }
+            catch { /* disk full, keep the UI alive */ }
+        }
+        for (const fn of listeners) {
+            try {
+                fn(line);
+            }
+            catch { /* a listener must never break logging */ }
+        }
     };
     console.log = push('log');
     console.warn = push('warn');
@@ -45,18 +103,18 @@ function captureConsole() {
         lines: () => [...ring],
         last: () => (ring.length ? ring[ring.length - 1] : null),
         count: () => ring.length,
-        restoreAndReplay() {
+        onLine(fn) { listeners.push(fn); },
+        restore() {
             console.log = original.log;
             console.warn = original.warn;
             console.error = original.error;
-            for (const l of ring) {
-                if (l.level === 'error')
-                    original.error(l.text);
-                else if (l.level === 'warn')
-                    original.warn(l.text);
-                else
-                    original.log(l.text);
+            if (sink !== null) {
+                try {
+                    fs.closeSync(sink);
+                }
+                catch { /* already gone */ }
             }
+            sink = null;
         },
     };
 }

package/dist/tui/dashboard.d.ts

@@ -1,9 +1,11 @@
+import { type AppHost, type Screen } from './app';
 import type { DataLayer, NodeSelf, NodeStats, RequestRow } from './data';
-import type { AppHost, Screen } from './app';
 export interface DashboardState {
     self: NodeSelf | null;
     stats: NodeStats | null;
-    requests: RequestRow[];
+    /** Recent requests, newest first — the NOW band reads the live ones off
+     *  the top and the idle line reads the most recent finish. */
+    recent: RequestRow[];
     sel: number;
     spin: number;
     pid: number | null;
@@ -14,24 +16,32 @@ export interface DashboardState {
     offline: boolean;
     now: number;
     version: string;
-    /** Newest line the daemon logged while the UI owned the screen. */
-    lastLog: string | null;
+    /** How many daemon log lines have been captured this session. */
     logCount: number;
 }
-export declare const FEED_ROWS = 12;
-/** Trigger sources are DB-shaped ('self_improve_distil'); the column is
- *  nine columns wide and "self_impr" tells you nothing. */
-export declare function shortVia(via: string | null | undefined): string;
-export declare function requestLine(r: RequestRow, now: number, selected: boolean, width: number): string;
-/** The landing screen's menu. Activity and Harnesses are places you go,
- *  not things that crowd the overview. */
+/** The landing screen's menu. */
 export declare const MENU: Array<{
     key: string;
     label: string;
     hint: string;
     shortcut: string;
 }>;
-export declare function renderDashboard(st: DashboardState, width: number): string[];
+/** Live rows the NOW band shows before it starts counting the rest. */
+export declare const MAX_NOW_ROWS = 6;
+export declare function liveRequests(rows: RequestRow[]): RequestRow[];
+/**
+ * The node's own state, as a label.
+ *
+ * A daemon is running — we either started it or the lockfile proved it — so
+ * the node IS online, whatever the server has got round to saying. Waiting
+ * for `runtime_self` to come back before admitting that meant the first
+ * second of every session claimed the node was in an unknown state.
+ */
+export declare function stateLabel(st: DashboardState): string;
+/** 1204 reads as a year; 1,204 reads as a count. */
+export declare function fmtCount(n: number | null | undefined): string;
+export declare function nowLines(st: DashboardState, width: number, rows: number): string[];
+export declare function renderDashboard(st: DashboardState, width: number, height: number): string[];
 export declare function createDashboardScreen(deps: {
     data: DataLayer;
     host: AppHost;
@@ -39,4 +49,5 @@ export declare function createDashboardScreen(deps: {
     openTranscript(r: RequestRow): void;
     openRequests(): void;
     openHarnesses(): void;
+    openLogs(): void;
 }): Screen;

package/dist/tui/dashboard.js

@@ -1,176 +1,209 @@
 "use strict";
-// Home screen: is this node alive, what has it been doing, what is it
-// doing right now.
+// The cockpit: is this node alive, what is it doing right now, and what has
+// it done today.
 //
-// Status vocabulary comes from the DB, where terminal success is
-// 'completed' and 'canceled' is a deliberate user action — shown apart
-// from failures so a healthy node isn't slandered by its own cancels.
+// The landing screen answers "is the box earning its keep" without a
+// keystroke. Everything that needs scrolling — history, harnesses, logs — is
+// a place you go, not something that crowds the overview.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MENU = exports.FEED_ROWS = void 0;
-exports.shortVia = shortVia;
-exports.requestLine = requestLine;
+exports.MAX_NOW_ROWS = exports.MENU = void 0;
+exports.liveRequests = liveRequests;
+exports.stateLabel = stateLabel;
+exports.fmtCount = fmtCount;
+exports.nowLines = nowLines;
 exports.renderDashboard = renderDashboard;
 exports.createDashboardScreen = createDashboardScreen;
 const render_1 = require("./render");
-exports.FEED_ROWS = 12;
-const ACTIVE = new Set(['pending', 'starting', 'running']);
-const CANCELLED = new Set(['canceled', 'cancelled']);
-/** Trigger sources are DB-shaped ('self_improve_distil'); the column is
- *  nine columns wide and "self_impr" tells you nothing. */
-function shortVia(via) {
-    if (!via)
-        return '—';
-    const map = {
-        self_improve_distil: 'distil',
-        self_improve: 'improve',
-        entity_chat: 'chat',
-        chat: 'chat',
-        schedule: 'schedule',
-        flow: 'flow',
-        api: 'api',
-        studio: 'studio',
-    };
-    return map[via] ?? via;
-}
-function statusLabel(status) {
-    if (status === 'completed')
-        return 'DONE';
-    if (CANCELLED.has(status))
-        return 'CANCEL';
-    return status.toUpperCase();
-}
-function statusCell(status) {
-    const label = statusLabel(status).padEnd(8).slice(0, 8);
-    if (ACTIVE.has(status))
-        return (0, render_1.cyan)(label);
-    if (status === 'completed')
-        return (0, render_1.green)(label);
-    if (CANCELLED.has(status))
-        return (0, render_1.grey)(label);
-    return (0, render_1.red)(label);
-}
-function dot(status) {
-    if (ACTIVE.has(status))
-        return (0, render_1.cyan)('⏺');
-    if (status === 'completed')
-        return (0, render_1.green)('⏺');
-    if (CANCELLED.has(status))
-        return (0, render_1.grey)('⏺');
-    return (0, render_1.red)('⏺');
-}
-function durationOf(r, now) {
-    const start = r.picked_up_at ?? r.created_at;
-    if (!start)
-        return null;
-    const end = r.finished_at ? new Date(r.finished_at).getTime() : now;
-    return Math.max(0, end - new Date(start).getTime());
+const request_row_1 = require("./request-row");
+const app_1 = require("./app");
+/** The landing screen's menu. */
+exports.MENU = [
+    { key: 'activity', label: 'Activity', hint: 'Every request this node has handled', shortcut: 'a' },
+    { key: 'harnesses', label: 'Harnesses', hint: 'Install / log in agent CLIs', shortcut: 'h' },
+    { key: 'logs', label: 'Logs', hint: 'What the daemon is saying', shortcut: 'l' },
+];
+/** Live rows the NOW band shows before it starts counting the rest. */
+exports.MAX_NOW_ROWS = 6;
+function liveRequests(rows) {
+    return rows.filter(r => request_row_1.ACTIVE.has(r.status));
 }
-function requestLine(r, now, selected, width) {
-    const entity = (0, render_1.padEndVisible)((0, render_1.truncate)(r.entity_name ?? '—', 12), 12);
-    const agent = `${r.agent}/${r.mode}`.padEnd(12).slice(0, 12);
-    const model = (r.model ?? '—').replace(/^claude-/, '').padEnd(7).slice(0, 7);
-    const via = shortVia(r.issued_via).padEnd(9).slice(0, 9);
-    const dur = (0, render_1.fmtDuration)(durationOf(r, now)).padStart(7);
-    // A run that failed once and then succeeded on retry still carries the
-    // old error_code. Showing it on a DONE row reads as "this broke" when
-    // the work actually landed — so the code is only for rows that ended badly.
-    const ended_badly = r.status !== 'completed' && !ACTIVE.has(r.status);
-    const tail = r.error_code && ended_badly
-        ? (0, render_1.red)(`[${r.error_code}]`)
-        : (r.prompt ?? '').replace(/\s+/g, ' ');
-    const prefix = `${dot(r.status)} ${statusCell(r.status)} ${entity} ${(0, render_1.dim)(agent)} ${(0, render_1.dim)(model)} ${(0, render_1.dim)(via)} ${dur}  `;
-    const room = Math.max(8, width - 2 - (0, render_1.visibleWidth)(prefix));
-    const line = `${prefix}${(0, render_1.truncate)(tail, room)}`;
-    return selected ? `${(0, render_1.cyan)('❯')} ${line}` : `  ${line}`;
+/**
+ * The node's own state, as a label.
+ *
+ * A daemon is running — we either started it or the lockfile proved it — so
+ * the node IS online, whatever the server has got round to saying. Waiting
+ * for `runtime_self` to come back before admitting that meant the first
+ * second of every session claimed the node was in an unknown state.
+ */
+function stateLabel(st) {
+    const reported = st.self?.effective_status;
+    if (!reported)
+        return (0, render_1.green)('Online');
+    if (reported === 'online')
+        return (0, render_1.green)('Online');
+    return (0, render_1.yellow)(reported.charAt(0).toUpperCase() + reported.slice(1));
 }
 function headerLines(st) {
     if (!st.paired) {
         return [
-            (0, render_1.yellow)('not paired'),
+            (0, render_1.yellow)('Not paired'),
             (0, render_1.dim)('run `ainode` and follow the prompt to vault.add.ai/entity/connect/<CODE>'),
         ];
     }
     const self = st.self;
-    const name = self?.name ?? self?.hostname ?? 'this node';
-    const state = self?.effective_status === 'online'
-        ? (0, render_1.green)('online')
-        : (0, render_1.yellow)(self?.effective_status ?? 'unknown');
+    const name = self?.name ?? self?.hostname ?? 'This node';
     const paired = self?.created_at ? `paired ${(0, render_1.fmtRelative)(self.created_at, st.now)}` : '';
-    const first = `${(0, render_1.bold)(name)} ${(0, render_1.dim)('·')} ${state} ${(0, render_1.dim)('·')} ${(0, render_1.dim)(paired)}`;
+    const first = `${(0, render_1.bold)(name)} ${(0, render_1.dim)('·')} ${stateLabel(st)}${paired ? ` ${(0, render_1.dim)('·')} ${(0, render_1.dim)(paired)}` : ''}`;
     const up = st.startedAt ? (0, render_1.fmtDuration)(st.now - st.startedAt) : '—';
     const daemon = st.viewerMode
-        ? `${(0, render_1.cyan)('⏺')} viewer ${(0, render_1.dim)('· another ainode owns this node')}  ${(0, render_1.dim)(`pid ${st.pid ?? '?'}`)}`
-        : `${(0, render_1.green)('⏺')} running  ${(0, render_1.dim)(`pid ${st.pid ?? '?'}`)}  ${(0, render_1.dim)(`up ${up}`)}  ${(0, render_1.dim)(`${st.inflight} in flight`)}`;
-    const chip = st.offline ? `  ${(0, render_1.yellow)('⚠ offline · retrying')}` : '';
+        ? `${(0, render_1.cyan)('⏺')} Viewer  ${(0, render_1.dim)(`pid ${st.pid ?? '?'}`)}  ${(0, render_1.dim)('· another process owns this node')}`
+        : `${(0, render_1.green)('⏺')} Running  ${(0, render_1.dim)(`pid ${st.pid ?? '?'}`)}  ${(0, render_1.dim)(`up ${up}`)}  ${(0, render_1.dim)(`${st.inflight} in flight`)}`;
+    const chip = st.offline ? `  ${(0, render_1.yellow)('⚠ Offline · retrying')}` : '';
     return [first, daemon + chip];
 }
+/** 1204 reads as a year; 1,204 reads as a count. */
+function fmtCount(n) {
+    if (n == null)
+        return '—';
+    return String(n).replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
+/** A labelled figure, padded so the labels line up down the screen. */
+function stat(label, value, width = 14) {
+    return (0, render_1.padEndVisible)(`${(0, render_1.dim)(label)} ${value}`, width);
+}
 function statsLines(st) {
     const s = st.stats;
-    if (!s)
-        return [(0, render_1.dim)('stats unavailable')];
+    // Keep the shape while the first fetch is in flight, so the band doesn't
+    // pop into place a second after the header.
+    if (!s) {
+        return [
+            `${stat('Today', (0, render_1.dim)('—'))}${stat('24h', (0, render_1.dim)('—'), 26)}${stat('Avg', (0, render_1.dim)('—'))}`,
+            `${stat('Week', (0, render_1.dim)('—'))}${stat('Month', (0, render_1.dim)('—'), 26)}${stat('Total', (0, render_1.dim)('—'))}`,
+        ];
+    }
     const agents = Object.entries(s.by_agent)
         .sort((a, b) => b[1] - a[1])
-        .map(([k, v]) => `${k} ${v}`)
-        .join(' · ');
-    const cancels = s.canceled_24h ? (0, render_1.dim)(`  ${s.canceled_24h} cancelled`) : '';
-    // The ✓/✗/avg figures are a rolling 24h window while "Today" is the
-    // calendar day, so they are labelled — otherwise ✓3 next to Today 2
-    // looks like an arithmetic bug.
+        .map(([k, v]) => `${k.charAt(0).toUpperCase()}${k.slice(1)} ${fmtCount(v)}`)
+        .join((0, render_1.dim)(' · '));
+    // The ✓/✗ figures are a rolling 24h window while "Today" is the calendar
+    // day, so the window is labelled — otherwise ✓3 next to Today 2 looks
+    // like an arithmetic bug.
+    const outcomes = [
+        (0, render_1.green)(`✓ ${fmtCount(s.succeeded_24h)}`),
+        s.failed_24h ? (0, render_1.red)(`✗ ${fmtCount(s.failed_24h)}`) : (0, render_1.dim)('✗ 0'),
+        s.canceled_24h ? (0, render_1.grey)(`⊘ ${fmtCount(s.canceled_24h)}`) : '',
+    ].filter(Boolean).join('  ');
+    // Both rows share one three-column grid, so Month sits under 24h and
+    // Total under Avg rather than the two rows drifting apart.
     return [
-        `${(0, render_1.bold)(`Today ${s.today}`)}   ${(0, render_1.dim)('·')}   ${(0, render_1.dim)('24h')} ${(0, render_1.green)(`✓ ${s.succeeded_24h}`)}  ${s.failed_24h ? (0, render_1.red)(`✗ ${s.failed_24h}`) : (0, render_1.dim)('✗ 0')}${cancels}   ${(0, render_1.dim)(`avg ${(0, render_1.fmtDuration)(s.avg_duration_ms)}`)}   ${(0, render_1.dim)(agents)}`,
-        (0, render_1.dim)(`Week ${s.week}   Month ${s.month}   Total ${s.total}`),
+        `${stat('Today', (0, render_1.bold)(fmtCount(s.today)))}${stat('24h', outcomes, 26)}${stat('Avg', (0, render_1.fmtDuration)(s.avg_duration_ms))}`,
+        `${stat('Week', fmtCount(s.week))}${stat('Month', fmtCount(s.month), 26)}${stat('Total', fmtCount(s.total))}${(0, render_1.dim)(agents)}`,
     ];
 }
-/** The landing screen's menu. Activity and Harnesses are places you go,
- *  not things that crowd the overview. */
-exports.MENU = [
-    { key: 'activity', label: 'Activity', hint: 'requests this node has handled', shortcut: 'a' },
-    { key: 'harnesses', label: 'Harnesses', hint: 'install / log in agent CLIs', shortcut: 'h' },
-];
-function renderDashboard(st, width) {
-    const out = [];
-    out.push(...(0, render_1.panel)(`+Ai Node ${(0, render_1.dim)(`ainode v${st.version}`)}`, headerLines(st), width));
-    out.push('');
-    if (st.paired) {
-        out.push(...statsLines(st).map(l => `  ${l}`));
-        out.push('');
-        exports.MENU.forEach((m, i) => {
-            const selected = i === st.sel;
-            const label = selected ? (0, render_1.bold)(m.label.padEnd(12)) : m.label.padEnd(12);
-            const marker = selected ? (0, render_1.cyan)('❯') : ' ';
-            out.push(`${marker} ${label} ${(0, render_1.dim)(m.hint)}   ${(0, render_1.dim)(m.shortcut)}`);
-        });
+/** The most recent request that actually finished, for the idle line. */
+function lastFinished(rows) {
+    return rows.find(r => r.finished_at) ?? null;
+}
+function nowLines(st, width, rows) {
+    const live = liveRequests(st.recent);
+    const out = [`  ${(0, render_1.bold)('Now')}`];
+    if (live.length === 0) {
+        const last = lastFinished(st.recent);
+        out.push(last
+            ? (0, render_1.dim)(`  Idle — last run finished ${(0, render_1.fmtRelative)(last.finished_at, st.now)}`)
+            : (0, render_1.dim)('  Idle'));
+        return out;
+    }
+    out.push((0, request_row_1.requestHeader)(width));
+    const shown = live.slice(0, Math.max(1, rows));
+    shown.forEach(r => out.push((0, request_row_1.requestLine)(r, st.now, false, width, st.spin)));
+    if (live.length > shown.length) {
+        out.push((0, render_1.dim)(`     +${live.length - shown.length} more running`));
     }
-    out.push('');
-    if (st.lastLog) {
-        out.push((0, render_1.dim)(`  log  ${st.lastLog}`));
-        if (st.logCount > 1)
-            out.push((0, render_1.dim)(`       ${st.logCount} lines captured — printed on exit`));
+    return out;
+}
+function renderDashboard(st, width, height) {
+    const head = (0, render_1.panel)(`+Ai Node ${(0, render_1.dim)(`@addai/node v${st.version}`)}`, headerLines(st), width);
+    if (!st.paired) {
+        return [...head, '', (0, app_1.footerHint)([{ keys: 'q', label: 'quit' }])].slice(0, height);
     }
-    out.push('');
-    out.push((0, render_1.dim)('  ↑↓ move   ⏎ open   r refresh   q quit'));
-    return out.map(l => (0, render_1.truncate)(l, width));
+    const stats = statsLines(st).map(l => `  ${l}`);
+    // The shortcut letters line up in a column of their own, so the eye can
+    // find them without reading the hints.
+    const hintWidth = Math.max(...exports.MENU.map(m => m.hint.length)) + 2;
+    const menu = exports.MENU.map((m, i) => {
+        const selected = i === st.sel;
+        const label = selected ? (0, render_1.bold)(m.label.padEnd(11)) : m.label.padEnd(11);
+        const cursor = selected ? (0, render_1.cyan)('❯') : ' ';
+        const badge = m.key === 'logs' && st.logCount ? `${st.logCount} lines` : '';
+        return `${cursor} ${label} ${(0, render_1.dim)(m.hint.padEnd(hintWidth))}${(0, render_1.dim)(badge.padEnd(10))}${(0, render_1.dim)(m.shortcut)}`;
+    });
+    const foot = (0, app_1.footerHint)([
+        { keys: '↑↓', label: 'move' },
+        { keys: '⏎', label: 'open' },
+        { keys: 'r', label: 'refresh' },
+        { keys: '?', label: 'keys' },
+        { keys: 'q', label: 'quit' },
+    ]);
+    // Everything but the NOW band is fixed height, so the band takes what is
+    // left: heading + header row + rows + the "+N more" line.
+    const fixed = head.length + 1 + stats.length + 1 + 3 + 1 + menu.length + 1 + 1;
+    const room = Math.min(exports.MAX_NOW_ROWS, Math.max(1, height - fixed));
+    return [
+        ...head,
+        '',
+        ...stats,
+        '',
+        ...nowLines(st, width, room),
+        '',
+        ...menu,
+        '',
+        foot,
+    ].map(l => (0, render_1.truncate)(l, width)).slice(0, height);
 }
 function createDashboardScreen(deps) {
     const st = deps.state;
-    // The landing screen shows identity and numbers only, so it fetches two
-    // rows of counters — not the request feed. Activity pages that in itself.
     const refresh = async () => {
         st.now = Date.now();
-        const [self, stats] = await Promise.all([deps.data.self(), deps.data.stats()]);
+        const [self, stats, recent] = await Promise.all([
+            deps.data.self(),
+            deps.data.stats(),
+            // Enough rows to hold every plausible concurrent run plus something
+            // finished for the idle line, and small enough to poll every 2s.
+            deps.data.requests({ limit: 20 }),
+        ]);
         if (self)
             st.self = self;
         if (stats)
             st.stats = stats;
+        if (recent.length)
+            st.recent = recent;
         st.offline = deps.data.offline();
         deps.host.redraw();
     };
     return {
         id: 'dashboard',
         title: '+Ai Node',
-        render: (width) => renderDashboard(st, width),
-        pollMs: () => (st.stats && st.stats.active > 0 ? 2000 : 5000),
+        render: (width, height) => renderDashboard(st, width, height),
+        // Poll hard while something is moving; an idle node doesn't need traffic.
+        pollMs: () => (liveRequests(st.recent).length > 0 || st.inflight > 0 ? 2000 : 5000),
         poll: refresh,
+        tick(n) {
+            st.spin = n;
+            // Only the NOW band animates, and only when something is in it.
+            if (liveRequests(st.recent).length === 0)
+                return false;
+            st.now = Date.now();
+            return true;
+        },
+        keys: () => [
+            { keys: '↑↓ / jk', label: 'move between destinations' },
+            { keys: '⏎', label: 'open the selected destination' },
+            { keys: 'a', label: 'activity — full request history' },
+            { keys: 'h', label: 'harnesses — install / log in agent CLIs' },
+            { keys: 'l', label: 'logs — daemon output' },
+            { keys: 'r', label: 'refresh now' },
+        ],
         async onKey(key) {
             if (key.name === 'up' || key.name === 'k') {
                 st.sel = Math.max(0, st.sel - 1);
@@ -190,13 +223,20 @@ function createDashboardScreen(deps) {
                 deps.openHarnesses();
                 return;
             }
+            if (key.name === 'l') {
+                deps.openLogs();
+                return;
+            }
             if (key.name === 'r') {
                 await refresh();
                 return;
             }
             if (key.name === 'return') {
-                if (exports.MENU[st.sel]?.key === 'harnesses')
+                const target = exports.MENU[st.sel]?.key;
+                if (target === 'harnesses')
                     deps.openHarnesses();
+                else if (target === 'logs')
+                    deps.openLogs();
                 else
                     deps.openRequests();
             }

package/dist/tui/harnesses.d.ts

@@ -1,16 +1,53 @@
+import { type HarnessId } from '../harness-registry';
+import { type AppHost, type Screen } from './app';
+export type Probe = {
+    available?: boolean;
+    authed?: boolean;
+    version?: string;
+    account?: string;
+    plan?: string;
+    accountKind?: string;
+    models?: string[];
+};
+export type Caps = Record<string, Probe>;
+export interface HarnessesState {
+    caps: Caps | null;
+    sel: number;
+    spin: number;
+    /** Spinner label while an action runs; null when idle. */
+    busy: string | null;
+    /** Enter on an authed row arms this; y fires it. */
+    confirmLogout: HarnessId | null;
+    /** Tail of an install's npm output. */
+    log: string[];
+    note: string | null;
+}
+export declare function actionFor(id: HarnessId, p: Probe | undefined): string;
 /**
- * Run the harness manager.
- *
- * The returned promise resolves when the USER LEAVES the screen — not when
- * the first capability probe finishes. Resolving early is what made the
- * embedded case flicker: the dashboard re-attached its own keypress handler
- * and repainted while this screen was still live, and the two fought over
- * the terminal.
+ * Harness CLIs report their version in whatever shape they feel like:
+ * `2.1.220 (Claude Code)`, `codex-cli 0.139.0`, `0.52.0`. Prefixing all of
+ * those with a `v` produced `vcodex-cli 0.139.0`. Pull out the version
+ * itself and leave the branding to the label column.
+ */
+export declare function formatVersion(v: string | undefined): string;
+export declare function accountLabel(p: Probe | undefined): string;
+/**
+ * Column widths.
  *
- * `embedded` distinguishes `ainode harnesses` (q exits the process) from
- * the dashboard's `h` (q hands control back to the caller). Ctrl-C always
- * ends the process.
+ * The account and the effort ladder vary most, so they take the spare width;
+ * version and action are fixed at what their values actually need. The old
+ * fixed widths cut `codex-cli` down to `vcodex-cli` and
+ * `low/medium/high/xhigh` to `low/medium/high/x`.
  */
-export declare function runHarnessesTui(opts?: {
-    embedded?: boolean;
-}): Promise<void>;
+export declare function harnessColumns(width: number): number[];
+export declare function harnessRow(id: HarnessId, p: Probe | undefined, selected: boolean, width: number): string;
+export declare function renderHarnesses(st: HarnessesState, width: number, height: number): string[];
+export declare function logoutSelected(id: HarnessId): string | null;
+export declare function createHarnessesScreen(deps: {
+    host: AppHost;
+    /** Hand the raw terminal to a vendor CLI, then take it back. */
+    suspend(fn: () => void | Promise<void>): Promise<void>;
+    probe?: () => Promise<Caps>;
+}): Screen;
+/** `ainode harnesses` on a pipe: no screen, just the facts. */
+export declare function plainStatus(): Promise<void>;