@xingular/harness 2.0.0 → 2.0.1-unstable

package/dist/sdk/terminal/tui/pages/remoteControlPage.js

@@ -0,0 +1,170 @@
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { safeText } from "../chrome.js";
+import { qrLines } from "../qr.js";
+const KIND_LABEL = { tailscale: 'Tailscale', lan: 'Wi-Fi' };
+export class RemoteControlPage {
+    options;
+    presentation = 'fullscreen';
+    status = null;
+    error = null;
+    showQr = true;
+    busy = false;
+    disposed = false;
+    watching = null;
+    constructor(options) {
+        this.options = options;
+    }
+    tabs() {
+        return [{ id: 'remote', title: 'Remote Control' }];
+    }
+    activeTab() {
+        return 'remote';
+    }
+    hint() {
+        const status = this.status;
+        if (status?.request)
+            return 'a allow · d deny';
+        if (!status?.running)
+            return 's start';
+        const parts = ['space QR', 'c copy link', 'n new link'];
+        if (status.kinds.length > 1)
+            parts.push(`t use ${status.kind === 'tailscale' ? 'Wi-Fi' : 'Tailscale'}`);
+        parts.push('x stop');
+        return parts.join(' · ');
+    }
+    activate() {
+        void this.watch();
+    }
+    dispose() {
+        this.disposed = true;
+        this.watching?.abort();
+    }
+    async watch() {
+        const watching = new AbortController();
+        this.watching = watching;
+        let revision;
+        while (!this.disposed && !watching.signal.aborted) {
+            try {
+                const status = await this.options.call(revision === undefined ? 'terminal.remoteControl.status' : 'terminal.remoteControl.status.wait', { revision });
+                if (this.disposed)
+                    return;
+                this.status = status;
+                this.error = null;
+                revision = status.revision;
+            }
+            catch (error) {
+                if (this.disposed)
+                    return;
+                this.error = error instanceof Error ? error.message : String(error);
+                revision = undefined;
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+            this.options.changed();
+        }
+    }
+    async act(method, params = {}, done) {
+        if (this.busy)
+            return;
+        this.busy = true;
+        this.options.changed();
+        try {
+            this.status = await this.options.call(method, params);
+            this.error = null;
+            if (done)
+                this.options.notify(done);
+        }
+        catch (error) {
+            this.error = error instanceof Error ? error.message : String(error);
+        }
+        finally {
+            this.busy = false;
+            this.options.changed();
+        }
+    }
+    handleInput(data) {
+        const status = this.status;
+        if (status?.request) {
+            if (data === 'a' || data === 'y')
+                void this.act('terminal.remoteControl.confirm', { requestId: status.request.id, allow: true }, `${status.request.label} can now control this session.`);
+            else if (data === 'd' || data === 'n')
+                void this.act('terminal.remoteControl.confirm', { requestId: status.request.id, allow: false });
+            return true;
+        }
+        if (!status?.running) {
+            if (data === 's')
+                void this.act('terminal.remoteControl.start');
+            return data === 's';
+        }
+        if (data === ' ')
+            this.showQr = !this.showQr;
+        else if (data === 'c' && status.url)
+            void this.options.copy(status.url).then(() => this.options.notify('Remote-control link copied'), (error) => this.options.notify(error instanceof Error ? error.message : String(error), 'error'));
+        else if (data === 'n')
+            void this.act('terminal.remoteControl.rotate', {}, 'New link. Paired devices were disconnected.');
+        else if (data === 't' && status.kinds.length > 1)
+            void this.act('terminal.remoteControl.start', { interface: status.kind === 'tailscale' ? 'lan' : 'tailscale' });
+        else if (data === 'x')
+            void this.act('terminal.remoteControl.stop', {}, 'Remote control stopped.');
+        else
+            return false;
+        return true;
+    }
+    render(width, rows) {
+        const theme = this.options.theme();
+        const status = this.status;
+        const lines = [];
+        const wrap = (text, color = 'text') => {
+            for (const line of wrapTextWithAnsi(text, Math.max(1, width)))
+                lines.push(theme.fg(color, line));
+        };
+        if (this.error) {
+            wrap(this.error, 'error');
+            lines.push('');
+        }
+        if (!status) {
+            wrap('Starting remote control…', 'dim');
+            return lines.slice(0, rows);
+        }
+        if (status.request) {
+            wrap(`${safeText(status.request.label)} wants to control this session.`, 'warning');
+            wrap('It will be able to send messages, stop replies, and answer approvals and questions. Press a to allow or d to deny.', 'text');
+            lines.push('');
+        }
+        if (!status.running) {
+            wrap('Remote control is off.', 'dim');
+            wrap('Press s to start it, then scan the QR code with your phone or iPad.', 'dim');
+            return lines.slice(0, rows);
+        }
+        const kind = status.kind ? KIND_LABEL[status.kind] : '';
+        lines.push(theme.fg('success', '● ') + theme.bold(`Remote control is on${kind ? ` · ${kind}` : ''}`));
+        wrap(status.kind === 'tailscale'
+            ? 'Scan with a phone or iPad signed in to the same Tailscale network, or open this link on it:'
+            : 'Scan with a phone or iPad on the same Wi-Fi, or open this link on it:', 'dim');
+        if (status.url)
+            wrap(status.url, 'accent');
+        if (status.warning)
+            wrap(safeText(status.warning), 'warning');
+        if (status.kind === 'lan')
+            wrap('On a network you do not trust, use Tailscale instead: anyone there can see that this computer is listening.', 'dim');
+        const devices = status.devices.length
+            ? status.devices.map((device) => `${device.connected ? theme.fg('success', '●') : theme.fg('dim', '○')} ${safeText(device.label)}${device.connected ? '' : theme.fg('dim', ' (paired, not connected)')}`)
+            : [theme.fg('dim', 'No device paired yet.')];
+        const footer = ['', ...devices];
+        if (this.showQr && status.url) {
+            const qr = qrLines(status.url);
+            const room = rows - lines.length - footer.length - 1;
+            const qrWidth = visibleWidth(qr[0] ?? '');
+            if (qr.length <= room && qrWidth <= width) {
+                lines.push('');
+                const pad = ' '.repeat(Math.max(0, Math.floor((width - qrWidth) / 2)));
+                for (const line of qr)
+                    lines.push(pad + line);
+            }
+            else {
+                lines.push('', theme.fg('dim', 'Make the terminal larger to show the QR code, or press c to copy the link.'));
+            }
+        }
+        lines.push(...footer);
+        return lines.slice(0, rows).map((line) => truncateToWidth(line, width, ''));
+    }
+}

package/dist/sdk/terminal/tui/pages/settingsPage.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The Settings page. It lists existing host settings and asks the host to change one; the values
+ * and actions belong to the host. Categories are page-local tabs (Tab / Shift+Tab).
+ */
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import type { TerminalPage } from "../page.js";
+import type { TerminalMouseInput } from "../mouse.js";
+export interface TerminalSettingItem {
+    id: string;
+    tab: string;
+    group: string;
+    label: string;
+    value: string;
+    description?: string;
+}
+export interface SettingsPageOptions {
+    theme: () => Theme;
+    items(): TerminalSettingItem[];
+    /** Loads device-local settings that need a protected Harness call. */
+    load?(): Promise<void>;
+    /** Changes the setting; the page reads the items again afterwards. */
+    apply(id: string): Promise<void>;
+    notify(message: string, type?: string): void;
+    changed(): void;
+}
+export declare class SettingsPage implements TerminalPage {
+    private readonly options;
+    readonly presentation = "fullscreen";
+    private items;
+    private category;
+    private disposed;
+    private readonly list;
+    constructor(options: SettingsPageOptions);
+    dispose(): void;
+    set focused(value: boolean);
+    get focused(): boolean;
+    private categories;
+    private rowsFor;
+    private reload;
+    /** Searching looks through every category; otherwise the page shows the current one. */
+    private fill;
+    tabs(): ({
+        readonly id: "appearance";
+        readonly title: "Appearance";
+    } | {
+        readonly id: "model";
+        readonly title: "Model";
+    } | {
+        readonly id: "interaction";
+        readonly title: "Interaction";
+    } | {
+        readonly id: "context";
+        readonly title: "Context";
+    } | {
+        readonly id: "browser";
+        readonly title: "Browser";
+    })[];
+    activeTab(): string;
+    hint(): string;
+    handleMouse(event: TerminalMouseInput): import("@earendil-works/pi-tui").TuiMouseEventResult | undefined;
+    handleInput(data: string): boolean;
+    render(width: number, rows: number): string[];
+}

package/dist/sdk/terminal/tui/pages/settingsPage.js

@@ -0,0 +1,103 @@
+import { matchesKey, truncateToWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { safeText } from "../chrome.js";
+import { FilterList } from "../list.js";
+const CATEGORIES = [
+    { id: 'appearance', title: 'Appearance' }, { id: 'model', title: 'Model' },
+    { id: 'interaction', title: 'Interaction' }, { id: 'context', title: 'Context' },
+    { id: 'browser', title: 'Browser' }
+];
+const tabOf = (item) => item.tab.toLowerCase();
+export class SettingsPage {
+    options;
+    presentation = 'fullscreen';
+    items = [];
+    category = '';
+    disposed = false;
+    list;
+    constructor(options) {
+        this.options = options;
+        this.list = new FilterList({
+            theme: options.theme, search: 'always', noun: ['setting', 'settings'], empty: 'No settings',
+            searchContext: () => 'every category',
+            onActivate: row => {
+                void options.apply(row.id).then(() => this.reload(), error => options.notify(error instanceof Error ? error.message : String(error), 'error'));
+            }
+        });
+        this.reload();
+        if (options.load) {
+            void options.load().then(() => {
+                if (!this.disposed)
+                    this.reload();
+            }, error => {
+                if (!this.disposed)
+                    options.notify(error instanceof Error ? error.message : String(error), 'error');
+            });
+        }
+    }
+    dispose() {
+        this.disposed = true;
+    }
+    set focused(value) { this.list.focused = value; }
+    get focused() { return this.list.focused; }
+    categories() {
+        return CATEGORIES.filter(category => this.items.some(item => tabOf(item) === category.id));
+    }
+    rowsFor(items) {
+        return items.map(item => ({
+            id: item.id, label: safeText(item.label), detail: safeText(item.value), group: safeText(item.group), data: item,
+            searchText: `${item.label} ${item.id} ${item.value} ${item.description ?? ''} ${item.group} ${item.tab}`
+        }));
+    }
+    reload() {
+        const selected = this.list.selected?.id;
+        this.items = this.options.items().filter(item => CATEGORIES.some(category => category.id === tabOf(item)));
+        if (!this.categories().some(category => category.id === this.category))
+            this.category = this.categories()[0]?.id ?? '';
+        this.fill();
+        if (selected)
+            this.list.select(selected);
+        this.options.changed();
+    }
+    /** Searching looks through every category; otherwise the page shows the current one. */
+    fill() {
+        this.list.setRows(this.rowsFor(this.list.query ? this.items : this.items.filter(item => tabOf(item) === this.category)));
+    }
+    tabs() { return this.categories(); }
+    activeTab() { return this.category; }
+    hint() { return this.list.query ? 'Enter change · Esc clear' : 'Enter change · type to search'; }
+    handleMouse(event) {
+        return this.list.handleMouse(event);
+    }
+    handleInput(data) {
+        if (matchesKey(data, 'tab') || matchesKey(data, 'shift+tab')) {
+            const categories = this.categories();
+            if (!this.list.query && categories.length > 1) {
+                const at = Math.max(0, categories.findIndex(category => category.id === this.category));
+                this.category = categories[(at + (matchesKey(data, 'shift+tab') ? -1 : 1) + categories.length) % categories.length].id;
+                this.fill();
+            }
+            return true;
+        }
+        const before = this.list.query;
+        const used = this.list.handleInput(data);
+        if (this.list.query !== before)
+            this.fill();
+        return used;
+    }
+    render(width, rows) {
+        if (width < 1 || rows < 1)
+            return [];
+        const theme = this.options.theme();
+        const description = this.list.selected?.data?.description;
+        const descriptionRows = Math.min(3, Math.max(0, rows - 7));
+        const reserved = descriptionRows ? descriptionRows + 1 : 0;
+        const lines = this.list.render(width, Math.max(2, rows - 1 - reserved));
+        if (descriptionRows) {
+            lines.push('');
+            const wrapped = description ? wrapTextWithAnsi(safeText(description), Math.max(1, width)) : [];
+            for (let index = 0; index < descriptionRows; index++)
+                lines.push(theme.fg('muted', wrapped[index] ?? ''));
+        }
+        return lines.slice(0, rows).map(line => truncateToWidth(line, width, ''));
+    }
+}

package/dist/sdk/terminal/tui/pages/subagentsPage.d.ts

@@ -0,0 +1,24 @@
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import { type TabInfo } from "../chrome.js";
+import type { TerminalPage } from "../page.js";
+import { type TerminalSubagentActivity } from "../../subagentMonitor.js";
+export interface SubagentsPageOptions {
+    theme(): Theme;
+    snapshot(): readonly TerminalSubagentActivity[];
+    changed(): void;
+    now?(): number;
+}
+export declare class SubagentsPage implements TerminalPage {
+    private readonly options;
+    presentation: "fullscreen";
+    private readonly list;
+    constructor(options: SubagentsPageOptions);
+    get focused(): boolean;
+    set focused(value: boolean);
+    tabs(): readonly TabInfo[];
+    activeTab(): string;
+    hint(): string;
+    private rows;
+    render(width: number, rows: number): string[];
+    handleInput(data: string): boolean;
+}

package/dist/sdk/terminal/tui/pages/subagentsPage.js

@@ -0,0 +1,155 @@
+import { matchesKey, stripTerminalSequences, truncateToWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { CHROME_PAD, headerRow, neutralRule, padded } from "../chrome.js";
+import { FilterList } from "../list.js";
+import { ACTIVE_SUBAGENT_STATUSES, terminalSubagentDuration } from "../../subagentMonitor.js";
+import { profileColor, opentuiTheme } from "../../opentui/theme.js";
+import { subagentTasks } from "../../opentui/subagentsWidget.js";
+import { formatTokenCount } from "../status.js";
+import { getWorkingSpinnerFrames, SPINNER_INTERVAL_MS, spinnerFrameAt } from "../workingStatus.js";
+const TABS = [{ id: 'subagents', title: 'Subagents' }];
+function clean(value) {
+    return stripTerminalSequences(value).replace(/[\x00-\x08\x0b-\x1f\x7f]/g, ' ').replace(/\s+/g, ' ').trim();
+}
+function statusGlyph(item, now) {
+    if (item.status === 'running') {
+        const started = Date.parse(item.startedAt);
+        return spinnerFrameAt(now - (Number.isFinite(started) ? started : now), getWorkingSpinnerFrames(process.env.TERM), SPINNER_INTERVAL_MS);
+    }
+    switch (item.status) {
+        case 'queued': return '○';
+        case 'waiting_for_approval':
+        case 'waiting_for_input': return '●';
+        case 'completed': return '✓';
+        case 'failed': return '✕';
+        case 'interrupted': return '!';
+    }
+}
+function statusGlyphTone(item) {
+    if (item.status === 'completed')
+        return 'success';
+    if (item.status === 'failed')
+        return 'error';
+    if (item.status === 'waiting_for_approval' || item.status === 'waiting_for_input')
+        return 'accent';
+    if (item.status === 'running')
+        return 'warning';
+    return 'muted';
+}
+function effectiveModel(item) {
+    const model = item.usage?.model;
+    if (model)
+        return `${item.usage?.provider ? `${item.usage.provider}/` : ''}${model}`;
+    return item.model ?? '—';
+}
+function usageSummary(item) {
+    const usage = item.usage;
+    if (!usage)
+        return 'usage —';
+    const cache = [usage.cacheReadTokens, usage.cacheWriteTokens]
+        .filter((value) => typeof value === 'number' && value > 0)
+        .map(formatTokenCount);
+    const cost = typeof usage.costUsd === 'number'
+        ? `${usage.costSource === 'estimate' ? '~' : ''}$${usage.costUsd.toFixed(usage.costUsd > 0 && usage.costUsd < 0.001 ? 5 : usage.costUsd < 0.01 ? 4 : 2).replace(/0+$/u, '').replace(/\.$/u, '')}`
+        : '';
+    const fields = [
+        typeof usage.inputTokens === 'number' ? `↑${formatTokenCount(usage.inputTokens)}` : '',
+        typeof usage.outputTokens === 'number' ? `↓${formatTokenCount(usage.outputTokens)}` : '',
+        cache.some(Boolean) ? `c${cache.join('/')}` : '',
+        cost,
+        typeof usage.contextTokens === 'number' ? `ctx${formatTokenCount(usage.contextTokens)}${typeof usage.contextWindow === 'number' ? `/${formatTokenCount(usage.contextWindow)}` : ''}` : '',
+        typeof usage.requests === 'number' ? `req${usage.requests}` : ''
+    ].filter(Boolean);
+    return fields.length ? fields.join(' ') : 'usage —';
+}
+function rowSubtitle(item, width) {
+    const available = Math.max(1, width - 2);
+    const verbose = width >= 96;
+    const account = clean(item.accountLabel ?? '') || '—';
+    const model = truncateToWidth(effectiveModel(item), 24, '…');
+    const details = verbose
+        ? [`acct ${account}`, `model ${model}`, `eff ${item.effort ?? '—'}`, usageSummary(item)].join(' · ')
+        : [`a:${account}`, `m:${model}`, `e:${item.effort ?? '—'}`, usageSummary(item)].join(' · ');
+    return truncateToWidth(details, available, '…');
+}
+export class SubagentsPage {
+    options;
+    presentation = 'fullscreen';
+    list;
+    constructor(options) {
+        this.options = options;
+        this.list = new FilterList({
+            theme: options.theme, search: 'always', noun: ['subagent', 'subagents'], rowGap: 1,
+            empty: 'No subagents have started in the latest run'
+        });
+    }
+    get focused() { return this.list.focused; }
+    set focused(value) { this.list.focused = value; }
+    tabs() { return TABS; }
+    activeTab() { return 'subagents'; }
+    hint() { return '↑↓ select · type to search'; }
+    rows(width = 80, now = this.options.now?.() ?? Date.now()) {
+        // The main agent is pinned first so its children read against it.
+        const ordered = [...this.options.snapshot()].sort((left, right) => {
+            const main = Number(right.relation === 'main') - Number(left.relation === 'main');
+            const active = Number(ACTIVE_SUBAGENT_STATUSES.has(right.status)) - Number(ACTIVE_SUBAGENT_STATUSES.has(left.status));
+            return main || active || left.startedAt.localeCompare(right.startedAt) || left.id.localeCompare(right.id);
+        });
+        return ordered.map(item => {
+            const profile = clean(item.profile?.name ?? '') || 'subagent';
+            const title = clean(item.title) || 'Subagent';
+            const color = item.profile?.color ? profileColor(opentuiTheme, item.profile.color) : null;
+            const glyph = statusGlyph(item, now);
+            const labelParts = [
+                { text: `${glyph} `, ...(item.status === 'running' && color ? { color } : { tone: statusGlyphTone(item) }) },
+                { text: profile, ...(color ? { color } : { tone: 'muted' }) },
+                { text: `  ${title}` }
+            ];
+            return {
+                id: item.id,
+                label: labelParts.map(part => part.text).join(''),
+                labelParts,
+                subtitle: rowSubtitle(item, width),
+                searchText: `${profile} ${title} ${item.goal ?? ''} ${item.status} ${item.activity} ${item.accountLabel ?? ''} ${effectiveModel(item)} ${item.effort ?? ''} ${usageSummary(item)}`,
+                data: item
+            };
+        });
+    }
+    render(width, rows) {
+        const items = this.rows(width, this.options.now?.() ?? Date.now());
+        this.list.setRows(items);
+        const children = items.filter(item => item.data?.relation !== 'main');
+        const active = children.filter(item => item.data && ACTIVE_SUBAGENT_STATUSES.has(item.data.status)).length;
+        const selected = this.list.selected?.data;
+        const header = headerRow('Subagents', `${active} active · ${children.length} total`, width, this.options.theme());
+        const bodyRows = Math.max(0, rows - 7);
+        const listRows = Math.max(1, Math.min(this.list.height, Math.floor(bodyRows * 0.6)));
+        const output = [header, '', ...this.list.render(width, listRows), ''];
+        if (selected) {
+            const theme = this.options.theme();
+            const detailIndent = ' '.repeat(CHROME_PAD * 2);
+            const detailLines = (text) => wrapTextWithAnsi(theme.fg('text', clean(text)), Math.max(1, width - detailIndent.length))
+                .map(line => `${detailIndent}${line}`);
+            output.push(neutralRule(width, theme));
+            output.push(padded(theme.fg('muted', `Profile: ${clean(selected.profile?.name ?? '') || 'copy of the parent'}`), width));
+            output.push(padded(theme.fg('accent', 'Task'), width));
+            output.push(...detailLines(selected.goal || (selected.relation === 'main' ? 'Main agent' : 'Subagent')));
+            output.push(padded(theme.fg('muted', `Status: ${[selected.status.replaceAll('_', ' '), subagentTasks(selected.todo), terminalSubagentDuration(selected)].filter(Boolean).join(' · ')}`), width));
+            output.push(padded(theme.fg('accent', 'Current activity'), width));
+            output.push(...detailLines(selected.activity));
+        }
+        else {
+            output.push(padded(this.options.theme().fg('muted', 'The selected subagent’s task and current activity appear here.'), width));
+        }
+        return output.slice(0, Math.max(0, rows)).map(line => truncateToWidth(line, width, ''));
+    }
+    handleInput(data) {
+        this.list.setRows(this.rows());
+        if (matchesKey(data, 'enter'))
+            return this.list.handleInput(data);
+        if (this.list.handleInput(data)) {
+            this.options.changed();
+            return true;
+        }
+        return false;
+    }
+}

package/dist/sdk/terminal/tui/pages/textPage.d.ts

@@ -0,0 +1,17 @@
+import type { TabInfo } from "../chrome.js";
+import type { TerminalPage } from "../page.js";
+export declare class TextPage implements TerminalPage {
+    private readonly title;
+    private readonly text;
+    private readonly changed;
+    readonly presentation: "fullscreen";
+    private offset;
+    private rows;
+    constructor(title: string, text: string, changed?: () => void);
+    tabs(): readonly TabInfo[];
+    activeTab(): string;
+    private lines;
+    render(width: number, rows: number): string[];
+    handleInput(data: string): boolean;
+    hint(): string;
+}

package/dist/sdk/terminal/tui/pages/textPage.js

@@ -0,0 +1,52 @@
+// A read-only, scrollable page of text: a variant diff, a refinement candidate, its output.
+import { matchesKey, truncateToWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+export class TextPage {
+    title;
+    text;
+    changed;
+    presentation = 'fullscreen';
+    offset = 0;
+    rows = 20;
+    constructor(title, text, changed = () => { }) {
+        this.title = title;
+        this.text = text;
+        this.changed = changed;
+    }
+    tabs() {
+        return [{ id: 'text', title: this.title }];
+    }
+    activeTab() {
+        return 'text';
+    }
+    lines(width) {
+        return this.text.split('\n').flatMap((line) => (line ? wrapTextWithAnsi(line, Math.max(10, width)) : ['']));
+    }
+    render(width, rows) {
+        this.rows = Math.max(1, rows);
+        const lines = this.lines(width);
+        this.offset = Math.max(0, Math.min(this.offset, lines.length - this.rows));
+        return lines.slice(this.offset, this.offset + this.rows).map((line) => truncateToWidth(line, width));
+    }
+    handleInput(data) {
+        const page = Math.max(1, this.rows - 1);
+        if (matchesKey(data, 'up'))
+            this.offset = Math.max(0, this.offset - 1);
+        else if (matchesKey(data, 'down'))
+            this.offset += 1;
+        else if (matchesKey(data, 'pageUp'))
+            this.offset = Math.max(0, this.offset - page);
+        else if (matchesKey(data, 'pageDown') || data === ' ')
+            this.offset += page;
+        else if (matchesKey(data, 'home'))
+            this.offset = 0;
+        else if (matchesKey(data, 'end'))
+            this.offset = Number.MAX_SAFE_INTEGER;
+        else
+            return false;
+        this.changed();
+        return true;
+    }
+    hint() {
+        return '↑↓ PgUp/PgDn scroll';
+    }
+}

package/dist/sdk/terminal/tui/pages/trajectoryPage.d.ts

@@ -0,0 +1,66 @@
+/** Saved run evidence for the current conversation: runs, their events, and the selected event's payload. */
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import { type TuiMouseEventResult } from '@earendil-works/pi-tui';
+import type { RunEvent } from "../../../sessions/contracts.js";
+import type { TerminalTrajectoryRun, TerminalTrajectorySnapshot } from "../../trajectory.js";
+import { type TabInfo } from "../chrome.js";
+import type { TerminalPage } from "../page.js";
+import type { TerminalMouseInput } from "../mouse.js";
+export interface TrajectoryPageOptions {
+    theme: () => Theme;
+    runs(): Promise<TerminalTrajectoryRun[]>;
+    read(runId: string, afterSequence?: number): Promise<TerminalTrajectorySnapshot>;
+    copy(text: string): Promise<void>;
+    /** Opens on this run when it is in the list; otherwise the newest. */
+    initialRunId?: string;
+    openContext?(runId: string): void;
+    notify(message: string, type?: string): void;
+    changed(): void;
+}
+export declare class TrajectoryPage implements TerminalPage {
+    private readonly options;
+    readonly presentation: "fullscreen";
+    private runs;
+    private section;
+    private readonly runList;
+    private readonly eventList;
+    private runIndex;
+    private run;
+    private events;
+    private detailOffset;
+    private listStart;
+    private listEnd;
+    private listWidth;
+    private detailsStart;
+    private wideLayout;
+    private loading;
+    private loaded;
+    private disposed;
+    private timer;
+    private error;
+    constructor(options: TrajectoryPageOptions);
+    get selectedRunId(): string | undefined;
+    get selectedEvent(): RunEvent | undefined;
+    get focused(): boolean;
+    set focused(value: boolean);
+    tabs(): readonly TabInfo[];
+    activeTab(): string;
+    activate(): void;
+    deactivate(): void;
+    dispose(): void;
+    private load;
+    private open;
+    private refresh;
+    /** `[` is the older run, `]` the newer one. */
+    private runRows;
+    private eventRows;
+    private eventJson;
+    private selectRun;
+    private changeRun;
+    hint(): string;
+    handleMouse(event: TerminalMouseInput): TuiMouseEventResult | undefined;
+    handleInput(data: string): boolean;
+    private runSummary;
+    private detailLines;
+    render(width: number, rows: number): string[];
+}