@xingular/harness 0.1.7 → 1.1.1

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

@@ -0,0 +1,47 @@
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import { type ComponentItem } from "../../../variant/components.js";
+import type { MenuUi } from "../../pluginMenu.js";
+import { type TabInfo } from "../chrome.js";
+import type { TerminalPage } from "../page.js";
+import type { TerminalMouseInput } from "../mouse.js";
+export interface ComponentLibrarySnapshot {
+    items: ComponentItem[];
+    addedIds: string[];
+    writable: boolean;
+    fingerprint: string | null;
+}
+export interface ComponentAddedResult {
+    fingerprint: string;
+    alreadyPresent: boolean;
+}
+export type ComponentPageCall = <T = unknown>(method: string, params?: Record<string, unknown>) => Promise<T>;
+export interface ComponentsPageOptions {
+    theme: () => Theme;
+    call: ComponentPageCall;
+    ui: MenuUi;
+    notify(message: string, type?: string): void;
+    changed(): void;
+}
+export declare class ComponentsPage implements TerminalPage {
+    private readonly options;
+    private snapshot;
+    private section;
+    private error;
+    private busy;
+    private disposed;
+    private readonly list;
+    constructor(options: ComponentsPageOptions);
+    get focused(): boolean;
+    set focused(value: boolean);
+    tabs(): readonly TabInfo[];
+    activeTab(): string;
+    activate(): void;
+    dispose(): void;
+    hint(): string;
+    private load;
+    private fill;
+    private add;
+    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/componentsPage.js

@@ -0,0 +1,119 @@
+import { matchesKey, truncateToWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { safeText } from "../chrome.js";
+import { FilterList } from "../list.js";
+const SECTIONS = [
+    { id: 'skills', title: 'Skills' },
+    { id: 'prompts', title: 'Prompts' },
+    { id: 'rules', title: 'Rules' }
+];
+export class ComponentsPage {
+    options;
+    snapshot;
+    section = 'skills';
+    error;
+    busy = false;
+    disposed = false;
+    list;
+    constructor(options) {
+        this.options = options;
+        this.list = new FilterList({
+            theme: options.theme, search: 'always', noun: ['item', 'items'], empty: 'This library section is empty.',
+            onActivate: row => { void this.add(row.data); }
+        });
+    }
+    get focused() { return this.list.focused; }
+    set focused(value) { this.list.focused = value; }
+    tabs() { return SECTIONS; }
+    activeTab() { return this.section; }
+    activate() { if (!this.snapshot)
+        void this.load(); }
+    dispose() { this.disposed = true; }
+    hint() { return this.list.query ? 'Enter add · Esc clear' : 'Enter add eligible item · type to search'; }
+    async load() {
+        try {
+            this.snapshot = await this.options.call('terminal.components.list');
+            this.error = undefined;
+        }
+        catch (error) {
+            this.error = error instanceof Error ? error.message : String(error);
+        }
+        if (this.disposed)
+            return;
+        this.fill();
+        this.options.changed();
+    }
+    fill() {
+        const items = (this.snapshot?.items ?? []).filter(item => item.kind === this.section);
+        const added = new Set(this.snapshot?.addedIds ?? []);
+        this.list.setRows(items.map(item => {
+            const exists = added.has(item.id);
+            const detail = exists ? 'In Harness' : item.kind === 'prompts' ? 'Library only' : this.snapshot?.writable ? 'Add for next session' : 'Browse only';
+            return {
+                id: item.id, label: safeText(item.name), group: item.builtin ? 'Built-in' : 'Library',
+                detail, tone: exists ? 'success' : item.kind === 'prompts' ? 'dim' : 'muted',
+                searchText: item.name + ' ' + item.description + ' ' + item.id, data: item
+            };
+        }));
+    }
+    async add(item) {
+        if (!item || this.busy)
+            return;
+        if (item.kind === 'prompts') {
+            this.options.notify('Prompts stay in the library and cannot be added to a Variant.', 'info');
+            return;
+        }
+        if ((this.snapshot?.addedIds ?? []).includes(item.id)) {
+            this.options.notify('This item is already in the current Variant.', 'info');
+            return;
+        }
+        if (!this.snapshot?.writable) {
+            this.options.notify('This terminal has no writable Harness scope. The library is browse-only.', 'warning');
+            return;
+        }
+        const approved = await this.options.ui.confirm('Add ' + item.name + '?', 'This creates a new Variant version for the next session. The running terminal keeps its pinned version.');
+        if (!approved)
+            return;
+        this.busy = true;
+        try {
+            const result = await this.options.call('terminal.components.add', { id: item.id });
+            this.options.notify(result.alreadyPresent ? 'This item is already in the current Variant.' : 'Saved for the next session · version ' + result.fingerprint, 'info');
+            await this.load();
+        }
+        catch (error) {
+            this.options.notify(error instanceof Error ? error.message : String(error), 'error');
+        }
+        finally {
+            this.busy = false;
+        }
+    }
+    handleMouse(event) {
+        return this.list.handleMouse(event);
+    }
+    handleInput(data) {
+        if (matchesKey(data, 'tab') || matchesKey(data, 'shift+tab')) {
+            if (!this.list.query) {
+                const at = SECTIONS.findIndex(section => section.id === this.section);
+                const delta = matchesKey(data, 'shift+tab') ? -1 : 1;
+                this.section = SECTIONS[(at + delta + SECTIONS.length) % SECTIONS.length].id;
+                this.fill();
+            }
+            return true;
+        }
+        return this.list.handleInput(data);
+    }
+    render(width, rows) {
+        const theme = this.options.theme();
+        if (width < 1 || rows < 1)
+            return [];
+        if (!this.snapshot)
+            return [theme.fg(this.error ? 'error' : 'dim', this.error ? 'Could not read the component library: ' + this.error : 'Reading the component library…')];
+        const selected = this.list.selected?.data;
+        const detail = selected && rows >= 8
+            ? wrapTextWithAnsi(safeText(selected.description || 'No description.'), width).slice(0, Math.min(3, rows - 4))
+            : [];
+        const lines = this.list.render(width, Math.max(2, rows - (detail.length ? detail.length + 1 : 0)));
+        if (detail.length)
+            lines.push('', ...detail.map(line => theme.fg('muted', line)));
+        return lines.slice(0, rows).map(line => truncateToWidth(line, width, ''));
+    }
+}

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

@@ -0,0 +1,39 @@
+import type { Theme, ExtensionUIContext } from '@earendil-works/pi-coding-agent';
+import type { TerminalPage } from "../page.js";
+import type { TabInfo } from "../chrome.js";
+interface DoctorPageOptions {
+    theme(): Theme;
+    call(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    selection(): {
+        model: string | null;
+        tools: string[];
+    };
+    confirm: ExtensionUIContext['confirm'];
+    select: ExtensionUIContext['select'];
+    changed(): void;
+}
+export declare class DoctorPage implements TerminalPage {
+    private readonly options;
+    focused: boolean;
+    private report?;
+    private error?;
+    private timer?;
+    private disposed;
+    private busy;
+    private offset;
+    private scrollRows;
+    private maxOffset;
+    constructor(options: DoctorPageOptions);
+    tabs(): readonly TabInfo[];
+    activeTab(): string;
+    hint(): string;
+    activate(): void;
+    dispose(): void;
+    private start;
+    private poll;
+    private chooseLive;
+    private retry;
+    handleInput(data: string): boolean;
+    render(width: number, rows: number): string[];
+}
+export {};

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

@@ -0,0 +1,233 @@
+import { matchesKey, stripTerminalSequences, truncateToWidth, visibleWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { doctorReportSchema } from "../../../doctor/types.js";
+const STATUSES = ['pass', 'warning', 'fail', 'disabled', 'blocked', 'unverified'];
+const STATUS_TONE = {
+    pass: 'success', warning: 'warning', fail: 'error', disabled: 'dim', blocked: 'warning', unverified: 'muted'
+};
+function cleanText(value) {
+    return stripTerminalSequences(value).replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, ' ').replace(/\t/g, ' ');
+}
+function oneLine(value) {
+    return cleanText(value).replace(/\s+/g, ' ').trim();
+}
+function padCell(value, width) {
+    const fitted = truncateToWidth(value, width, '');
+    return fitted + ' '.repeat(Math.max(0, width - visibleWidth(fitted)));
+}
+function tableRow(cells, widths, width) {
+    const wrapped = cells.map((cell, index) => {
+        const lines = wrapTextWithAnsi(cell, widths[index]);
+        return lines.length ? lines : [''];
+    });
+    const height = Math.max(...wrapped.map(lines => lines.length));
+    return Array.from({ length: height }, (_, row) => truncateToWidth(wrapped.map((lines, column) => padCell(lines[row] ?? '', widths[column])).join('  '), width, ''));
+}
+function appendDetails(lines, label, value, width, theme) {
+    if (!value?.trim())
+        return;
+    for (const paragraph of cleanText(value).split('\n')) {
+        const wrapped = wrapTextWithAnsi(`${label}: ${paragraph}`, Math.max(1, width - 2));
+        lines.push(...(wrapped.length ? wrapped : [`${label}:`]).map(line => theme.fg('muted', `  ${line}`)));
+    }
+}
+export class DoctorPage {
+    options;
+    focused = false;
+    report;
+    error;
+    timer;
+    disposed = false;
+    busy = false;
+    offset = 0;
+    scrollRows = 1;
+    maxOffset = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    tabs() { return [{ id: 'doctor', title: 'Doctor' }]; }
+    activeTab() { return 'doctor'; }
+    hint() { return '↑/↓ scroll · PgUp/PgDn/wheel page · Home/End · r refresh · t retry · l live · c cancel · Esc close'; }
+    activate() { if (!this.report && !this.busy)
+        void this.start(); }
+    dispose() {
+        this.disposed = true;
+        clearTimeout(this.timer);
+        if (this.report?.state === 'running')
+            void this.options.call('terminal.doctor.cancel', { id: this.report.id }).catch(() => undefined);
+    }
+    async start(mode = 'local', checks = []) {
+        if (this.busy || this.disposed)
+            return;
+        this.busy = true;
+        this.error = undefined;
+        clearTimeout(this.timer);
+        try {
+            if (this.report?.state === 'running')
+                await this.options.call('terminal.doctor.cancel', { id: this.report.id });
+            const result = await this.options.call('terminal.doctor.start', { ...this.options.selection(), mode, checks, confirmed: mode === 'live' });
+            this.report = doctorReportSchema.parse(result);
+            this.offset = 0;
+            if (this.disposed) {
+                await this.options.call('terminal.doctor.cancel', { id: this.report.id });
+                return;
+            }
+            this.poll();
+        }
+        catch {
+            this.error = 'Diagnostics could not be started. Check the host connection.';
+        }
+        finally {
+            this.busy = false;
+            if (!this.disposed)
+                this.options.changed();
+        }
+    }
+    poll() {
+        if (this.disposed || this.report?.state !== 'running')
+            return;
+        const id = this.report.id;
+        this.timer = setTimeout(() => {
+            void this.options.call('terminal.doctor.read', { id }).then(result => {
+                if (this.disposed || this.report?.id !== id)
+                    return;
+                this.report = doctorReportSchema.parse(result);
+                this.options.changed();
+                this.poll();
+            }).catch(() => { this.error = 'The diagnostic host connection was lost.'; this.options.changed(); });
+        }, 200);
+    }
+    async chooseLive() {
+        const report = this.report;
+        if (!report || this.busy || report.state === 'running')
+            return;
+        const selected = [];
+        const checks = report.liveChecks;
+        while (!this.disposed) {
+            const labels = checks.map(check => `${selected.includes(check.id) ? '[x]' : '[ ]'} ${check.title}`);
+            const run = 'Run selected checks';
+            const choice = await this.options.select('Select live checks', [...labels, run]);
+            if (!choice || this.disposed)
+                return;
+            if (choice === run)
+                break;
+            const check = checks[labels.indexOf(choice)];
+            if (check) {
+                const index = selected.indexOf(check.id);
+                if (index < 0)
+                    selected.push(check.id);
+                else
+                    selected.splice(index, 1);
+            }
+        }
+        if (!selected.length || this.disposed)
+            return;
+        const notice = [`Account: ${report.context.accountId ?? 'none'}`, `Model: ${report.context.model ?? 'none'}`, ...checks.filter(check => selected.includes(check.id)).map(check => `${check.title}: ${check.notice}`)].join('\n\n');
+        if (await this.options.confirm('Run these live diagnostics?', notice) && !this.disposed)
+            await this.start('live', selected);
+    }
+    async retry() {
+        const report = this.report;
+        if (!report || this.busy || report.state === 'running')
+            return;
+        const labels = report.findings.map(finding => `${finding.status}: ${finding.title}`);
+        const selected = await this.options.select('Retry local readiness check', labels);
+        const finding = selected ? report.findings[labels.indexOf(selected)] : undefined;
+        if (finding && !this.disposed)
+            await this.start('local', finding.id === 'doctor' ? [] : [finding.id]);
+    }
+    handleInput(data) {
+        const page = Math.max(1, this.scrollRows - 1);
+        if (matchesKey(data, 'up'))
+            this.offset = Math.max(0, this.offset - 1);
+        else if (matchesKey(data, 'down'))
+            this.offset = Math.min(this.maxOffset, this.offset + 1);
+        else if (matchesKey(data, 'pageUp'))
+            this.offset = Math.max(0, this.offset - page);
+        else if (matchesKey(data, 'pageDown'))
+            this.offset = Math.min(this.maxOffset, this.offset + page);
+        else if (matchesKey(data, 'home'))
+            this.offset = 0;
+        else if (matchesKey(data, 'end'))
+            this.offset = this.maxOffset;
+        else if (data === 'r')
+            void this.start();
+        else if (data === 'l')
+            void this.chooseLive();
+        else if (data === 't')
+            void this.retry();
+        else if (data === 'c' && this.report?.state === 'running') {
+            void this.options.call('terminal.doctor.cancel', { id: this.report.id }).then(result => {
+                this.report = doctorReportSchema.parse(result);
+                clearTimeout(this.timer);
+                this.options.changed();
+            }).catch(() => { this.error = 'Could not cancel diagnostics.'; this.options.changed(); });
+        }
+        else
+            return false;
+        return true;
+    }
+    render(width, rows) {
+        if (width < 1 || rows < 1)
+            return [];
+        const theme = this.options.theme();
+        const report = this.report;
+        const counts = report?.findings.reduce((all, finding) => {
+            all[finding.status] = (all[finding.status] ?? 0) + 1;
+            return all;
+        }, {}) ?? {};
+        const stateTone = report?.state === 'completed' ? 'success' : report?.state === 'cancelled' ? 'warning' : 'accent';
+        const summary = report ? [
+            ...wrapTextWithAnsi(theme.bold(theme.fg(stateTone, `${report.mode} · ${report.state} · ${report.completed}/${report.total} checks`)), width),
+            ...wrapTextWithAnsi(theme.fg('muted', `Account ${oneLine(report.context.accountId ?? 'none')} · Model ${oneLine(report.context.model ?? 'none')}`), width),
+            ...wrapTextWithAnsi(STATUSES.filter(status => counts[status]).map(status => theme.fg(STATUS_TONE[status], `${counts[status]} ${status}`)).join(theme.fg('dim', ' · ')), width)
+        ] : [theme.fg(this.error ? 'error' : 'dim', this.error ?? 'Preparing diagnostics…')];
+        if (this.error && report)
+            summary.unshift(...wrapTextWithAnsi(theme.fg('error', this.error), width));
+        const content = [];
+        if (report?.findings.length) {
+            const statusWidth = 11;
+            const categoryWidth = 14;
+            const verificationWidth = 12;
+            const gapsWidth = 6;
+            const checkWidth = width - statusWidth - categoryWidth - verificationWidth - gapsWidth;
+            if (checkWidth >= 18) {
+                const widths = [statusWidth, checkWidth, categoryWidth, verificationWidth];
+                content.push(...tableRow([
+                    theme.bold(theme.fg('dim', 'STATUS')),
+                    theme.bold(theme.fg('dim', 'CHECK')),
+                    theme.bold(theme.fg('dim', 'CATEGORY')),
+                    theme.bold(theme.fg('dim', 'VERIFY'))
+                ], widths, width));
+                for (const [index, finding] of report.findings.entries()) {
+                    content.push(...tableRow([
+                        theme.bold(theme.fg(STATUS_TONE[finding.status], finding.status.toUpperCase())),
+                        oneLine(finding.title), oneLine(finding.category), oneLine(finding.verification)
+                    ], widths, width));
+                    appendDetails(content, 'Evidence', finding.evidence, width, theme);
+                    appendDetails(content, 'Next step', finding.remedy, width, theme);
+                    if (index < report.findings.length - 1)
+                        content.push('');
+                }
+            }
+            else {
+                for (const [index, finding] of report.findings.entries()) {
+                    const heading = `${theme.bold(theme.fg(STATUS_TONE[finding.status], finding.status.toUpperCase()))} · ${oneLine(finding.title)}`;
+                    content.push(...wrapTextWithAnsi(heading, width));
+                    content.push(...wrapTextWithAnsi(theme.fg('dim', `${oneLine(finding.category)} · ${oneLine(finding.verification)}`), width));
+                    appendDetails(content, 'Evidence', finding.evidence, width, theme);
+                    appendDetails(content, 'Next step', finding.remedy, width, theme);
+                    if (index < report.findings.length - 1)
+                        content.push('');
+                }
+            }
+        }
+        else {
+            content.push(theme.fg('dim', report?.state === 'running' ? 'Waiting for findings…' : 'No findings to show.'));
+        }
+        const bodyRows = Math.max(0, rows - summary.length);
+        this.scrollRows = Math.max(1, bodyRows);
+        this.maxOffset = Math.max(0, content.length - bodyRows);
+        this.offset = Math.max(0, Math.min(this.offset, this.maxOffset));
+        return [...summary, ...content.slice(this.offset, this.offset + bodyRows)].slice(0, rows).map(line => truncateToWidth(line, width, ''));
+    }
+}

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

@@ -0,0 +1,39 @@
+/**
+ * The Hub page: the reviewed catalog of skills, plugins and reusable documents. Installing asks first,
+ * installs exactly the listed version, and leaves code switched off and untrusted.
+ */
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import type { MenuCall, MenuUi } from "../../pluginMenu.js";
+import { type TabInfo } from "../chrome.js";
+import type { TerminalPage } from "../page.js";
+import type { TerminalMouseInput } from "../mouse.js";
+export interface HubPageOptions {
+    theme: () => Theme;
+    call: MenuCall;
+    ui: MenuUi;
+    changed(): void;
+}
+export declare class HubPage implements TerminalPage {
+    private readonly options;
+    private catalog;
+    private section;
+    private error;
+    private busy;
+    private disposed;
+    private readonly list;
+    constructor(options: HubPageOptions);
+    get focused(): boolean;
+    set focused(value: boolean);
+    activate(): void;
+    dispose(): void;
+    tabs(): readonly TabInfo[];
+    activeTab(): string;
+    hint(): string;
+    private load;
+    private fill;
+    private rows;
+    private activateRow;
+    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/hubPage.js

@@ -0,0 +1,128 @@
+import { matchesKey, truncateToWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { installHubEntry } from "../../hubMenu.js";
+import { safeText } from "../chrome.js";
+import { FilterList } from "../list.js";
+const SECTIONS = [
+    { id: 'catalog', title: 'Catalog' },
+    { id: 'installed', title: 'Installed' }
+];
+const REFRESH = 'action:refresh';
+export class HubPage {
+    options;
+    catalog;
+    section = 'catalog';
+    error;
+    busy = false;
+    disposed = false;
+    list;
+    constructor(options) {
+        this.options = options;
+        this.list = new FilterList({
+            theme: options.theme, search: 'always', noun: ['entry', 'entries'], empty: 'The catalog has no entries.',
+            onActivate: row => { void this.activateRow(row.id); }
+        });
+    }
+    get focused() { return this.list.focused; }
+    set focused(value) { this.list.focused = value; }
+    activate() { if (!this.catalog)
+        void this.load(false); }
+    dispose() { this.disposed = true; }
+    tabs() { return SECTIONS; }
+    activeTab() { return this.section; }
+    hint() {
+        return this.list.query ? 'Enter open · Esc clear' : this.section === 'catalog' ? 'Enter review and install · type to search' : 'Select an installed entry · type to search';
+    }
+    async load(refresh) {
+        try {
+            const catalog = await this.options.call('hub.list', refresh ? { refresh: true } : {});
+            this.catalog = catalog;
+            this.error = undefined;
+            if (refresh && catalog.error)
+                this.options.ui.notify(`${catalog.error} Using ${catalog.origin} content.`, 'warning');
+        }
+        catch (error) {
+            this.error = error instanceof Error ? error.message : String(error);
+        }
+        if (this.disposed)
+            return;
+        this.fill();
+        this.options.changed();
+    }
+    fill() {
+        this.list.setRows(this.rows());
+    }
+    rows() {
+        if (this.section === 'installed') {
+            return [
+                ...(this.catalog?.installed ?? []).map(receipt => ({
+                    id: 'installed:' + receipt.entry.id + '@' + receipt.entry.version,
+                    label: safeText(receipt.entry.title),
+                    group: receipt.entry.category,
+                    detail: (receipt.state ?? 'installed') + ' · ' + receipt.entry.version,
+                    tone: receipt.state === 'installed' ? 'success' : 'warning',
+                    searchText: receipt.entry.title + ' ' + receipt.entry.category + ' ' + receipt.entry.id + ' ' + receipt.entry.publisher + ' ' + (receipt.state ?? '')
+                }))
+            ];
+        }
+        const entries = [...(this.catalog?.entries ?? [])].sort((left, right) => left.category.localeCompare(right.category));
+        return [
+            ...entries.map(entry => ({
+                id: entry.id + '@' + entry.version, label: safeText(entry.title), group: safeText(entry.category),
+                detail: entry.version, tone: 'muted', searchText: entry.title + ' ' + entry.category + ' ' + entry.id + ' ' + entry.publisher
+            })),
+            { id: REFRESH, label: '⟳ Refresh catalog', group: 'Actions', tone: 'accent' }
+        ];
+    }
+    async activateRow(id) {
+        if (this.busy)
+            return;
+        this.busy = true;
+        try {
+            if (id === REFRESH) {
+                await this.load(true);
+                return;
+            }
+            if (id.startsWith('installed:'))
+                return;
+            const entry = this.catalog?.entries.find(candidate => candidate.id + '@' + candidate.version === id);
+            if (entry)
+                await installHubEntry(this.options.ui, this.options.call, entry);
+        }
+        finally {
+            this.busy = false;
+        }
+    }
+    handleMouse(event) {
+        return this.list.handleMouse(event);
+    }
+    handleInput(data) {
+        if (matchesKey(data, 'tab') || matchesKey(data, 'shift+tab')) {
+            if (!this.list.query) {
+                this.section = this.section === 'catalog' ? 'installed' : 'catalog';
+                this.fill();
+            }
+            return true;
+        }
+        return this.list.handleInput(data);
+    }
+    render(width, rows) {
+        const theme = this.options.theme();
+        if (width < 1 || rows < 1)
+            return [];
+        if (!this.catalog)
+            return [theme.fg(this.error ? 'error' : 'dim', this.error ? 'Could not read the catalog: ' + this.error : 'Reading the catalog…')];
+        const selectedId = this.list.selected?.id;
+        const installed = this.section === 'installed'
+            ? this.catalog.installed.find(receipt => 'installed:' + receipt.entry.id + '@' + receipt.entry.version === selectedId)
+            : undefined;
+        const entry = installed?.entry ?? this.catalog.entries.find(candidate => candidate.id + '@' + candidate.version === selectedId);
+        const detail = entry && rows >= 9
+            ? [...wrapTextWithAnsi(safeText(entry.description), width).slice(0, 3), entry.publisher + ' · ' + entry.license + ' · ' + entry.id,
+                ...(installed ? ['Installed ' + installed.installedAt + ' · ' + (installed.state ?? 'installed')] : [])]
+            : [];
+        const lines = this.list.render(width, Math.max(2, rows - (detail.length ? detail.length + 1 : 0)));
+        if (detail.length)
+            lines.push('', ...detail.map(line => theme.fg('muted', safeText(line))));
+        return lines.slice(0, rows).map(line => truncateToWidth(line, width, ''));
+    }
+}

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

@@ -0,0 +1,38 @@
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import type { TerminalTrajectorySnapshot } from "../../trajectory.js";
+import type { TabInfo } from "../chrome.js";
+import type { TerminalPage } from "../page.js";
+export interface LogSection {
+    title: string;
+    text: string;
+}
+export declare function formatRunEventLog(snapshots: TerminalTrajectorySnapshot[]): string;
+export interface LogPageOptions {
+    theme: () => Theme;
+    /** The diagnostic sources, read when the page is first shown and not again while the overlay is open. */
+    load(): Promise<LogSection[]>;
+    changed(): void;
+}
+/** A static view of the diagnostic snapshot taken when the page was first shown. */
+export declare class LogPage implements TerminalPage {
+    private readonly options;
+    focused: boolean;
+    private sections;
+    private error;
+    private source;
+    private offset;
+    private atEnd;
+    private maxOffset;
+    private rows;
+    private disposed;
+    constructor(options: LogPageOptions);
+    activate(): void;
+    dispose(): void;
+    tabs(): readonly TabInfo[];
+    activeTab(): string;
+    hint(): string;
+    private changeSource;
+    private currentOffset;
+    handleInput(data: string): boolean;
+    render(width: number, rows: number): string[];
+}