@xingular/harness 2.0.0 → 2.0.1-unstable

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

@@ -0,0 +1,397 @@
+import { matchesKey, stripTerminalSequences, truncateToWidth, visibleWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+const PERIODS = [
+    { key: '1', period: 'today', label: 'today' },
+    { key: '2', period: '7d', label: '7d' },
+    { key: '3', period: '30d', label: '30d' },
+    { key: '0', period: 'all', label: 'all time' }
+];
+const SCOPES = [
+    { key: 'c', scope: 'account', label: 'account' },
+    { key: 's', scope: 'session', label: 'session' },
+    { key: 'p', scope: 'project', label: 'project' },
+    { key: 'a', scope: 'all', label: 'all accounts' }
+];
+const BARS = '▁▂▃▄▅▆▇█';
+function clean(value) {
+    return stripTerminalSequences(value).replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, ' ').replace(/\t/g, ' ');
+}
+function oneLine(value) {
+    return clean(value).replace(/\s+/g, ' ').trim();
+}
+function count(value) {
+    if (!Number.isFinite(value))
+        return '0';
+    if (value >= 1_000_000_000)
+        return `${(value / 1_000_000_000).toFixed(1)}B`;
+    if (value >= 1_000_000)
+        return `${(value / 1_000_000).toFixed(1)}M`;
+    if (value >= 1_000)
+        return `${(value / 1_000).toFixed(1)}K`;
+    return String(Math.round(value));
+}
+function money(value) {
+    if (value === null)
+        return '—';
+    return value >= 1 ? `$${value.toFixed(2)}` : `$${value.toFixed(3)}`;
+}
+function duration(milliseconds) {
+    if (milliseconds === null)
+        return '—';
+    if (milliseconds < 1_000)
+        return `${Math.round(milliseconds)}ms`;
+    return `${(milliseconds / 1_000).toFixed(1)}s`;
+}
+function until(iso, now = Date.now()) {
+    if (!iso)
+        return '';
+    const at = Date.parse(iso);
+    if (Number.isNaN(at))
+        return '';
+    const delta = at - now;
+    if (delta <= 0)
+        return 'reset due';
+    const minutes = Math.round(delta / 60_000);
+    if (minutes < 60)
+        return `resets in ${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 48)
+        return `resets in ${hours}h ${minutes % 60}m`;
+    return `resets in ${Math.floor(hours / 24)}d`;
+}
+function ago(iso) {
+    const at = Date.parse(iso);
+    if (Number.isNaN(at))
+        return 'unknown time';
+    const minutes = Math.max(0, Math.round((Date.now() - at) / 60_000));
+    if (minutes < 1)
+        return 'just now';
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.round(minutes / 60);
+    return hours < 48 ? `${hours}h ago` : `${Math.round(hours / 24)}d ago`;
+}
+function usageLine(totals) {
+    const parts = [
+        `${count(totals.inputTokens)} in`,
+        `${count(totals.cacheReadTokens)} cached`,
+        `${count(totals.outputTokens)} out`,
+        `${count(totals.requests)} requests`,
+        money(totals.costUsd)
+    ];
+    if (totals.unpricedRequests)
+        parts.push(`${totals.unpricedRequests} unpriced`);
+    return parts.join(' · ');
+}
+function share(value, total) {
+    if (!total)
+        return '0%';
+    return `${Math.round((value / total) * 100)}%`;
+}
+function tokensOf(row) {
+    return row.inputTokens + row.cacheReadTokens + row.cacheWriteTokens + row.outputTokens;
+}
+/** A quota-left bar: green with room, amber when it narrows, red when it runs out. */
+function barTone(percent, rejected = false) {
+    if (rejected)
+        return 'error';
+    if (percent === null || percent === undefined)
+        return 'dim';
+    if (percent >= 50)
+        return 'success';
+    if (percent >= 20)
+        return 'warning';
+    return 'error';
+}
+function bar(percent, width, theme, rejected = false) {
+    const track = '░'.repeat(width);
+    if (percent === null || percent === undefined)
+        return `[${theme.fg('dim', track)}]`;
+    const filled = Math.max(0, Math.min(width, Math.round((Math.max(0, Math.min(100, percent)) / 100) * width)));
+    return `[${theme.fg(barTone(percent, rejected), '█'.repeat(filled))}${theme.fg('dim', '░'.repeat(Math.max(0, width - filled)))}]`;
+}
+/** A label on the left and a quiet value on the right of the same row. */
+function spread(left, right, width) {
+    if (!right)
+        return left;
+    const rightText = truncateToWidth(right, Math.max(0, width - visibleWidth(left) - 2), '');
+    return left + ' '.repeat(Math.max(1, width - visibleWidth(left) - visibleWidth(rightText))) + rightText;
+}
+export class UsagePage {
+    options;
+    presentation = 'fullscreen';
+    focused = false;
+    tab;
+    period = '7d';
+    scope = 'account';
+    summary;
+    limitsSummary;
+    limits;
+    allLimits;
+    busy = false;
+    reloadPending = false;
+    error;
+    refreshLimits;
+    offset = 0;
+    scrollRows = 1;
+    maxOffset = 0;
+    disposed = false;
+    constructor(options) {
+        this.options = options;
+        this.tab = options.initialTab ?? 'analysis';
+        this.period = options.initialPeriod ?? '7d';
+        this.refreshLimits = this.tab === 'limits';
+    }
+    tabs() {
+        return [{ id: 'analysis', title: 'Analysis' }, { id: 'limits', title: 'Limits' }, { id: 'accounts', title: 'All accounts' }];
+    }
+    activeTab() {
+        return this.tab;
+    }
+    selectTab(id) {
+        if ((id === 'analysis' || id === 'limits' || id === 'accounts') && id !== this.tab) {
+            this.tab = id;
+            this.offset = 0;
+            this.options.changed();
+            if (id === 'accounts')
+                void this.load();
+            else if (id === 'limits' && !this.limits) {
+                this.refreshLimits = true;
+                void this.load();
+            }
+            else if (id === 'analysis' && !this.summary)
+                void this.load();
+            else if (id === 'limits' && this.refreshLimits)
+                void this.load();
+        }
+    }
+    hint() {
+        return this.tab === 'analysis'
+            ? '↑/↓ scroll · PgUp/PgDn page · 1 today 2 7d 3 30d 0 all · c account s session p project a all accounts · r refresh'
+            : '↑/↓ scroll · PgUp/PgDn page · r read provider limits';
+    }
+    activate() {
+        if (!this.summary && !this.limits && !this.allLimits)
+            void this.load();
+    }
+    dispose() {
+        this.disposed = true;
+    }
+    async load() {
+        if (this.disposed)
+            return;
+        if (this.busy) {
+            this.reloadPending = true;
+            return;
+        }
+        this.busy = true;
+        this.error = undefined;
+        this.options.changed();
+        try {
+            if (this.tab === 'analysis') {
+                this.summary = await this.options.call('terminal.usage.summary', {
+                    scope: this.scope,
+                    period: this.period,
+                    timezoneOffsetMinutes: -new Date().getTimezoneOffset()
+                });
+            }
+            else if (this.tab === 'accounts') {
+                if (!this.allLimits) {
+                    this.allLimits = await this.options.call('terminal.usage.allLimits', { refresh: false });
+                    if (!this.disposed)
+                        this.options.changed();
+                }
+                this.allLimits = await this.options.call('terminal.usage.allLimits', { refresh: true });
+            }
+            else {
+                // The provider's windows and this app's own ledger answer different questions; show both.
+                const [limits, summary] = await Promise.all([
+                    this.options.call('terminal.usage.limits', { refresh: this.refreshLimits }),
+                    this.options.call('terminal.usage.summary', {
+                        scope: 'account',
+                        period: '7d',
+                        timezoneOffsetMinutes: -new Date().getTimezoneOffset()
+                    })
+                ]);
+                this.limits = limits;
+                this.limitsSummary = summary;
+                this.refreshLimits = false;
+            }
+            this.offset = 0;
+        }
+        catch (error) {
+            this.error = error instanceof Error ? error.message : 'Usage could not be read.';
+        }
+        finally {
+            this.busy = false;
+            if (!this.disposed) {
+                this.options.changed();
+                if (this.reloadPending) {
+                    this.reloadPending = false;
+                    void this.load();
+                }
+            }
+        }
+    }
+    handleInput(data) {
+        const page = Math.max(1, this.scrollRows - 1);
+        if (matchesKey(data, 'tab') || matchesKey(data, 'shift+tab')) {
+            const tabs = ['analysis', 'limits', 'accounts'];
+            const direction = matchesKey(data, 'shift+tab') ? -1 : 1;
+            this.selectTab(tabs[(tabs.indexOf(this.tab) + direction + tabs.length) % tabs.length]);
+            return true;
+        }
+        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') {
+            if (this.tab === 'limits')
+                this.refreshLimits = true;
+            void this.load();
+        }
+        else if (this.tab === 'analysis' && PERIODS.some((entry) => entry.key === data)) {
+            this.period = PERIODS.find((entry) => entry.key === data).period;
+            void this.load();
+        }
+        else if (this.tab === 'analysis' && SCOPES.some((entry) => entry.key === data)) {
+            this.scope = SCOPES.find((entry) => entry.key === data).scope;
+            void this.load();
+        }
+        else
+            return false;
+        this.options.changed();
+        return true;
+    }
+    analysisContent(width, theme) {
+        const summary = this.summary;
+        const header = [];
+        if (!summary) {
+            header.push(theme.fg(this.error ? 'error' : 'dim', this.error ?? (this.busy ? 'Reading usage…' : 'No usage to show.')));
+            return { header, body: [] };
+        }
+        const scope = SCOPES.find((entry) => entry.scope === summary.scope)?.label ?? summary.scope;
+        const period = PERIODS.find((entry) => entry.period === summary.period)?.label ?? summary.period;
+        header.push(theme.bold(theme.fg('accent', `${scope} · ${period}`)));
+        header.push(...wrapTextWithAnsi(theme.fg('muted', usageLine(summary.totals)), width));
+        const details = [
+            summary.totals.cacheHitPercent === null ? null : `${summary.totals.cacheHitPercent}% cache hits`,
+            `TTFT ${duration(summary.totals.avgTtftMs)}`,
+            `request ${duration(summary.totals.avgDurationMs)}`,
+            summary.totals.estimatedCostUsd ? `${money(summary.totals.estimatedCostUsd)} estimated` : null
+        ].filter((entry) => Boolean(entry));
+        if (details.length)
+            header.push(...wrapTextWithAnsi(theme.fg('dim', details.join(' · ')), width));
+        if (this.error)
+            header.push(...wrapTextWithAnsi(theme.fg('error', this.error), width));
+        const body = [''];
+        const total = tokensOf(summary.totals);
+        const gap = () => {
+            if (body.length && body[body.length - 1] !== '')
+                body.push('');
+        };
+        if (summary.byDay.length) {
+            const max = Math.max(...summary.byDay.map((day) => day.inputTokens + day.cacheReadTokens + day.outputTokens), 1);
+            const spark = summary.byDay.slice(-14).map((day) => BARS[Math.min(BARS.length - 1, Math.round(((day.inputTokens + day.cacheReadTokens + day.outputTokens) / max) * (BARS.length - 1)))]).join('');
+            body.push(theme.fg('accent', spark));
+            for (const day of summary.byDay.slice(-3).reverse()) {
+                body.push(...wrapTextWithAnsi(theme.fg('muted', `  ${day.day}  ${count(day.inputTokens + day.cacheReadTokens + day.outputTokens)} tokens · ${count(day.requests)} requests · ${money(day.costUsd)}`), width));
+            }
+        }
+        const section = (rows) => {
+            if (!rows.length)
+                return;
+            gap();
+            for (const row of rows) {
+                const line = `  ${oneLine(row.label)}  ${share(tokensOf(row), total)}  ${count(tokensOf(row))} tokens · ${count(row.requests)} requests · ${money(row.costUsd)}`;
+                body.push(...wrapTextWithAnsi(theme.fg('muted', line), width));
+            }
+        };
+        section(summary.byModel);
+        section(summary.byProvider);
+        section(summary.byAccount);
+        section(summary.bySession);
+        if (body.length === 1)
+            body.push(theme.fg('dim', 'No requests were recorded in this period.'));
+        while (body.length > 1 && body[body.length - 1] === '')
+            body.pop();
+        return { header, body };
+    }
+    limitsContent(width, theme) {
+        const report = this.tab === 'accounts' ? this.allLimits : this.limits;
+        const header = [];
+        if (!report) {
+            header.push(theme.fg(this.error ? 'error' : 'dim', this.error ?? (this.busy ? 'Reading provider limits…' : 'No limit readings yet.')));
+            return { header, body: [] };
+        }
+        if (this.error)
+            header.push(...wrapTextWithAnsi(theme.fg('error', this.error), width));
+        const body = [];
+        const barWidth = Math.max(8, Math.min(16, Math.floor(width / 6)));
+        for (const account of report.accounts) {
+            if (body.length)
+                body.push('');
+            body.push(theme.bold(oneLine(account.label)) + theme.fg('dim', `${account.plan ? ` · ${oneLine(account.plan)}` : ''} · ${account.health}`));
+            if (!account.providers.length) {
+                body.push(theme.fg('dim', '  No limit readings.'));
+                continue;
+            }
+            for (const provider of account.providers) {
+                body.push('');
+                const source = this.tab === 'accounts' ? `cached · ${provider.source}` : provider.source === 'provider' ? '' : provider.source;
+                const meta = [source, ago(provider.observedAt)].filter(Boolean).join(' · ');
+                const tone = provider.source === 'unavailable' ? 'warning' : 'muted';
+                body.push(...wrapTextWithAnsi(theme.fg(tone, `  ${provider.provider}${meta ? ` · ${meta}` : ''}${provider.reason ? ` · ${oneLine(provider.reason)}` : ''}`), width));
+                for (const limit of provider.limits) {
+                    body.push('');
+                    const reset = until(limit.resetsAt);
+                    body.push(...wrapTextWithAnsi(spread(theme.bold(`  ${oneLine(limit.label)}`), theme.fg('dim', reset), width), width));
+                    const used = limit.usedPercent ?? null;
+                    const remainingPercent = limit.remainingPercent
+                        ?? (used === null
+                            ? limit.remaining !== null && limit.remaining !== undefined && limit.limit !== null && limit.limit !== undefined && limit.limit > 0
+                                ? Math.max(0, Math.min(100, (limit.remaining / limit.limit) * 100))
+                                : null
+                            : Math.max(0, Math.min(100, 100 - used)));
+                    const rejected = limit.status === 'rejected';
+                    const tone = barTone(remainingPercent, rejected);
+                    const absolute = limit.remaining !== null && limit.remaining !== undefined
+                        ? `${limit.unit === 'usd' ? money(limit.remaining) : limit.unit === 'currency' ? `${limit.remaining.toFixed(2)} ${limit.detail ?? ''}`.trim() : count(limit.remaining)} left`
+                        : limit.limit !== null && limit.limit !== undefined
+                            ? `limit ${count(limit.limit)}${limit.unit && limit.unit !== 'percent' ? ` ${limit.unit}` : ''}`
+                            : '';
+                    const value = remainingPercent === null ? absolute || '—' : `${Math.round(remainingPercent)}% left`;
+                    const suffix = remainingPercent !== null && absolute ? `  ${theme.fg('dim', absolute)}` : '';
+                    body.push(...wrapTextWithAnsi(`  ${bar(remainingPercent, barWidth, theme, rejected)}  ${theme.fg(tone, value)}${suffix}`, width));
+                }
+            }
+        }
+        if (!report.accounts.length)
+            body.push(theme.fg('dim', 'No accounts.'));
+        const local = this.tab === 'limits' ? this.limitsSummary?.totals : undefined;
+        if (local) {
+            if (body.length)
+                body.push('');
+            body.push(...wrapTextWithAnsi(theme.fg('dim', `7d · ${count(local.inputTokens + local.cacheReadTokens + local.outputTokens)} tokens · ${count(local.requests)} requests · ${money(local.costUsd)}`), width));
+        }
+        return { header, body };
+    }
+    render(width, rows) {
+        if (width < 1 || rows < 1)
+            return [];
+        const theme = this.options.theme();
+        const { header, body } = this.tab === 'analysis' ? this.analysisContent(width, theme) : this.limitsContent(width, theme);
+        const bodyRows = Math.max(0, rows - header.length);
+        this.scrollRows = Math.max(1, bodyRows);
+        this.maxOffset = Math.max(0, body.length - bodyRows);
+        this.offset = Math.max(0, Math.min(this.offset, this.maxOffset));
+        return [...header, ...body.slice(this.offset, this.offset + bodyRows)].slice(0, rows).map((line) => truncateToWidth(line, width, ''));
+    }
+}

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

@@ -0,0 +1,72 @@
+/**
+ * The Worktrees page (`/worktree`): the managed worktrees of the repository this session works in.
+ * A person makes, switches to, branches, hands off, removes, restores and prunes them; switching
+ * restarts the terminal in the chosen folder as a new conversation (PROP-0016).
+ */
+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 { WorktreeRecord, WorktreeStatus } from "../../../worktrees/types.js";
+export interface WorktreeOverview {
+    repo: string | null;
+    current: string | null;
+    worktrees: WorktreeStatus[];
+    removed: WorktreeRecord[];
+    reason: string | null;
+}
+export interface WorktreesPageOptions {
+    theme(): Theme;
+    call: MenuCall;
+    ui: MenuUi & {
+        input(title: string, placeholder?: string): Promise<string | undefined>;
+    };
+    /** Ends the frontend so the host restarts it in the chosen folder. */
+    relaunch(): void;
+    changed(): void;
+}
+type Row = {
+    kind: 'new' | 'permanent' | 'prune' | 'trust' | 'main';
+} | {
+    kind: 'worktree';
+    status: WorktreeStatus;
+} | {
+    kind: 'removed';
+    record: WorktreeRecord;
+};
+export declare const WORKTREE_ACTIONS: {
+    readonly switch: "Switch this terminal here (new conversation)";
+    readonly branch: "Create branch here";
+    readonly toSource: "Hand off its changes to the main checkout";
+    readonly toWorktree: "Bring the main checkout's changes here";
+    readonly remove: "Remove";
+    readonly removeForce: "Remove, keeping a snapshot of unsaved work";
+};
+export declare class WorktreesPage implements TerminalPage {
+    private readonly options;
+    presentation: "centered";
+    private overview;
+    private error;
+    private busy;
+    private disposed;
+    private readonly list;
+    constructor(options: WorktreesPageOptions);
+    get focused(): boolean;
+    set focused(value: boolean);
+    activate(): void;
+    dispose(): void;
+    tabs(): readonly TabInfo[];
+    activeTab(): string;
+    hint(): string;
+    reload(): Promise<void>;
+    rows(): ListRow<Row>[];
+    private attempt;
+    activateRow(row: Row): Promise<void>;
+    private worktreeMenu;
+    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/worktreesPage.js

@@ -0,0 +1,203 @@
+import { truncateToWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { FilterList } from "../list.js";
+const TABS = [{ id: 'worktrees', title: 'Worktrees' }];
+export const WORKTREE_ACTIONS = {
+    switch: 'Switch this terminal here (new conversation)',
+    branch: 'Create branch here',
+    toSource: 'Hand off its changes to the main checkout',
+    toWorktree: "Bring the main checkout's changes here",
+    remove: 'Remove',
+    removeForce: 'Remove, keeping a snapshot of unsaved work'
+};
+export class WorktreesPage {
+    options;
+    presentation = 'centered';
+    overview;
+    error;
+    busy = false;
+    disposed = false;
+    list;
+    constructor(options) {
+        this.options = options;
+        this.list = new FilterList({
+            theme: options.theme, search: 'always', noun: ['worktree', 'worktrees'], empty: 'No worktrees 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(); }
+    dispose() { this.disposed = true; }
+    tabs() { return TABS; }
+    activeTab() { return 'worktrees'; }
+    hint() { return 'Enter choose · type to search · Esc close'; }
+    async reload() {
+        try {
+            this.overview = await this.options.call('terminal.worktrees.list');
+            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();
+    }
+    rows() {
+        const overview = this.overview;
+        if (!overview?.repo)
+            return [];
+        const rows = [
+            { id: 'new', label: 'New managed worktree', group: 'Actions', detail: 'detached, carries your changes', tone: 'accent', data: { kind: 'new' } },
+            { id: 'permanent', label: 'New permanent worktree', group: 'Actions', detail: 'named, never pruned', tone: 'muted', data: { kind: 'permanent' } }
+        ];
+        if (overview.current)
+            rows.push({ id: 'main', label: 'Switch back to the main checkout', group: 'Actions', tone: 'muted', data: { kind: 'main' } });
+        rows.push({ id: 'prune', label: 'Prune older managed worktrees', group: 'Actions', tone: 'muted', data: { kind: 'prune' } }, { id: 'trust', label: 'Trust the setup script as it is now', group: 'Actions', tone: 'muted', data: { kind: 'trust' } });
+        for (const status of overview.worktrees) {
+            const record = status.record;
+            const here = record.id === overview.current ? ' · this terminal' : record.lease ? ' · in use' : '';
+            const changes = status.changes ? `${status.changes} changed` : 'clean';
+            rows.push({
+                id: `worktree:${record.id}`, label: record.name, group: 'Worktrees',
+                detail: `${record.branch ?? 'detached'} · ${changes}${status.ahead ? ` · ${status.ahead} commit(s)` : ''} · ${record.kind}${here}`,
+                tone: record.id === overview.current ? 'success' : status.changes ? 'warning' : 'muted',
+                searchText: `${record.name} ${record.branch ?? ''} ${record.path}`,
+                data: { kind: 'worktree', status }
+            });
+        }
+        for (const record of overview.removed) {
+            rows.push({
+                id: `removed:${record.id}`, label: record.name, group: 'Removed (restorable)',
+                detail: record.removed?.snapshot ? 'snapshot kept' : 'clean when removed', tone: 'dim', data: { kind: 'removed', record }
+            });
+        }
+        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) {
+        const call = this.options.call;
+        const ui = this.options.ui;
+        switch (row.kind) {
+            case 'new':
+            case 'permanent':
+                return this.attempt(async () => {
+                    const name = row.kind === 'permanent' ? await ui.input('Worktree name', 'lowercase-with-dashes') : undefined;
+                    if (row.kind === 'permanent' && !name)
+                        return;
+                    const result = await call('terminal.worktrees.create', { kind: row.kind === 'permanent' ? 'permanent' : 'managed', ...(name ? { name } : {}) });
+                    if (result.setup.state === 'untrusted')
+                        ui.notify('The repository has a setup script you have not trusted; it did not run.', 'warning');
+                    if (await ui.confirm(`Worktree ${result.worktree.name} is ready`, 'Switch this terminal there now? It starts a new conversation in that folder.')) {
+                        await call('terminal.worktrees.switch', { id: result.worktree.id });
+                        this.options.relaunch();
+                    }
+                });
+            case 'main':
+                return this.attempt(async () => {
+                    await call('terminal.worktrees.switch', { main: true });
+                    this.options.relaunch();
+                });
+            case 'prune':
+                return this.attempt(async () => {
+                    const result = await call('terminal.worktrees.prune');
+                    return `Removed ${result.removed.length} older worktree(s); unsaved work was kept as snapshots.`;
+                });
+            case 'trust':
+                return this.attempt(async () => {
+                    if (!await ui.confirm('Trust the setup script?', 'Read .xharness/worktree-setup first. It will run in every new worktree of this repository until its text changes.'))
+                        return;
+                    await call('terminal.worktrees.trustSetup');
+                    return 'Setup script trusted.';
+                });
+            case 'removed':
+                return this.attempt(async () => {
+                    await call('terminal.worktrees.restore', { id: row.record.id });
+                    return `Restored ${row.record.name}.`;
+                });
+            case 'worktree':
+                return this.worktreeMenu(row.status);
+        }
+    }
+    async worktreeMenu(status) {
+        const record = status.record;
+        const current = this.overview?.current === record.id;
+        const choices = [
+            ...(current ? [] : [WORKTREE_ACTIONS.switch]),
+            ...(record.branch ? [] : [WORKTREE_ACTIONS.branch]),
+            WORKTREE_ACTIONS.toSource,
+            WORKTREE_ACTIONS.toWorktree,
+            ...(current ? [] : [status.changes || status.ahead ? WORKTREE_ACTIONS.removeForce : WORKTREE_ACTIONS.remove])
+        ];
+        const choice = await this.options.ui.select(`${record.name} · ${record.path}`, choices);
+        const call = this.options.call;
+        const id = record.id;
+        if (choice === WORKTREE_ACTIONS.switch)
+            return this.attempt(async () => {
+                await call('terminal.worktrees.switch', { id });
+                this.options.relaunch();
+            });
+        if (choice === WORKTREE_ACTIONS.branch)
+            return this.attempt(async () => {
+                const name = await this.options.ui.input('Branch name', 'my-change');
+                if (!name)
+                    return;
+                const updated = await call('terminal.worktrees.branch', { id, name });
+                return `${record.name} is on branch ${updated.branch}.`;
+            });
+        if (choice === WORKTREE_ACTIONS.toSource || choice === WORKTREE_ACTIONS.toWorktree)
+            return this.attempt(async () => {
+                const direction = choice === WORKTREE_ACTIONS.toSource ? 'toSource' : 'toWorktree';
+                const result = await call('terminal.worktrees.handoff', { id, direction });
+                if (!result.patched && !result.copied.length)
+                    return 'Nothing to hand off.';
+                return `Handed off.${result.stash ? ' The origin keeps a copy in git stash.' : ''}`;
+            });
+        if (choice === WORKTREE_ACTIONS.remove || choice === WORKTREE_ACTIONS.removeForce)
+            return this.attempt(async () => {
+                const force = choice === WORKTREE_ACTIONS.removeForce;
+                if (force && !await this.options.ui.confirm(`Remove ${record.name}?`, 'Its unsaved changes and commits are kept as a snapshot you can restore from this page.'))
+                    return;
+                await call('terminal.worktrees.remove', { id, force });
+                return `Removed ${record.name}.`;
+            });
+    }
+    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 worktrees: ${this.error}`)];
+        if (!this.overview)
+            return [theme.fg('dim', 'Reading worktrees…')];
+        if (!this.overview.repo) {
+            return wrapTextWithAnsi(`Worktrees need a git repository. ${this.overview.reason ?? ''}`.trim(), width).slice(0, rows).map(line => theme.fg('dim', line));
+        }
+        const header = truncateToWidth(theme.fg('dim', `Repository ${this.overview.repo}`), width, '');
+        return [header, '', ...this.list.render(width, Math.max(1, rows - 2))].slice(0, rows).map(line => truncateToWidth(line, width, ''));
+    }
+}