@voidlabs.gg/voidshift 0.0.0-stage → 0.4.0

package/dist/tui/screens/checks.js

@@ -0,0 +1,106 @@
+// Checks: every doctor check with its mark and its fix. Enter on a check whose
+// fix is a vsf command runs that command (after a confirm); other fixes are
+// shown as text.
+import React, { useState } from 'react';
+import { Box, Text } from 'ink';
+import { needsTerminal, commandLine } from "../actions.js";
+import { useData } from "../data.js";
+import { useEquivalent, useHints, useKeys, useScreen } from "../context.js";
+import { clock } from "../format.js";
+import { theme } from "../theme.js";
+import { Panel, Table } from "../widgets.js";
+const h = React.createElement;
+const ORDER = { fail: 0, warn: 1, ok: 2 };
+// Problems first (failed, then warnings), then the ones that are fine, each in its own order.
+export function sortChecks(checks) {
+    return checks.map((c, i) => ({ c, i })).sort((a, b) => ORDER[a.c.status] - ORDER[b.c.status] || a.i - b.i).map((x) => x.c);
+}
+export const mark = (s) => s === 'ok' ? { text: '✓', colour: theme.green } : s === 'warn' ? { text: '!', colour: theme.yellow } : { text: '✗', colour: theme.red };
+// The vsf arguments in a fix like "vsf setup awake", or null when it is not a plain vsf command.
+export function fixCommand(fix) {
+    if (!fix)
+        return null;
+    const words = fix.trim().split(/\s+/);
+    if (words[0] !== 'vsf' || words.length < 2)
+        return null;
+    if (words.some((w) => /[|&;<>`$()'"\\]/.test(w)))
+        return null;
+    return words.slice(1);
+}
+export function checkRows(checks) {
+    return checks.map((c) => {
+        const m = mark(c.status);
+        return [{ text: m.text, colour: m.colour }, { text: c.name, bold: c.status !== 'ok' }, { text: c.detail, colour: c.status === 'ok' ? theme.dim : undefined }, { text: c.fix ?? '', colour: theme.dim }];
+    });
+}
+function Checks() {
+    const ctx = useScreen();
+    const { state, refreshChecks } = useData();
+    const checks = sortChecks(state.checks ?? []);
+    const [sel, setSel] = useState(0);
+    const at = Math.min(sel, Math.max(0, checks.length - 1));
+    const check = checks[at];
+    const args = fixCommand(check?.fix);
+    useHints([
+        { key: 'enter', label: args ? 'run the fix' : 'show the fix' },
+        { key: 'r', label: 'check again' },
+        { key: 'esc', label: 'back' },
+    ]);
+    useEquivalent(args);
+    useKeys((input, key) => {
+        if (key.upArrow)
+            setSel(Math.max(0, at - 1));
+        else if (key.downArrow)
+            setSel(Math.min(checks.length - 1, at + 1));
+        else if (input === 'r') {
+            refreshChecks();
+            ctx.toast('Checking again', 'info');
+        }
+        else if (key.return && check) {
+            if (!check.fix)
+                ctx.toast(`${check.name}: ${check.detail}. No fix needed.`, 'info');
+            else if (!args)
+                ctx.toast(`Fix for ${check.name}: ${check.fix}`, 'info');
+            else if (needsTerminal(args)) {
+                void (async () => {
+                    const ok = await ctx.actions.confirm({
+                        title: `Run ${commandLine(args)}?`,
+                        body: `Fixes ${check.name}. This opens in the terminal, and you come back here when it is done.`,
+                        confirmLabel: 'Run it',
+                        cancelLabel: 'Not now',
+                    });
+                    if (ok) {
+                        await ctx.actions.terminal(args);
+                        refreshChecks();
+                    }
+                })();
+            }
+            else {
+                void ctx.actions
+                    .run({ args, title: `Run ${commandLine(args)}?`, body: `Fixes ${check.name}: ${check.detail}.`, confirmLabel: 'Run it', cancelLabel: 'Not now' })
+                    .then((r) => r && refreshChecks());
+            }
+        }
+    });
+    if (!state.checks) {
+        return h(Box, { paddingX: 1 }, h(Text, { color: state.errors.checks ? theme.red : theme.dim }, state.errors.checks ?? 'Running checks...'));
+    }
+    const bad = checks.filter((c) => c.status !== 'ok').length;
+    return h(Box, { flexDirection: 'column' }, h(Panel, { title: 'Checks', subtitle: `${checks.length - bad} ok${bad ? `, ${bad} need a look` : ''}${state.checksAt ? ` · checked ${clock(new Date(state.checksAt))}` : ''}`, focused: true }, h(Table, {
+        columns: [{ title: '', width: 3 }, { title: 'CHECK', width: 24 }, { title: 'WHAT WE FOUND', width: 34 }, { title: 'FIX' }],
+        rows: checkRows(checks),
+        selected: at,
+        marker: true,
+        empty: 'No checks yet.',
+    })), check
+        ? h(Panel, { title: check.name }, h(Text, null, check.detail), check.fix
+            ? h(Text, { color: theme.dim }, args ? `Fix: ${commandLine(args)}  (enter runs it)` : `Fix: ${check.fix}`)
+            : h(Text, { color: theme.dim }, check.status === 'ok' ? 'Nothing to fix.' : 'No fix suggested.'))
+        : null);
+}
+export const checksScreen = {
+    id: 'checks',
+    title: 'Checks',
+    component: () => h(Checks),
+    hints: () => [{ key: 'enter', label: 'fix' }, { key: 'r', label: 'check again' }, { key: 'esc', label: 'back' }],
+};

package/dist/tui/screens/homes.d.ts

@@ -0,0 +1,14 @@
+import { type HomeItem } from '../data.ts';
+import type { Screen } from '../screens.ts';
+export interface HomeRow {
+    kind: string;
+    dir: string;
+    linked: string[];
+    missing: string[];
+    taken: string[];
+}
+export declare function homeRows(homes: HomeItem[]): HomeRow[];
+export declare function homeSummary(r: HomeRow): string;
+export declare const linkArgs: (dir: string) => string[];
+export declare const unlinkArgs: (dir: string) => string[];
+export declare const homesScreen: Screen;

package/dist/tui/screens/homes.js

@@ -0,0 +1,99 @@
+// Agents, Homes: the Claude Code and Codex config folders the agents are
+// linked into. l and u run `vsf agents link DIR` and `vsf agents unlink DIR`.
+import React, { useState } from 'react';
+import { Box, Text } from 'ink';
+import { useData } from "../data.js";
+import { useEquivalent, useHints, useKeys, useScreen } from "../context.js";
+import { tilde } from "../format.js";
+import { theme } from "../theme.js";
+import { Panel, TextInput } from "../widgets.js";
+const h = React.createElement;
+const list = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === 'string') : []);
+// The homes --json shape, made safe to draw.
+export function homeRows(homes) {
+    return homes
+        .filter((x) => typeof x.dir === 'string')
+        .map((x) => ({ kind: typeof x.kind === 'string' ? x.kind : 'claude', dir: x.dir, linked: list(x.linked), missing: list(x.missing), taken: list(x.taken) }));
+}
+const short = (id) => id.replace(/^vs-/, '');
+// "3 linked, 1 missing, 1 taken by something else"
+export function homeSummary(r) {
+    const parts = [`${r.linked.length} linked`];
+    if (r.missing.length)
+        parts.push(`${r.missing.length} missing`);
+    if (r.taken.length)
+        parts.push(`${r.taken.length} taken by something else`);
+    return parts.join(', ');
+}
+export const linkArgs = (dir) => ['agents', 'link', dir];
+export const unlinkArgs = (dir) => ['agents', 'unlink', dir];
+const LIST_HINTS = [
+    { key: 'l', label: 'link a folder' },
+    { key: 'u', label: 'unlink' },
+    { key: 'esc', label: 'back' },
+];
+function Homes() {
+    const ctx = useScreen();
+    const { state } = useData();
+    const rows = homeRows(state.homes);
+    const [sel, setSel] = useState(0);
+    const [adding, setAdding] = useState(false);
+    const [path, setPath] = useState('');
+    const index = Math.max(0, Math.min(sel, rows.length - 1));
+    const current = rows[index];
+    useHints(adding ? [{ key: 'enter', label: 'link' }, { key: 'esc', label: 'cancel' }] : LIST_HINTS);
+    useEquivalent(adding ? (path.trim() ? linkArgs(path.trim()) : null) : current ? unlinkArgs(current.dir) : null);
+    const link = async () => {
+        const dir = path.trim();
+        if (!dir)
+            return;
+        const r = await ctx.actions.run({
+            args: linkArgs(dir),
+            title: 'Link the agents into this folder?',
+            body: `${tilde(dir)}\nThe agents are added as skills in it. Anything already there is left alone.`,
+            confirmLabel: 'Link',
+            done: `Linked ${tilde(dir)}`,
+        });
+        if (r && r.code === 0) {
+            setAdding(false);
+            setPath('');
+        }
+    };
+    useKeys((input, key) => {
+        if (adding) {
+            if (key.escape)
+                setAdding(false);
+            return;
+        }
+        if (key.upArrow || input === 'k')
+            setSel(Math.max(0, index - 1));
+        else if (key.downArrow || input === 'j')
+            setSel(Math.min(rows.length - 1, index + 1));
+        else if (input === 'l') {
+            setPath('');
+            setAdding(true);
+        }
+        else if (input === 'u' && current) {
+            void ctx.actions.run({
+                args: unlinkArgs(current.dir),
+                title: `Unlink ${tilde(current.dir)}?`,
+                body: 'The agents are removed from this folder. Other files in it stay.',
+                confirmLabel: 'Unlink',
+                done: `Unlinked ${tilde(current.dir)}`,
+            });
+        }
+    }, { whileCapturing: true });
+    return h(Panel, { title: 'Config folders', focused: true }, h(Text, { color: theme.dim }, 'Where the agents are linked, so Claude Code and Codex can use them.'), h(Text, null, ' '), rows.length === 0 ? h(Text, { color: theme.dim }, state.loaded ? 'No folders yet. Press l to link one.' : 'Loading...') : null, ...rows.map((r, i) => {
+        const on = i === index;
+        const bg = on ? theme.selected : undefined;
+        return h(Box, { key: r.dir, flexDirection: 'column' }, h(Text, { wrap: 'truncate-end', backgroundColor: bg }, h(Text, { color: theme.accent }, on ? '▶ ' : '  '), h(Text, { bold: on }, tilde(r.dir)), h(Text, { color: theme.dim }, `  ${r.kind}  `), h(Text, { color: r.linked.length && !r.missing.length && !r.taken.length ? theme.green : theme.yellow }, homeSummary(r))), r.missing.length ? h(Text, { key: 'm', color: theme.yellow, wrap: 'truncate-end' }, `    missing: ${r.missing.map(short).join(', ')}`) : null, r.taken.length ? h(Text, { key: 't', color: theme.red, wrap: 'truncate-end' }, `    taken by something else: ${r.taken.map(short).join(', ')}`) : null);
+    }), adding
+        ? h(Box, { marginTop: 1 }, h(Text, { color: theme.dim }, 'Folder to link  '), h(TextInput, { value: path, onChange: setPath, placeholder: '~/.claude', onSubmit: () => void link() }))
+        : null, state.errors.homes ? h(Text, { color: theme.red }, state.errors.homes) : null);
+}
+export const homesScreen = {
+    id: 'agents.homes',
+    title: 'Homes',
+    component: Homes,
+    hints: () => LIST_HINTS,
+};

package/dist/tui/screens/list-window.d.ts

@@ -0,0 +1,6 @@
+export declare function windowOf(count: number, index: number, size: number): {
+    start: number;
+    end: number;
+};
+export declare function tailLines(text: string, n: number): string[];
+export declare const scrollBy: (offset: number, delta: number, max: number) => number;

package/dist/tui/screens/list-window.js

@@ -0,0 +1,18 @@
+// Pure helpers for showing a long list in a short box.
+// The slice of `count` items that fits in `size` rows and keeps `index` visible.
+export function windowOf(count, index, size) {
+    const n = Math.max(1, size);
+    if (count <= n)
+        return { start: 0, end: count };
+    const start = Math.max(0, Math.min(count - n, index - Math.floor(n / 2)));
+    return { start, end: start + n };
+}
+// The last `n` non-empty lines of a text.
+export function tailLines(text, n) {
+    const lines = text.split('\n').map((l) => l.replace(/\s+$/, ''));
+    while (lines.length && !lines[lines.length - 1])
+        lines.pop();
+    return lines.slice(-n);
+}
+// Moves a scroll offset by delta and keeps it inside [0, max].
+export const scrollBy = (offset, delta, max) => Math.max(0, Math.min(Math.max(0, max), offset + delta));

package/dist/tui/screens/log.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import { type RunItem } from '../data.ts';
+import type { Screen } from '../screens.ts';
+export declare const POLL_LOG_MS = 500;
+export interface LogText {
+    lines: string[];
+    partial: string;
+}
+export declare function appendChunk(text: LogText, chunk: string): LogText;
+export declare function wrapLines(lines: string[], width: number): string[];
+export interface Scroll {
+    top: number | null;
+}
+export declare const bottomTop: (total: number, size: number) => number;
+export declare function scrollBy(s: Scroll, total: number, size: number, delta: number): Scroll;
+export declare function visibleRows(rows: string[], size: number, s: Scroll): string[];
+export declare function logFor(run: RunItem, step: string | undefined): string | undefined;
+export declare function lineColour(line: string): string | undefined;
+export declare function useTail(path: string | null): LogText & {
+    missing: boolean;
+};
+export declare function LogView(props: {
+    params: Record<string, unknown>;
+}): React.ReactElement;
+export declare const logTitle: (p: Record<string, unknown>) => string[];
+export declare const logScreen: Screen;

package/dist/tui/screens/log.js

@@ -0,0 +1,266 @@
+// The live log screen: steps on the left, the selected step's log on the right,
+// following the end of the file like tail -f.
+import React, { useEffect, useMemo, useRef, useState } from 'react';
+import { Box, Text } from 'ink';
+import { closeSync, openSync, readSync, statSync } from 'node:fs';
+import { StringDecoder } from 'node:string_decoder';
+import { join } from 'node:path';
+import { useHints, useKeys, useScreen } from "../context.js";
+import { useData } from "../data.js";
+import { Lines, Panel, seg } from "../widgets.js";
+import { theme } from "../theme.js";
+import { cancelSpec, isLive, settledSteps, stepDuration, stepMark } from "./runs.js";
+const h = React.createElement;
+export const POLL_LOG_MS = 500;
+const MAX_LINES = 5000;
+const FIRST_READ_BYTES = 512 * 1024;
+const clean = (s) => s.replace(/\u001b\[[0-9;?]*[A-Za-z]/g, '').replace(/\r/g, '').replace(/\t/g, '  ').replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, '');
+// Adds a freshly read chunk: whole lines are kept, the unfinished one waits.
+export function appendChunk(text, chunk) {
+    const parts = (text.partial + clean(chunk)).split('\n');
+    const partial = parts.pop() ?? '';
+    const lines = text.lines.concat(parts);
+    return { lines: lines.length > MAX_LINES ? lines.slice(lines.length - MAX_LINES) : lines, partial };
+}
+// Wraps every line to rows of at most `width` characters, breaking at spaces.
+// Only a word longer than the width is cut mid-word. Blank lines stay.
+export function wrapLines(lines, width) {
+    const w = Math.max(8, width);
+    const out = [];
+    for (const line of lines) {
+        if (line.length <= w) {
+            out.push(line);
+            continue;
+        }
+        let row = '';
+        let broke = false;
+        for (const tok of line.match(/\S+|\s+/g) ?? []) {
+            if (/^\s/.test(tok)) {
+                // Spaces that would start a wrapped row, or overflow this one, are dropped.
+                if (row.length + tok.length <= w && !(broke && row === ''))
+                    row += tok;
+                continue;
+            }
+            if (row.length + tok.length <= w) {
+                row += tok;
+                continue;
+            }
+            if (row.trim() !== '') {
+                out.push(row.trimEnd());
+                broke = true;
+            }
+            row = tok;
+            while (row.length > w) {
+                out.push(row.slice(0, w));
+                broke = true;
+                row = row.slice(w);
+            }
+        }
+        out.push(row.trimEnd());
+    }
+    return out;
+}
+export const bottomTop = (total, size) => Math.max(0, total - size);
+export function scrollBy(s, total, size, delta) {
+    const cur = s.top ?? bottomTop(total, size);
+    return { top: Math.max(0, Math.min(bottomTop(total, size), cur + delta)) };
+}
+export function visibleRows(rows, size, s) {
+    const top = s.top === null ? bottomTop(rows.length, size) : Math.min(s.top, bottomTop(rows.length, size));
+    return rows.slice(top, top + size);
+}
+// Log name for a step: its recorded file, else a file that names the step.
+export function logFor(run, step) {
+    const steps = run.record?.steps ?? [];
+    if (step) {
+        const rec = [...steps].reverse().find((s) => s.step === step || s.label === step);
+        if (rec?.log && run.logs.includes(rec.log))
+            return rec.log;
+        const byName = [...run.logs].reverse().find((l) => l.includes(step.replace(/^vs-/, '')));
+        if (byName)
+            return byName;
+    }
+    const running = [...steps].reverse().find((s) => !s.endedAt)?.log;
+    if (running && run.logs.includes(running))
+        return running;
+    return run.logs[run.logs.length - 1];
+}
+export function lineColour(line) {
+    if (line.startsWith('$ '))
+        return theme.accent;
+    if (/^\s*(✓|PASS)/.test(line))
+        return theme.green;
+    if (/^\s*(✗|FAIL|Error)/.test(line))
+        return theme.red;
+    return undefined;
+}
+// ---- tailing a file --------------------------------------------------------
+// Reads the file once, then only the bytes added since, every 500ms.
+export function useTail(path) {
+    const [text, setText] = useState({ lines: [], partial: '', missing: false });
+    useEffect(() => {
+        setText({ lines: [], partial: '', missing: false });
+        if (!path)
+            return;
+        let offset = -1;
+        let acc = { lines: [], partial: '' };
+        let decoder = new StringDecoder('utf8');
+        const tick = () => {
+            let size;
+            try {
+                size = statSync(path).size;
+            }
+            catch {
+                setText((t) => (t.missing ? t : { ...t, missing: true }));
+                return;
+            }
+            if (offset < 0) {
+                offset = Math.max(0, size - FIRST_READ_BYTES);
+                if (offset > 0)
+                    acc = { lines: [], partial: '' };
+            }
+            else if (size < offset) {
+                offset = 0;
+                acc = { lines: [], partial: '' };
+                decoder = new StringDecoder('utf8');
+            }
+            else if (size === offset)
+                return;
+            try {
+                const fd = openSync(path, 'r');
+                try {
+                    const buf = Buffer.alloc(size - offset);
+                    const n = readSync(fd, buf, 0, buf.length, offset);
+                    offset += n;
+                    acc = appendChunk(acc, decoder.write(buf.subarray(0, n)));
+                }
+                finally {
+                    closeSync(fd);
+                }
+                setText({ ...acc, missing: false });
+            }
+            catch {
+                // try again next tick
+            }
+        };
+        tick();
+        const t = setInterval(tick, POLL_LOG_MS);
+        return () => clearInterval(t);
+    }, [path]);
+    return text;
+}
+// ---- the screen ------------------------------------------------------------
+const LEFT = 24;
+export function LogView(props) {
+    const ctx = useScreen();
+    const { state } = useData();
+    const [now, setNow] = useState(Date.now());
+    useEffect(() => {
+        const t = setInterval(() => setNow(Date.now()), 1000);
+        return () => clearInterval(t);
+    }, []);
+    const card = String(props.params.card ?? '');
+    const dir = typeof props.params.dir === 'string' ? props.params.dir : null;
+    const run = state.runs.find((r) => (dir ? r.dir === dir : r.card === card));
+    const live = isLive(run, state);
+    const record = run?.record;
+    const [picked, setPicked] = useState(null);
+    const [scroll, setScroll] = useState({ top: null });
+    const wanted = typeof props.params.step === 'string' ? props.params.step : undefined;
+    const autoFile = run ? logFor(run, picked ? undefined : wanted) : undefined;
+    // Until the user picks a log, a live run moves on to the newest one.
+    const followNewest = !picked && live && !!run && run.logs.length > 0;
+    const file = picked ?? (followNewest ? run.logs[run.logs.length - 1] : autoFile);
+    const path = run && file ? join(run.dir, file) : null;
+    const text = useTail(path);
+    const rightWidth = Math.max(30, ctx.columns - LEFT - 1);
+    const panelHeight = Math.max(6, ctx.rows - 4);
+    const size = panelHeight - 2;
+    const all = text.partial ? [...text.lines, text.partial] : text.lines;
+    const rows = useMemo(() => wrapLines(all, rightWidth - 4), [text.lines, text.partial, rightWidth]);
+    const following = scroll.top === null;
+    const hints = [
+        { key: 'f', label: following ? 'follow off' : 'follow on' },
+        { key: '↑↓', label: 'scroll' },
+        { key: '1-9', label: 'step' },
+        { key: 'c', label: 'cancel card' },
+        { key: 'esc', label: 'back' },
+    ];
+    useHints(hints);
+    useEffect(() => {
+        ctx.setHeaderRight(following ? 'following' : 'scrolled', following ? theme.accent : theme.dim);
+        return () => ctx.setHeaderRight(null);
+    }, [following]);
+    const sizeRef = useRef(size);
+    sizeRef.current = size;
+    useKeys((input, key) => {
+        const total = rows.length;
+        if (input === 'f')
+            setScroll(following ? { top: bottomTop(total, size) } : { top: null });
+        else if (key.upArrow)
+            setScroll((s) => scrollBy(s, total, size, -1));
+        else if (key.downArrow)
+            setScroll((s) => scrollBy(s, total, size, 1));
+        else if (key.pageUp)
+            setScroll((s) => scrollBy(s, total, size, -(size - 1)));
+        else if (key.pageDown)
+            setScroll((s) => scrollBy(s, total, size, size - 1));
+        else if (/^[1-9]$/.test(input) && run) {
+            const name = run.logs[Number(input) - 1];
+            if (name) {
+                setPicked(name);
+                setScroll({ top: null });
+            }
+        }
+        else if (input === 'c') {
+            if (!live)
+                ctx.toast(`${card} is not running, so there is nothing to cancel.`, 'info');
+            else
+                void ctx.actions.run(cancelSpec(card, state.agents?.current?.step));
+        }
+    });
+    if (!run) {
+        return h(Panel, { title: card || 'Log' }, h(Text, { color: theme.dim }, state.loaded ? `No saved run for ${card}.` : 'Loading...'));
+    }
+    // Left: steps, round, log files.
+    const steps = settledSteps(run, state);
+    const left = steps.map((s) => {
+        const m = stepMark(s);
+        const on = !!file && s.log === file;
+        return [seg(`${m.glyph} `, m.colour), seg(s.label.padEnd(8), on ? theme.accent : undefined, { bold: on }), seg(stepDuration(s, now), theme.dim)];
+    });
+    if (!steps.length)
+        left.push([seg('No steps yet', theme.dim)]);
+    const workflow = state.workflows.find((w) => w.name === record?.workflow);
+    const cur = state.agents?.current;
+    const round = live && cur?.round !== undefined ? cur.round + 1 : Math.max(1, steps.filter((s) => s.step === steps[0]?.step).length);
+    left.push([], [seg(`round ${round}${workflow?.maxRounds ? ` of ${workflow.maxRounds}` : ''}`, theme.dim)], []);
+    run.logs.forEach((l) => {
+        const on = l === file;
+        left.push([seg(on ? '▶ ' : '  ', theme.accent), seg(l, on ? theme.accent : theme.dim, { bold: on })]);
+    });
+    const view = visibleRows(rows, size, scroll);
+    const body = text.missing
+        ? [h(Text, { key: 'm', color: theme.dim }, 'This log has not been written yet.')]
+        : view.map((r, i) => h(Text, { key: i, wrap: 'truncate-end', color: lineColour(r) }, r || ' '));
+    if (!text.missing && live && following && view.length < size)
+        body.push(h(Text, { key: 'cur', color: theme.accent }, '▍'));
+    return h(Box, { flexDirection: 'row' }, h(Panel, { title: 'Steps', width: LEFT, height: panelHeight }, h(Lines, { lines: left })), h(Box, { width: 1 }), h(Panel, { title: file ?? 'Log', focused: true, width: rightWidth, height: panelHeight, subtitle: rows.length > size && !following ? `${(scroll.top ?? 0) + 1}/${rows.length}` : undefined }, ...body));
+}
+// The step's name for the header: "QA log".
+export const logTitle = (p) => {
+    const label = typeof p.stepLabel === 'string' ? p.stepLabel : typeof p.step === 'string' ? p.step.replace(/^vs-/, '') : '';
+    return [String(p.card ?? 'Log'), label ? `${label} log` : 'Log'];
+};
+export const logScreen = {
+    id: 'agents.log',
+    title: logTitle,
+    component: LogView,
+    hints: () => [
+        { key: 'f', label: 'follow on/off' },
+        { key: '↑↓', label: 'scroll' },
+        { key: '1-9', label: 'step' },
+        { key: 'c', label: 'cancel card' },
+        { key: 'esc', label: 'back' },
+    ],
+};

package/dist/tui/screens/memory.d.ts

@@ -0,0 +1,24 @@
+import { type MemoryStatus } from '../data.ts';
+import { type Line } from '../widgets.ts';
+import type { Screen } from '../screens.ts';
+type Home = MemoryStatus['homes'][number];
+export interface VaultProblems {
+    unindexed: string[];
+    brokenIndex: string[];
+    brokenLinks: {
+        note: string;
+        link: string;
+    }[];
+}
+export declare const kindLabel: (k: string) => string;
+export declare function recallText(recall: string): {
+    text: string;
+    colour: string;
+};
+export declare const toggleArgs: (mode: "on" | "off", home: Home) => string[];
+export declare const tryArgs: (prompt: string) => string[];
+export declare function parseProblems(output: string): VaultProblems | null;
+export declare function problemLines(p: VaultProblems): Line[];
+export declare function vaultLines(m: MemoryStatus, now?: Date): Line[];
+export declare const memoryScreen: Screen;
+export {};