@addai/node 0.4.0 → 0.5.1

package/dist/tui/render.d.ts

@@ -4,6 +4,26 @@ export declare function visibleWidth(s: string): number;
 /** Cut to `max` VISIBLE columns, ellipsis included in the budget. */
 export declare function truncate(s: string, max: number): string;
 export declare function padEndVisible(s: string, width: number): string;
+export declare function padStartVisible(s: string, width: number): string;
+/** A column that takes what it needs, or grows to absorb what's spare. */
+export interface ColumnSpec {
+    /** Columns narrower than this are unreadable, so they are never cut below it. */
+    min: number;
+    /** Share of the leftover width. 0 (the default) means fixed at `min`. */
+    grow?: number;
+}
+/**
+ * Split `width` across columns.
+ *
+ * Fixed columns are served first and always get their `min`. Whatever is left
+ * over after the gaps is handed to the growing columns in proportion to their
+ * `grow` — so a table clips the prompt, never the version or the account.
+ * When the terminal is too narrow for even the minimums, every column shrinks
+ * proportionally rather than the last one falling off the edge.
+ */
+export declare function layoutColumns(specs: ColumnSpec[], width: number, gap?: number): number[];
+/** Lay cells into `widths`, truncating and padding each to fit exactly. */
+export declare function tableRow(cells: string[], widths: number[], align?: Array<'left' | 'right'>, gap?: number): string;
 export declare const dim: (s: string) => string;
 export declare const bold: (s: string) => string;
 export declare const green: (s: string) => string;
@@ -19,3 +39,23 @@ export declare function fmtDuration(ms: number | null): string;
 export declare const altOn: () => void;
 export declare const altOff: () => void;
 export declare const home: () => void;
+export declare function termHeight(): number;
+export interface Painter {
+    /** Write only what changed since the last frame. */
+    paint(lines: string[]): void;
+    /** Force the next paint to clear and redraw everything (resize, resume). */
+    invalidate(): void;
+}
+/**
+ * Frames are painted as a diff against the last one.
+ *
+ * The screen used to be erased (`ESC[2J`) before every frame, and with the
+ * spinner redrawing eight times a second while work is in flight, that is a
+ * full clear-and-repaint eight times a second — the flicker you can see from
+ * across the room. Almost nothing changes between those frames: a spinner
+ * glyph and a duration. So keep the last frame, compare line by line, and
+ * touch only the rows that actually moved.
+ *
+ * `write` is injected so the painter can be unit-tested without a TTY.
+ */
+export declare function createPainter(write: (s: string) => void): Painter;

package/dist/tui/render.js

@@ -11,10 +11,15 @@ exports.stripAnsi = stripAnsi;
 exports.visibleWidth = visibleWidth;
 exports.truncate = truncate;
 exports.padEndVisible = padEndVisible;
+exports.padStartVisible = padStartVisible;
+exports.layoutColumns = layoutColumns;
+exports.tableRow = tableRow;
 exports.termWidth = termWidth;
 exports.panel = panel;
 exports.fmtRelative = fmtRelative;
 exports.fmtDuration = fmtDuration;
+exports.termHeight = termHeight;
+exports.createPainter = createPainter;
 const E = '\x1b[';
 exports.SPIN = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 /** Not global: a /g regex carries lastIndex between calls and would make
@@ -59,6 +64,58 @@ function padEndVisible(s, width) {
     const pad = Math.max(0, width - visibleWidth(s));
     return s + ' '.repeat(pad);
 }
+function padStartVisible(s, width) {
+    const pad = Math.max(0, width - visibleWidth(s));
+    return ' '.repeat(pad) + s;
+}
+/**
+ * Split `width` across columns.
+ *
+ * Fixed columns are served first and always get their `min`. Whatever is left
+ * over after the gaps is handed to the growing columns in proportion to their
+ * `grow` — so a table clips the prompt, never the version or the account.
+ * When the terminal is too narrow for even the minimums, every column shrinks
+ * proportionally rather than the last one falling off the edge.
+ */
+function layoutColumns(specs, width, gap = 1) {
+    if (specs.length === 0)
+        return [];
+    const gaps = gap * (specs.length - 1);
+    const mins = specs.map(s => Math.max(0, s.min));
+    const totalMin = mins.reduce((a, b) => a + b, 0);
+    const room = Math.max(0, width - gaps);
+    if (totalMin > room) {
+        const scale = room / (totalMin || 1);
+        return mins.map(m => Math.max(1, Math.floor(m * scale)));
+    }
+    const totalGrow = specs.reduce((a, s) => a + (s.grow ?? 0), 0);
+    let spare = room - totalMin;
+    if (totalGrow === 0 || spare === 0)
+        return mins;
+    // The last growing column takes the remainder, so rounding never loses a
+    // column of width off the right-hand edge.
+    let lastGrowing = -1;
+    specs.forEach((s, i) => { if ((s.grow ?? 0) > 0)
+        lastGrowing = i; });
+    return mins.map((m, i) => {
+        const grow = specs[i].grow ?? 0;
+        if (grow === 0)
+            return m;
+        const share = i === lastGrowing ? spare : Math.floor((spare * grow) / totalGrow);
+        spare -= share;
+        return m + share;
+    });
+}
+/** Lay cells into `widths`, truncating and padding each to fit exactly. */
+function tableRow(cells, widths, align = [], gap = 1) {
+    return cells
+        .map((c, i) => {
+        const w = widths[i] ?? 0;
+        const cut = truncate(c, w);
+        return align[i] === 'right' ? padStartVisible(cut, w) : padEndVisible(cut, w);
+    })
+        .join(' '.repeat(gap));
+}
 const wrapCode = (on, off) => (s) => `${E}${on}${s}${E}${off}`;
 exports.dim = wrapCode('2m', '22m');
 exports.bold = wrapCode('1m', '22m');
@@ -114,3 +171,45 @@ const altOff = () => { process.stdout.write(`${E}?1049l${E}?25h`); };
 exports.altOff = altOff;
 const home = () => { process.stdout.write(`${E}H${E}2J`); };
 exports.home = home;
+function termHeight() {
+    return Math.max(10, process.stdout.rows || 30);
+}
+/**
+ * Frames are painted as a diff against the last one.
+ *
+ * The screen used to be erased (`ESC[2J`) before every frame, and with the
+ * spinner redrawing eight times a second while work is in flight, that is a
+ * full clear-and-repaint eight times a second — the flicker you can see from
+ * across the room. Almost nothing changes between those frames: a spinner
+ * glyph and a duration. So keep the last frame, compare line by line, and
+ * touch only the rows that actually moved.
+ *
+ * `write` is injected so the painter can be unit-tested without a TTY.
+ */
+function createPainter(write) {
+    let prev = [];
+    let full = true;
+    return {
+        invalidate() { full = true; },
+        paint(lines) {
+            let out = '';
+            if (full) {
+                out += `${E}H${E}2J`;
+                prev = [];
+                full = false;
+            }
+            const rows = Math.max(lines.length, prev.length);
+            for (let i = 0; i < rows; i++) {
+                const next = lines[i] ?? '';
+                if (prev[i] === next)
+                    continue;
+                // Position, write, and erase whatever the previous, longer line left
+                // behind on that row.
+                out += `${E}${i + 1};1H${next}${E}K`;
+            }
+            prev = lines.slice();
+            if (out)
+                write(out);
+        },
+    };
+}

package/dist/tui/request-row.d.ts

@@ -0,0 +1,35 @@
+import type { RequestRow } from './data';
+export declare const ACTIVE: Set<string>;
+export declare const CANCELLED: Set<string>;
+/**
+ * Trigger sources are DB-shaped ('self_improve_distil', 'tables_trigger');
+ * the column is nine columns wide and 'self_impr' tells you nothing.
+ *
+ * Anything unmapped is shortened by rule rather than cut mid-word: the
+ * 'entity_' prefix and the '_trigger' suffix carry no information a reader of
+ * this column needs.
+ */
+export declare function shortVia(via: string | null | undefined): string;
+/**
+ * Model ids carry a vendor prefix and a release date the column has no room
+ * for: `claude-haiku-4-5-20251001` was rendering as `haiku-4-…`, which loses
+ * the one part you were reading it for.
+ */
+export declare function shortModel(model: string | null | undefined): string;
+export declare function statusLabel(status: string): string;
+export declare function statusColour(status: string): (s: string) => string;
+/** Live rows get a moving spinner; settled rows get a dot. */
+export declare function marker(status: string, spin: number): string;
+export declare function durationOf(r: RequestRow, now: number): number | null;
+/**
+ * Column widths for the request table.
+ *
+ * The two columns that carry names — the entity and the prompt — grow into
+ * whatever the terminal has spare, and the prompt takes the larger share
+ * because it is the only free text on the row. Everything else is fixed at
+ * the width its values actually need, so a version or a duration is never
+ * the thing that gets cut.
+ */
+export declare function requestColumns(width: number): number[];
+export declare function requestHeader(width: number): string;
+export declare function requestLine(r: RequestRow, now: number, selected: boolean, width: number, spin?: number): string;

package/dist/tui/request-row.js

@@ -0,0 +1,144 @@
+"use strict";
+// One request, rendered as a row — shared by the cockpit's NOW band and the
+// Activity screen so the two never drift apart.
+//
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CANCELLED = exports.ACTIVE = void 0;
+exports.shortVia = shortVia;
+exports.shortModel = shortModel;
+exports.statusLabel = statusLabel;
+exports.statusColour = statusColour;
+exports.marker = marker;
+exports.durationOf = durationOf;
+exports.requestColumns = requestColumns;
+exports.requestHeader = requestHeader;
+exports.requestLine = requestLine;
+const render_1 = require("./render");
+exports.ACTIVE = new Set(['pending', 'starting', 'running']);
+exports.CANCELLED = new Set(['canceled', 'cancelled']);
+/**
+ * Trigger sources are DB-shaped ('self_improve_distil', 'tables_trigger');
+ * the column is nine columns wide and 'self_impr' tells you nothing.
+ *
+ * Anything unmapped is shortened by rule rather than cut mid-word: the
+ * 'entity_' prefix and the '_trigger' suffix carry no information a reader of
+ * this column needs.
+ */
+function shortVia(via) {
+    if (!via)
+        return '—';
+    const map = {
+        self_improve_distil: 'distil',
+        self_improve: 'improve',
+        entity_chat: 'chat',
+        chat: 'chat',
+        chatflows: 'chatflow',
+        entity_schedule: 'schedule',
+        schedule: 'schedule',
+        tables_trigger: 'tables',
+        skillflow: 'skillflow',
+        flow: 'flow',
+        api: 'api',
+        studio: 'studio',
+        widget: 'widget',
+    };
+    if (map[via])
+        return map[via];
+    return via.replace(/^entity_/, '').replace(/_trigger$/, '');
+}
+/**
+ * Model ids carry a vendor prefix and a release date the column has no room
+ * for: `claude-haiku-4-5-20251001` was rendering as `haiku-4-…`, which loses
+ * the one part you were reading it for.
+ */
+function shortModel(model) {
+    if (!model)
+        return '—';
+    return model.replace(/^claude-/, '').replace(/-\d{8}$/, '');
+}
+function statusLabel(status) {
+    if (status === 'completed')
+        return 'Done';
+    if (exports.CANCELLED.has(status))
+        return 'Cancelled';
+    if (status === 'dead_letter')
+        return 'Dead';
+    return status.charAt(0).toUpperCase() + status.slice(1);
+}
+function statusColour(status) {
+    if (exports.ACTIVE.has(status))
+        return render_1.cyan;
+    if (status === 'completed')
+        return render_1.green;
+    if (exports.CANCELLED.has(status))
+        return render_1.grey;
+    return render_1.red;
+}
+/** Live rows get a moving spinner; settled rows get a dot. */
+function marker(status, spin) {
+    const colour = statusColour(status);
+    return colour(exports.ACTIVE.has(status) ? render_1.SPIN[spin % render_1.SPIN.length] : '⏺');
+}
+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());
+}
+/**
+ * Column widths for the request table.
+ *
+ * The two columns that carry names — the entity and the prompt — grow into
+ * whatever the terminal has spare, and the prompt takes the larger share
+ * because it is the only free text on the row. Everything else is fixed at
+ * the width its values actually need, so a version or a duration is never
+ * the thing that gets cut.
+ */
+function requestColumns(width) {
+    // marker, status, entity, agent/mode, model, via, duration, prompt
+    return (0, render_1.layoutColumns)([
+        { min: 1 },
+        // 'Cancelled' is the longest label; anything shorter than it clips the
+        // status, which is the one column that must never be ambiguous.
+        { min: 9 },
+        { min: 10, grow: 1 },
+        { min: 12 },
+        // 'haiku-4-5' is nine columns once the claude- prefix is stripped.
+        { min: 9 },
+        { min: 8 },
+        { min: 7 },
+        { min: 12, grow: 3 },
+    ], Math.max(40, width - 2));
+}
+const ALIGN = ['left', 'left', 'left', 'left', 'left', 'left', 'right', 'left'];
+function requestHeader(width) {
+    const w = requestColumns(width);
+    return (0, render_1.dim)('  ' + (0, render_1.tableRow)(['', 'Status', 'Entity', 'Agent', 'Model', 'Via', 'Dur', 'Prompt'], w, ALIGN));
+}
+function requestLine(r, now, selected, width, spin = 0) {
+    const w = requestColumns(width);
+    const colour = statusColour(r.status);
+    // 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 endedBadly = r.status !== 'completed' && !exports.ACTIVE.has(r.status);
+    const tail = r.error_code && endedBadly
+        ? (0, render_1.red)(`[${r.error_code}]`)
+        : (r.prompt ?? '').replace(/\s+/g, ' ');
+    const cells = [
+        marker(r.status, spin),
+        colour(statusLabel(r.status)),
+        r.entity_name ?? '—',
+        (0, render_1.dim)(`${r.agent}/${r.mode}`),
+        (0, render_1.dim)(shortModel(r.model)),
+        (0, render_1.dim)(shortVia(r.issued_via)),
+        (0, render_1.dim)((0, render_1.fmtDuration)(durationOf(r, now))),
+        tail,
+    ];
+    const line = (0, render_1.tableRow)(cells, w, ALIGN);
+    return selected ? `${(0, render_1.cyan)('❯')} ${line}` : `  ${line}`;
+}

package/dist/tui/requests.d.ts

@@ -1,16 +1,24 @@
+import { type AppHost, type Screen } from './app';
 import type { DataLayer, RequestRow } from './data';
-import type { AppHost, Screen } from './app';
 export interface RequestsState {
     rows: RequestRow[];
     sel: number;
+    /** Index of the first visible row. */
+    top: number;
+    /** Rows the last render could fit — how far a PgDn moves, and what
+     *  onKey needs to know to keep the cursor inside the window. */
+    rowsVisible: number;
     filter: string;
     filtering: boolean;
     loading: boolean;
     exhausted: boolean;
+    spin: number;
     now: number;
 }
 export declare function filterRows(rows: RequestRow[], filter: string): RequestRow[];
-export declare function renderRequests(st: RequestsState, width: number): string[];
+/** Scroll the window the smallest distance that puts the cursor back in it. */
+export declare function windowTop(sel: number, top: number, rows: number, total: number): number;
+export declare function renderRequests(st: RequestsState, width: number, height: number): string[];
 export declare function createRequestsScreen(deps: {
     data: DataLayer;
     host: AppHost;

package/dist/tui/requests.js

@@ -1,12 +1,20 @@
 "use strict";
-// Full request history for this node: cursor-paged, filterable.
+// Full request history for this node: windowed, cursor-paged, filterable.
+//
+// The list is windowed rather than fully rendered. Rendering all loaded rows
+// meant a 50-row page painted 50 lines into a 40-row terminal, and the heading
+// and newest rows scrolled off the top of the alt screen.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.filterRows = filterRows;
+exports.windowTop = windowTop;
 exports.renderRequests = renderRequests;
 exports.createRequestsScreen = createRequestsScreen;
 const render_1 = require("./render");
-const dashboard_1 = require("./dashboard");
+const request_row_1 = require("./request-row");
+const app_1 = require("./app");
 const PAGE = 50;
+/** Lines the screen spends on things that are not rows. */
+const CHROME = 6;
 function filterRows(rows, filter) {
     const f = filter.trim().toLowerCase();
     if (!f)
@@ -16,33 +24,59 @@ function filterRows(rows, filter) {
         (r.agent ?? '').toLowerCase().includes(f) ||
         (r.error_code ?? '').toLowerCase().includes(f));
 }
-function renderRequests(st, width) {
+/** Scroll the window the smallest distance that puts the cursor back in it. */
+function windowTop(sel, top, rows, total) {
+    const max = Math.max(0, total - rows);
+    let next = top;
+    if (sel < next)
+        next = sel;
+    if (sel >= next + rows)
+        next = sel - rows + 1;
+    return Math.min(Math.max(0, next), max);
+}
+function renderRequests(st, width, height) {
     const shown = filterRows(st.rows, st.filter);
+    const rows = Math.max(1, height - CHROME);
+    st.rowsVisible = rows;
+    st.top = windowTop(st.sel, st.top, rows, shown.length);
     const out = [];
-    out.push(`  ${(0, render_1.bold)('ALL REQUESTS')}  ${(0, render_1.dim)(`${shown.length} shown`)}`);
+    const scope = st.filter ? `${shown.length} matching “${st.filter}”` : `${shown.length} loaded`;
+    out.push((0, app_1.heading)('Activity', scope));
     out.push('');
     if (shown.length === 0) {
-        out.push((0, render_1.dim)(st.filter ? '  no requests match that filter' : '  no requests yet'));
+        out.push((0, render_1.dim)(st.filter ? '  No requests match that filter' : '  No requests yet'));
     }
     else {
-        shown.forEach((r, i) => out.push((0, dashboard_1.requestLine)(r, st.now, i === st.sel, width)));
+        out.push((0, request_row_1.requestHeader)(width));
+        shown
+            .slice(st.top, st.top + rows)
+            .forEach((r, i) => out.push((0, request_row_1.requestLine)(r, st.now, st.top + i === st.sel, width, st.spin)));
     }
-    out.push('');
+    // Pad so the footer sits at the bottom of the screen rather than floating
+    // up under a short list.
+    while (out.length < height - 2)
+        out.push('');
     if (st.loading)
-        out.push((0, render_1.dim)('  loading more…'));
+        out.push((0, render_1.dim)('  Loading more…'));
     else if (st.exhausted)
-        out.push((0, render_1.dim)('  end of history'));
+        out.push((0, render_1.dim)(`  End of history — ${shown.length} rows`));
     else
-        out.push((0, render_1.dim)('  ↓ at the bottom loads more'));
+        out.push((0, render_1.dim)('  ↓ past the last row loads more'));
     out.push(st.filtering
         ? `  ${(0, render_1.cyan)('/')}${st.filter}${(0, render_1.cyan)('▏')}`
-        : (0, render_1.dim)('  ↑↓ move   ⏎ transcript   / filter   q back'));
-    return out.map(l => (0, render_1.truncate)(l, width));
+        : (0, app_1.footerHint)([
+            { keys: '↑↓', label: 'move' },
+            { keys: '⏎', label: 'transcript' },
+            { keys: '/', label: 'filter' },
+            { keys: 'q', label: 'back' },
+        ]));
+    return out.map(l => (0, render_1.truncate)(l, width)).slice(0, height);
 }
 function createRequestsScreen(deps) {
     const st = {
-        rows: [], sel: 0, filter: '', filtering: false,
-        loading: false, exhausted: false, now: Date.now(),
+        rows: [], sel: 0, top: 0, rowsVisible: 10,
+        filter: '', filtering: false,
+        loading: false, exhausted: false, spin: 0, now: Date.now(),
     };
     async function loadMore() {
         if (st.loading || st.exhausted)
@@ -65,12 +99,32 @@ function createRequestsScreen(deps) {
             deps.host.redraw();
         }
     }
+    const move = (delta, total) => {
+        st.sel = Math.min(Math.max(0, total - 1), Math.max(0, st.sel + delta));
+        st.top = windowTop(st.sel, st.top, st.rowsVisible, total);
+    };
     return {
         id: 'requests',
-        title: 'All requests',
-        render: (width) => renderRequests(st, width),
+        title: 'Activity',
+        render: (width, height) => renderRequests(st, width, height),
         pollMs: () => 5000,
         capturesKeys: () => st.filtering,
+        tick(n) {
+            st.spin = n;
+            // Durations only tick on rows that haven't finished.
+            const live = st.rows.slice(st.top, st.top + st.rowsVisible).some(r => request_row_1.ACTIVE.has(r.status));
+            if (live)
+                st.now = Date.now();
+            return live;
+        },
+        keys: () => [
+            { keys: '↑↓ / jk', label: 'move the cursor' },
+            { keys: 'PgUp/PgDn', label: 'move a screenful' },
+            { keys: 'g / G', label: 'first row / last loaded row' },
+            { keys: '⏎', label: 'open the transcript' },
+            { keys: '/', label: 'filter by entity, status, agent or error code' },
+            { keys: 'esc', label: 'clear the filter' },
+        ],
         async poll() {
             st.now = Date.now();
             if (st.rows.length === 0)
@@ -79,13 +133,23 @@ function createRequestsScreen(deps) {
         },
         async onKey(key) {
             if (st.filtering) {
-                if (key.name === 'return' || key.name === 'escape') {
+                if (key.name === 'return') {
+                    st.filtering = false;
+                    deps.host.redraw();
+                    return;
+                }
+                if (key.name === 'escape') {
                     st.filtering = false;
+                    st.filter = '';
+                    st.sel = 0;
+                    st.top = 0;
                     deps.host.redraw();
                     return;
                 }
                 if (key.name === 'backspace') {
                     st.filter = st.filter.slice(0, -1);
+                    st.sel = 0;
+                    st.top = 0;
                     deps.host.redraw();
                     return;
                 }
@@ -94,18 +158,38 @@ function createRequestsScreen(deps) {
                 const ch = key.sequence ?? key.name ?? '';
                 if (ch.length === 1 && ch >= ' ') {
                     st.filter += ch;
+                    st.sel = 0;
+                    st.top = 0;
                     deps.host.redraw();
                 }
                 return;
             }
             const shown = filterRows(st.rows, st.filter);
+            const page = Math.max(1, st.rowsVisible - 1);
             if (key.name === 'up' || key.name === 'k') {
-                st.sel = Math.max(0, st.sel - 1);
+                move(-1, shown.length);
+                deps.host.redraw();
+                return;
+            }
+            if (key.name === 'pageup') {
+                move(-page, shown.length);
                 deps.host.redraw();
                 return;
             }
-            if (key.name === 'down' || key.name === 'j') {
-                st.sel = Math.min(Math.max(0, shown.length - 1), st.sel + 1);
+            if (key.name === 'g' && !key.shift) {
+                st.sel = 0;
+                st.top = 0;
+                deps.host.redraw();
+                return;
+            }
+            if (key.name === 'g' && key.shift) {
+                move(shown.length, shown.length);
+                deps.host.redraw();
+                return;
+            }
+            if (key.name === 'down' || key.name === 'j' || key.name === 'pagedown') {
+                move(key.name === 'pagedown' ? page : 1, shown.length);
+                // Reaching the end of what's loaded is the request for more.
                 if (st.sel >= shown.length - 1)
                     await loadMore();
                 deps.host.redraw();
@@ -115,6 +199,14 @@ function createRequestsScreen(deps) {
                 st.filtering = true;
                 st.filter = '';
                 st.sel = 0;
+                st.top = 0;
+                deps.host.redraw();
+                return;
+            }
+            if (key.name === 'escape' && st.filter) {
+                st.filter = '';
+                st.sel = 0;
+                st.top = 0;
                 deps.host.redraw();
                 return;
             }

package/dist/tui/run.d.ts

@@ -1,4 +1,3 @@
-import { FEED_ROWS } from './dashboard';
 export declare function shouldRenderTui(env: {
     isTTY: boolean;
     stdinTTY: boolean;
@@ -10,4 +9,5 @@ export declare function runDashboard(opts: {
     startedAt: number | null;
     version: string;
 }): Promise<void>;
-export { FEED_ROWS };
+/** `ainode harnesses` — straight to the harness screen. */
+export declare function runHarnessesTui(): Promise<void>;