@xingular/harness 1.0.0 → 1.1.1

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

@@ -21,6 +21,8 @@ export declare class DoctorPage implements TerminalPage {
     private disposed;
     private busy;
     private offset;
+    private scrollRows;
+    private maxOffset;
     constructor(options: DoctorPageOptions);
     tabs(): readonly TabInfo[];
     activeTab(): string;

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

@@ -1,5 +1,35 @@
-import { matchesKey, stripTerminalSequences, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+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;
@@ -9,12 +39,14 @@ export class DoctorPage {
     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 · r refresh · t retry finding · l live checks · c cancel · Esc close'; }
+    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() {
@@ -104,10 +136,19 @@ export class DoctorPage {
             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++;
+            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')
@@ -128,18 +169,65 @@ export class DoctorPage {
     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 lines = [
-            this.error ?? (report ? `${report.mode} · ${report.state} · ${report.completed}/${report.total} checks` : 'Preparing diagnostics…'),
-            report ? `Account ${report.context.accountId ?? 'none'} · Model ${report.context.model ?? 'none'}` : '',
-            Object.entries(counts).map(([status, count]) => `${count} ${status}`).join(' · '),
-            ...report?.findings.flatMap(finding => [
-                '', `[${finding.status}] ${finding.category} · ${finding.title} (${finding.verification})`,
-                finding.evidence, ...(finding.remedy ? [`Action: ${finding.remedy}`] : [])
-            ]) ?? []
-        ].flatMap(line => stripTerminalSequences(line).replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, ' ').split('\n').flatMap(part => wrapTextWithAnsi(part, width)));
-        this.offset = Math.max(0, Math.min(this.offset, lines.length - rows));
-        return lines.slice(this.offset, this.offset + rows).map(line => this.options.theme().fg('text', line));
+        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/notesPage.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The Page notes page (`/plugin:notes`, `/plugin:annotate [url]`): notes a person keeps about web pages. A new note
+ * is captured in a visible browser window: the whole page, text the person selects, or an element
+ * they click. A note is private until it is shared with this session, whose agent can then read it
+ * with `page_notes_read` (PROP-0017).
+ */
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import type { MenuCall, MenuUi } from "../../pluginMenu.js";
+import type { TabInfo } from "../chrome.js";
+import { type ListRow } from "../list.js";
+import type { TerminalMouseInput } from "../mouse.js";
+import type { TerminalPage } from "../page.js";
+import type { Note } from "../../../annotations/store.js";
+export interface NotesPageOptions {
+    theme(): Theme;
+    call: MenuCall;
+    ui: MenuUi & {
+        input(title: string, placeholder?: string): Promise<string | undefined>;
+    };
+    changed(): void;
+    /** Start a new note as soon as the page opens (`/plugin:annotate [url]`), on this address when given. */
+    start?: {
+        url?: string;
+    };
+}
+type Row = {
+    kind: 'new';
+} | {
+    kind: 'note';
+    note: Note;
+};
+export declare const NOTE_KINDS: {
+    readonly page: "The whole page";
+    readonly text: "Text I select in the window";
+    readonly element: "An element I click in the window";
+};
+export declare const NOTE_ACTIONS: {
+    readonly reveal: "Show it in the browser window";
+    readonly edit: "Edit the note";
+    readonly resolve: "Mark resolved";
+    readonly reopen: "Reopen";
+    readonly share: "Let this session's agent read it";
+    readonly unshare: "Stop sharing it with this session";
+    readonly delete: "Delete";
+};
+export declare class NotesPage implements TerminalPage {
+    private readonly options;
+    presentation: "centered";
+    private notes;
+    private sessionId;
+    private error;
+    private busy;
+    private disposed;
+    private readonly list;
+    constructor(options: NotesPageOptions);
+    get focused(): boolean;
+    set focused(value: boolean);
+    activate(): void;
+    dispose(): void;
+    tabs(): readonly TabInfo[];
+    activeTab(): string;
+    hint(): string;
+    reload(): Promise<void>;
+    private shared;
+    rows(): ListRow<Row>[];
+    private attempt;
+    activateRow(row: Row): Promise<void>;
+    /** Opens the capture window, takes what the person points at, and saves their note. */
+    newNote(startUrl?: string): Promise<void>;
+    private noteMenu;
+    handleMouse(event: TerminalMouseInput): import("@earendil-works/pi-tui").TuiMouseEventResult | undefined;
+    handleInput(data: string): boolean;
+    render(width: number, rows: number): string[];
+}
+export {};

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

@@ -0,0 +1,201 @@
+import { truncateToWidth } from '@earendil-works/pi-tui';
+import { FilterList } from "../list.js";
+const TABS = [{ id: 'notes', title: 'Page notes' }];
+export const NOTE_KINDS = { page: 'The whole page', text: 'Text I select in the window', element: 'An element I click in the window' };
+export const NOTE_ACTIONS = {
+    reveal: 'Show it in the browser window',
+    edit: 'Edit the note',
+    resolve: 'Mark resolved',
+    reopen: 'Reopen',
+    share: 'Let this session\'s agent read it',
+    unshare: 'Stop sharing it with this session',
+    delete: 'Delete'
+};
+const clip = (text, size) => (text.length > size ? `${text.slice(0, size - 1)}…` : text);
+function describeTarget(target) {
+    if (target.kind === 'text')
+        return `“${clip(target.exact.replace(/\s+/g, ' '), 60)}”`;
+    if (target.kind === 'element')
+        return `<${target.tag}> ${clip(target.name || target.text, 50)}`;
+    return 'whole page';
+}
+export class NotesPage {
+    options;
+    presentation = 'centered';
+    notes;
+    sessionId = null;
+    error;
+    busy = false;
+    disposed = false;
+    list;
+    constructor(options) {
+        this.options = options;
+        this.list = new FilterList({
+            theme: options.theme, search: 'always', noun: ['note', 'notes'], empty: 'No page notes yet',
+            onActivate: row => { if (row.data)
+                void this.activateRow(row.data); }
+        });
+    }
+    get focused() { return this.list.focused; }
+    set focused(value) { this.list.focused = value; }
+    activate() {
+        void this.reload().then(() => {
+            if (this.options.start)
+                void this.newNote(this.options.start.url);
+        });
+    }
+    dispose() { this.disposed = true; }
+    tabs() { return TABS; }
+    activeTab() { return 'notes'; }
+    hint() { return 'Enter choose · type to search · Esc close'; }
+    async reload() {
+        try {
+            const result = await this.options.call('terminal.annotations.list');
+            this.notes = result.notes;
+            this.sessionId = result.sessionId;
+            this.error = undefined;
+        }
+        catch (error) {
+            this.error = error instanceof Error ? error.message : String(error);
+        }
+        if (this.disposed)
+            return;
+        this.list.setRows(this.rows());
+        this.options.changed();
+    }
+    shared(note) {
+        return note.grants.some(grant => grant.principal.sessionId && grant.principal.sessionId === this.sessionId);
+    }
+    rows() {
+        const rows = [{ id: 'new', label: 'New note on a page…', group: 'Actions', detail: 'opens a browser window', tone: 'accent', data: { kind: 'new' } }];
+        for (const note of this.notes ?? []) {
+            rows.push({
+                id: `note:${note.id}`, label: clip(note.body.replace(/\s+/g, ' '), 60), group: 'Notes',
+                detail: `${describeTarget(note.target)} · ${note.status}${this.shared(note) ? ' · shared here' : ''}`,
+                tone: note.status === 'resolved' ? 'dim' : this.shared(note) ? 'success' : 'muted',
+                searchText: `${note.body} ${note.source.url} ${note.source.title} ${note.tags.join(' ')}`,
+                data: { kind: 'note', note }
+            });
+        }
+        return rows;
+    }
+    async attempt(work) {
+        if (this.busy)
+            return;
+        this.busy = true;
+        try {
+            const message = await work();
+            if (message)
+                this.options.ui.notify(message, 'info');
+        }
+        catch (error) {
+            this.options.ui.notify(error instanceof Error ? error.message : String(error), 'error');
+        }
+        finally {
+            this.busy = false;
+        }
+        await this.reload();
+    }
+    async activateRow(row) {
+        if (row.kind === 'new')
+            return this.newNote();
+        return this.noteMenu(row.note);
+    }
+    /** Opens the capture window, takes what the person points at, and saves their note. */
+    newNote(startUrl) {
+        const { call, ui } = this.options;
+        return this.attempt(async () => {
+            const url = startUrl ?? await ui.input('Page address', 'https://');
+            if (!url)
+                return;
+            await call('terminal.annotations.open', { url });
+            const kind = await ui.select('What does the note point at?', Object.values(NOTE_KINDS));
+            if (!kind)
+                return;
+            let envelope;
+            if (kind === NOTE_KINDS.page) {
+                const identity = await call('terminal.annotations.identity');
+                envelope = { ...identity, target: { kind: 'page' } };
+            }
+            else {
+                const element = kind === NOTE_KINDS.element;
+                const { captureId } = await call('terminal.annotations.begin', { kind: element ? 'element' : 'text' });
+                const ready = await ui.confirm(element ? 'Click the element in the browser window' : 'Select the text in the browser window', 'When it is selected, choose Yes to capture it. Choose No to cancel.');
+                if (!ready) {
+                    await call('terminal.annotations.cancel', { captureId });
+                    return;
+                }
+                envelope = await call('terminal.annotations.capture', { captureId });
+                if (!envelope)
+                    return 'Nothing was selected in the browser window, so no note was made.';
+            }
+            const body = await ui.input('Note', 'What should be remembered about it?');
+            if (!body?.trim())
+                return 'A note needs some text; nothing was saved.';
+            const tags = (await ui.input('Tags (optional, comma separated)', '') ?? '').split(',').map(tag => tag.trim()).filter(Boolean);
+            const share = await ui.confirm('Share it with this session?', 'This session\'s agent can then read the note with page_notes_read. You can stop sharing it later.');
+            await call('terminal.annotations.create', {
+                source: { url: envelope.url, title: envelope.title, capturedAt: new Date().toISOString(), surface: 'terminal', representationHint: envelope.documentId },
+                target: envelope.target, body, tags, share
+            });
+            return share ? 'Note saved and shared with this session.' : 'Note saved. It stays private until you share it.';
+        });
+    }
+    async noteMenu(note) {
+        const { call, ui } = this.options;
+        const choices = [
+            NOTE_ACTIONS.reveal,
+            NOTE_ACTIONS.edit,
+            note.status === 'open' ? NOTE_ACTIONS.resolve : NOTE_ACTIONS.reopen,
+            this.shared(note) ? NOTE_ACTIONS.unshare : NOTE_ACTIONS.share,
+            NOTE_ACTIONS.delete
+        ];
+        const choice = await ui.select(`${clip(note.source.title || note.source.url, 60)} · ${describeTarget(note.target)}`, choices);
+        const id = note.id;
+        if (choice === NOTE_ACTIONS.reveal)
+            return this.attempt(async () => {
+                const result = await call('terminal.annotations.reveal', { id });
+                return result.state === 'matched' ? 'Marked in the browser window.' : `The target is ${result.state}${result.reason ? `: ${result.reason}` : ''}.`;
+            });
+        if (choice === NOTE_ACTIONS.edit)
+            return this.attempt(async () => {
+                const body = await ui.input('Note', note.body);
+                if (!body?.trim() || body === note.body)
+                    return;
+                await call('terminal.annotations.update', { id, expectedVersion: note.version, patch: { body } });
+                return 'Note saved.';
+            });
+        if (choice === NOTE_ACTIONS.resolve || choice === NOTE_ACTIONS.reopen)
+            return this.attempt(async () => {
+                await call('terminal.annotations.update', { id, expectedVersion: note.version, patch: { status: choice === NOTE_ACTIONS.resolve ? 'resolved' : 'open' } });
+            });
+        if (choice === NOTE_ACTIONS.share || choice === NOTE_ACTIONS.unshare)
+            return this.attempt(async () => {
+                await call(choice === NOTE_ACTIONS.share ? 'terminal.annotations.share' : 'terminal.annotations.unshare', { id });
+                return choice === NOTE_ACTIONS.share ? 'This session\'s agent can read the note.' : 'The note is no longer shared with this session.';
+            });
+        if (choice === NOTE_ACTIONS.delete)
+            return this.attempt(async () => {
+                if (!await ui.confirm('Delete this note?', 'It cannot be restored.'))
+                    return;
+                await call('terminal.annotations.delete', { id, expectedVersion: note.version });
+                return 'Note deleted.';
+            });
+    }
+    handleMouse(event) {
+        return this.list.handleMouse(event);
+    }
+    handleInput(data) {
+        return this.list.handleInput(data);
+    }
+    render(width, rows) {
+        const theme = this.options.theme();
+        if (width < 1 || rows < 1)
+            return [];
+        if (this.error)
+            return [theme.fg('error', `Could not read page notes: ${this.error}`)];
+        if (!this.notes)
+            return [theme.fg('dim', 'Reading page notes…')];
+        return this.list.render(width, rows).slice(0, rows).map(line => truncateToWidth(line, width, ''));
+    }
+}

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

@@ -16,6 +16,8 @@ export interface TerminalSettingItem {
 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;
@@ -23,10 +25,13 @@ export interface SettingsPageOptions {
 }
 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;
@@ -46,6 +51,9 @@ export declare class SettingsPage implements TerminalPage {
     } | {
         readonly id: "context";
         readonly title: "Context";
+    } | {
+        readonly id: "browser";
+        readonly title: "Browser";
     })[];
     activeTab(): string;
     hint(): string;

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

@@ -3,13 +3,16 @@ 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: '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;
@@ -21,6 +24,18 @@ export class SettingsPage {
             }
         });
         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; }

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

@@ -0,0 +1,23 @@
+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;
+}
+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,70 @@
+import { matchesKey, stripTerminalSequences, truncateToWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { headerRow, neutralRule, padded } from "../chrome.js";
+import { FilterList } from "../list.js";
+import { ACTIVE_SUBAGENT_STATUSES, terminalSubagentDuration, terminalSubagentTone } from "../../subagentMonitor.js";
+import { subagentTasks } from "../../opentui/subagentsWidget.js";
+const TABS = [{ id: 'subagents', title: 'Subagents' }];
+function clean(value) {
+    return stripTerminalSequences(value).replace(/[\x00-\x08\x0b-\x1f\x7f]/g, ' ').replace(/\s+/g, ' ').trim();
+}
+export class SubagentsPage {
+    options;
+    presentation = 'fullscreen';
+    list;
+    constructor(options) {
+        this.options = options;
+        this.list = new FilterList({
+            theme: options.theme, search: 'always', noun: ['subagent', 'subagents'], empty: 'No subagents have started in this turn'
+        });
+    }
+    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() {
+        return this.options.snapshot().map(item => ({
+            id: item.id,
+            label: `${clean(item.profile?.name ?? '') || 'subagent'} · ${clean(item.title) || 'Subagent'}`,
+            detail: [item.status.replaceAll('_', ' '), subagentTasks(item.checklist), terminalSubagentDuration(item)].filter(Boolean).join(' · '),
+            tone: terminalSubagentTone(item.status),
+            searchText: `${item.profile?.name ?? ''} ${item.title} ${item.goal ?? ''} ${item.status} ${item.activity}`,
+            data: item
+        }));
+    }
+    render(width, rows) {
+        const items = this.rows();
+        this.list.setRows(items);
+        const active = items.filter(item => item.data && ACTIVE_SUBAGENT_STATUSES.has(item.data.status)).length;
+        const selected = this.list.selected?.data;
+        const header = headerRow('Subagents', `${active} active · ${items.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 textWidth = Math.max(1, width - 4);
+            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(...wrapTextWithAnsi(theme.fg('text', clean(selected.goal || 'Subagent')), textWidth));
+            output.push(padded(theme.fg('muted', `Status: ${[selected.status.replaceAll('_', ' '), subagentTasks(selected.checklist), terminalSubagentDuration(selected)].filter(Boolean).join(' · ')}`), width));
+            output.push(padded(theme.fg('accent', 'Current activity'), width));
+            output.push(...wrapTextWithAnsi(theme.fg('text', clean(selected.activity)), textWidth));
+        }
+        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/trajectoryPage.d.ts

@@ -5,7 +5,7 @@ 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";
+import type { TerminalMouseInput } from "../mouse.js";
 export interface TrajectoryPageOptions {
     theme: () => Theme;
     runs(): Promise<TerminalTrajectoryRun[]>;
@@ -18,17 +18,20 @@ export interface TrajectoryPageOptions {
 }
 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 selected;
     private detailOffset;
-    private eventRowsStart;
-    private eventRowsFirst;
-    private eventRowsCount;
+    private listStart;
+    private listEnd;
+    private listWidth;
+    private detailsStart;
+    private wideLayout;
     private loading;
     private loaded;
     private disposed;
@@ -49,10 +52,14 @@ export declare class TrajectoryPage implements TerminalPage {
     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[];
 }