@xingular/harness 1.0.0 → 1.1.1

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

@@ -1,7 +1,5 @@
-import { matchesKey, stripTerminalSequences, truncateToWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
-import { selectedRow, selectionText } from "../chrome.js";
+import { matchesKey, stripTerminalSequences, truncateToWidth, visibleWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
 import { FilterList } from "../list.js";
-import { isPrimaryClick } from "../mouse.js";
 const ACTIVE = new Set(['queued', 'running', 'waiting_for_approval', 'waiting_for_input']);
 const payloadOf = (event) => event.payload && typeof event.payload === 'object' ? event.payload : {};
 const stringOf = (value) => typeof value === 'string' ? value : undefined;
@@ -68,17 +66,20 @@ const SECTIONS = [
 ];
 export class TrajectoryPage {
     options;
+    presentation = 'fullscreen';
     runs = [];
     section = 'runs';
     runList;
+    eventList;
     runIndex = 0;
     run;
     events = [];
-    selected = 0;
     detailOffset = 0;
-    eventRowsStart = -1;
-    eventRowsFirst = 0;
-    eventRowsCount = 0;
+    listStart = 0;
+    listEnd = 0;
+    listWidth = 0;
+    detailsStart = -1;
+    wideLayout = false;
     loading = false;
     loaded = false;
     disposed = false;
@@ -87,15 +88,19 @@ export class TrajectoryPage {
     constructor(options) {
         this.options = options;
         this.runList = new FilterList({
-            theme: options.theme, search: 'never', noun: ['run', 'runs'], empty: 'No runs recorded for this native session yet',
+            theme: options.theme, search: 'always', noun: ['run', 'runs'], empty: 'No runs recorded for this native session yet',
             onActivate: row => { if (row.data)
                 void this.selectRun(row.data); }
         });
+        this.eventList = new FilterList({
+            theme: options.theme, search: 'always', noun: ['event', 'events'], empty: 'No recorded events',
+            onActivate: () => { this.detailOffset = 0; this.options.changed(); }
+        });
     }
     get selectedRunId() { return this.run?.id; }
-    get selectedEvent() { return this.events[this.selected]; }
-    get focused() { return this.runList.focused; }
-    set focused(value) { this.runList.focused = value; }
+    get selectedEvent() { return this.eventList.selected?.data; }
+    get focused() { return this.section === 'runs' ? this.runList.focused : this.eventList.focused; }
+    set focused(value) { this.runList.focused = value; this.eventList.focused = value; }
     tabs() { return SECTIONS; }
     activeTab() { return this.section; }
     activate() {
@@ -153,8 +158,11 @@ export class TrajectoryPage {
             return;
         this.run = snapshot.run;
         this.events = snapshot.events.slice().sort(bySequence);
+        this.eventList.setRows(this.eventRows());
+        const latest = this.events.at(-1);
+        if (latest)
+            this.eventList.select(String(latest.sequence));
         this.runList.select(run.id);
-        this.selected = Math.max(0, this.events.length - 1);
         this.detailOffset = 0;
     }
     async refresh() {
@@ -162,7 +170,8 @@ export class TrajectoryPage {
             return;
         this.loading = true;
         const lastSequence = this.events.at(-1)?.sequence;
-        const followedLatest = this.selected === this.events.length - 1;
+        const selectedBefore = this.selectedEvent;
+        const followedLatest = !selectedBefore || selectedBefore.sequence === lastSequence;
         try {
             const snapshot = await this.options.read(this.run.id, lastSequence);
             if (this.disposed)
@@ -176,8 +185,14 @@ export class TrajectoryPage {
                 const existing = new Set(this.events.map(event => event.sequence));
                 this.events = [...this.events, ...snapshot.events.filter(event => !existing.has(event.sequence))].sort(bySequence);
             }
-            if (followedLatest && this.events.length)
-                this.selected = this.events.length - 1;
+            this.eventList.setRows(this.eventRows());
+            if (followedLatest) {
+                const latest = this.events.at(-1);
+                if (latest)
+                    this.eventList.select(String(latest.sequence));
+            }
+            else if (selectedBefore)
+                this.eventList.select(String(selectedBefore.sequence));
             this.error = undefined;
         }
         catch (error) {
@@ -201,6 +216,18 @@ export class TrajectoryPage {
             data: run
         }));
     }
+    eventRows() {
+        return this.events.map(event => ({
+            id: String(event.sequence),
+            label: `${timeOf(event.timestamp)}  ${event.type}`,
+            detail: eventDescription(event),
+            searchText: `${event.timestamp} ${event.type} ${eventDescription(event)} ${safe(JSON.stringify(payloadOf(event)))}`,
+            data: event
+        }));
+    }
+    eventJson(event) {
+        return JSON.stringify({ payload: event.payload, type: event.type, sequence: event.sequence, timestamp: event.timestamp }, null, 2);
+    }
     async selectRun(run) {
         const at = this.runs.findIndex(candidate => candidate.id === run.id);
         if (at < 0 || this.loading)
@@ -209,7 +236,7 @@ export class TrajectoryPage {
         this.runList.select(run.id);
         this.run = run;
         this.events = [];
-        this.selected = 0;
+        this.eventList.setRows([]);
         this.detailOffset = 0;
         this.error = undefined;
         this.loading = true;
@@ -236,7 +263,7 @@ export class TrajectoryPage {
         this.run = this.runs[next];
         this.runList.select(this.run.id);
         this.events = [];
-        this.selected = 0;
+        this.eventList.setRows([]);
         this.detailOffset = 0;
         this.error = undefined;
         this.loading = true;
@@ -255,21 +282,38 @@ export class TrajectoryPage {
         }
     }
     hint() {
-        return this.section === 'runs' ? '↑/↓ runs · Enter inspect' : '[ ] runs · ↑/↓ events · PgUp/PgDn details · c copy';
+        return this.section === 'runs'
+            ? '↑/↓ runs · type to search · Enter inspect'
+            : '[ ] runs · ↑/↓ events · type to search · PgUp/PgDn details · Shift+C copy';
     }
     handleMouse(event) {
+        if (event.type === 'wheel') {
+            const down = (event.wheelDelta ?? 1) >= 0;
+            if (this.section === 'events' && this.detailsStart >= 0 && (this.wideLayout ? event.x >= this.listWidth + 3 : event.y >= this.detailsStart)) {
+                this.detailOffset = Math.max(0, this.detailOffset + (down ? 4 : -4));
+                this.options.changed();
+                return { handled: true, render: true };
+            }
+            if (this.section === 'runs')
+                this.runList.handleInput(down ? '\x1b[B' : '\x1b[A');
+            else
+                this.eventList.handleInput(down ? '\x1b[B' : '\x1b[A');
+            this.detailOffset = 0;
+            this.options.changed();
+            return { handled: true, render: true };
+        }
         if (event.type === 'click' && event.button !== 'left')
             return undefined;
-        if (this.section === 'runs')
-            return this.runList.handleMouse({ ...event, y: event.y - 1 });
-        const offset = event.y - this.eventRowsStart;
-        if (this.eventRowsStart < 0 || offset < 0 || offset >= this.eventRowsCount)
+        if (event.type !== 'click' && event.type !== 'move')
             return undefined;
-        const next = this.eventRowsFirst + offset;
-        const changed = this.selected !== next;
-        this.selected = next;
-        this.detailOffset = 0;
-        return { handled: true, render: changed || isPrimaryClick(event) };
+        if (this.section === 'runs') {
+            if (event.y < this.listStart || event.y >= this.listEnd)
+                return undefined;
+            return this.runList.handleMouse({ ...event, y: event.y - this.listStart });
+        }
+        if (event.y < this.listStart || event.y >= this.listEnd || (this.wideLayout && event.x >= this.listWidth + 3))
+            return undefined;
+        return this.eventList.handleMouse({ ...event, y: event.y - this.listStart });
     }
     handleInput(data) {
         if (matchesKey(data, 'tab') || matchesKey(data, 'shift+tab')) {
@@ -288,16 +332,6 @@ export class TrajectoryPage {
             void this.changeRun(-1);
             return true;
         }
-        if (matchesKey(data, 'up')) {
-            this.selected = Math.max(0, this.selected - 1);
-            this.detailOffset = 0;
-            return true;
-        }
-        if (matchesKey(data, 'down')) {
-            this.selected = this.events.length ? Math.min(this.events.length - 1, this.selected + 1) : 0;
-            this.detailOffset = 0;
-            return true;
-        }
         if (matchesKey(data, 'pageUp')) {
             this.detailOffset = Math.max(0, this.detailOffset - 8);
             return true;
@@ -306,71 +340,110 @@ export class TrajectoryPage {
             this.detailOffset += 8;
             return true;
         }
-        if (data.toLowerCase() === 'c' && this.selectedEvent) {
-            const text = JSON.stringify(this.selectedEvent, null, 2);
+        if (data === 'C' && this.selectedEvent) {
+            const text = this.eventJson(this.selectedEvent);
             void this.options.copy(text).then(() => this.options.notify('Copied selected trajectory event')).catch(error => this.options.notify(String(error), 'error'));
             return true;
         }
-        return false;
+        const selected = this.selectedEvent?.sequence;
+        if (!this.eventList.handleInput(data))
+            return false;
+        if (this.selectedEvent?.sequence !== selected)
+            this.detailOffset = 0;
+        return true;
+    }
+    runSummary(width, rows) {
+        if (!this.run || rows < 1)
+            return [];
+        const runPosition = `${this.runIndex + 1}/${this.runs.length}`;
+        const modelEvent = [...this.events].reverse().find(event => event.type === 'usage.updated');
+        const usage = modelEvent ? payloadOf(modelEvent) : {};
+        const model = stringOf(usage.model) ?? 'model unavailable';
+        const theme = this.options.theme();
+        const lines = [theme.bold(theme.fg('accent', `Run ${runPosition} · ${this.run.id} · ${this.run.status}${this.loading ? ' · loading' : ''}`))];
+        if (rows >= 3)
+            lines.push(theme.fg('muted', `${model} · ${durationLine(this.run)} · ${this.run.mode}`));
+        if (rows >= 4)
+            lines.push(theme.fg('muted', usageLine(this.events)));
+        if (rows >= 6)
+            lines.push(theme.fg('dim', this.run.goal ? `Prompt: ${this.run.goal.replace(/\s+/g, ' ').slice(0, 140)}` : 'Prompt text unavailable'));
+        if (this.error)
+            lines.push(theme.fg('error', `Read error: ${this.error}`));
+        return lines.slice(0, Math.min(rows, 5)).map(line => truncateToWidth(line, width, ''));
+    }
+    detailLines(width, rows) {
+        if (rows < 1)
+            return [];
+        const event = this.selectedEvent;
+        const theme = this.options.theme();
+        const heading = theme.bold(theme.fg('accent', event ? `Event JSON · ${event.type} · #${event.sequence}` : 'Event JSON'));
+        const json = event
+            ? wrapTextWithAnsi(safe(this.eventJson(event)), Math.max(1, width))
+            : [this.events.length ? 'No event selected' : this.loading ? 'Loading recorded events…' : 'No recorded events'];
+        const visibleRows = Math.max(0, rows - 1);
+        this.detailOffset = Math.min(this.detailOffset, Math.max(0, json.length - visibleRows));
+        return [heading, ...json.slice(this.detailOffset, this.detailOffset + visibleRows)
+                .map(line => this.options.theme().fg('dim', line))].slice(0, rows).map(line => truncateToWidth(line, width, ''));
     }
     render(width, rows) {
         const theme = this.options.theme();
         if (width < 1 || rows < 1)
             return [];
         if (this.section === 'runs') {
-            this.eventRowsStart = -1;
-            this.eventRowsCount = 0;
+            this.wideLayout = false;
+            this.detailsStart = -1;
             if (this.error && !this.runs.length)
                 return [theme.fg('error', 'Read error: ' + this.error)];
-            const lines = [theme.fg('dim', !this.loaded ? 'Loading recorded runs…' : this.runs.length + ' recorded runs')];
-            lines.push(...this.runList.render(width, Math.max(0, rows - lines.length)));
+            const lines = [theme.fg('dim', !this.loaded ? 'Loading recorded runs…' : `${this.runs.length} recorded runs`)];
+            this.listStart = lines.length;
+            const list = this.runList.render(width, Math.max(0, rows - lines.length));
+            this.listEnd = this.listStart + list.length;
+            lines.push(...list);
             return lines.slice(0, rows).map(line => truncateToWidth(line, width, ''));
         }
         if (!this.run) {
-            this.eventRowsStart = -1;
-            this.eventRowsCount = 0;
+            this.listStart = this.listEnd = 0;
+            this.detailsStart = -1;
             if (this.error)
                 return [theme.fg('error', 'Read error: ' + this.error)];
             return [theme.fg('dim', this.loading || !this.loaded ? 'Loading recorded runs…' : 'No run selected. Choose a run in the Runs tab.')];
         }
-        const runPosition = (this.runIndex + 1) + '/' + this.runs.length;
-        const modelEvent = [...this.events].reverse().find(event => event.type === 'usage.updated');
-        const usage = modelEvent ? payloadOf(modelEvent) : {};
-        const model = stringOf(usage.model) ?? 'model unavailable';
-        const lines = [theme.bold(theme.fg('accent', 'Run ' + runPosition + ' · ' + this.run.id + ' · ' + this.run.status + (this.loading ? ' · loading' : '')))];
-        if (rows >= 9) {
-            lines.push(theme.fg('muted', model + ' · ' + durationLine(this.run) + ' · ' + this.run.mode));
-            lines.push(theme.fg('muted', usageLine(this.events)));
-            lines.push(this.run.goal ? theme.fg('dim', 'Prompt: ' + this.run.goal.replace(/\s+/g, ' ').slice(0, 140)) : theme.fg('dim', 'Prompt text unavailable'));
-        }
-        else if (rows >= 6) {
-            lines.push(theme.fg('muted', model + ' · ' + durationLine(this.run)));
-        }
-        lines.push(theme.bold('Events'));
-        if (this.error)
-            lines.push(theme.fg('error', 'Read error: ' + this.error));
-        if (!this.events.length)
-            lines.push(theme.fg('dim', this.loading ? 'Loading recorded events…' : 'No recorded events'));
-        const available = Math.max(0, rows - lines.length - 1);
-        const ledgerBudget = this.events.length ? Math.min(this.events.length, Math.max(1, Math.floor(available * 0.4))) : 0;
-        const detailBudget = Math.max(0, available - ledgerBudget);
-        const firstEvent = Math.max(0, Math.min(this.events.length - ledgerBudget, this.selected - Math.floor(ledgerBudget / 2)));
-        this.eventRowsStart = lines.length;
-        this.eventRowsFirst = firstEvent;
-        this.eventRowsCount = ledgerBudget;
-        for (let offset = 0; offset < ledgerBudget; offset++) {
-            const index = firstEvent + offset;
-            const event = this.events[index];
-            const prefix = index === this.selected ? '❯' : ' ';
-            const label = truncateToWidth(prefix + ' ' + timeOf(event.timestamp) + '  ' + event.type + '  ' + eventDescription(event), width, '');
-            lines.push(index === this.selected ? selectedRow(selectionText(theme, label), width, theme) : theme.fg('muted', label));
+        const lines = this.runSummary(width, rows);
+        const bodyRows = Math.max(0, rows - lines.length);
+        const wide = width >= 72;
+        this.wideLayout = wide;
+        if (wide) {
+            const separatorWidth = 3;
+            const leftWidth = Math.max(24, Math.floor((width - separatorWidth) * 0.42));
+            const rightWidth = Math.max(1, width - leftWidth - separatorWidth);
+            const paneStart = lines.length;
+            this.listWidth = leftWidth;
+            const events = [theme.bold(theme.fg('accent', 'Events')), ...this.eventList.render(leftWidth, Math.max(0, bodyRows - 1))];
+            const details = this.detailLines(rightWidth, bodyRows);
+            this.listStart = paneStart + 1;
+            this.listEnd = this.listStart + events.length - 1;
+            this.detailsStart = paneStart;
+            const pane = Array.from({ length: Math.max(events.length, details.length) }, (_, index) => {
+                const left = truncateToWidth(events[index] ?? '', leftWidth, '');
+                const gap = ' '.repeat(Math.max(0, leftWidth - visibleWidth(left)));
+                return left + gap + theme.fg('dim', ' │ ') + (details[index] ?? '');
+            });
+            lines.push(...pane);
         }
-        const selected = this.selectedEvent;
-        lines.push(theme.bold(selected ? 'Selected event · ' + selected.type + ' · #' + selected.sequence : 'Selected event'));
-        if (selected) {
-            const details = wrapTextWithAnsi(safe(JSON.stringify({ payload: selected.payload, type: selected.type, sequence: selected.sequence, timestamp: selected.timestamp }, null, 2)), width);
-            this.detailOffset = Math.min(this.detailOffset, Math.max(0, details.length - detailBudget));
-            lines.push(...details.slice(this.detailOffset, this.detailOffset + detailBudget).map(line => theme.fg('dim', line)));
+        else {
+            lines.push(theme.bold(theme.fg('accent', 'Events')));
+            this.listStart = lines.length;
+            this.listWidth = width;
+            const listRows = Math.min(Math.max(0, bodyRows - 1), Math.max(1, Math.floor(bodyRows * 0.58)));
+            const events = this.eventList.render(width, listRows);
+            this.listEnd = this.listStart + events.length;
+            lines.push(...events);
+            const hasRoomForDetails = lines.length < rows;
+            if (hasRoomForDetails)
+                lines.push('');
+            this.detailsStart = lines.length;
+            const detailRows = Math.max(0, rows - lines.length);
+            lines.push(...this.detailLines(width, detailRows));
         }
         return lines.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, ''));
+    }
+}

package/dist/sdk/terminal/tui/planMode.d.ts

@@ -1,2 +1,2 @@
-export { parseProposedPlan, planModeTools } from "../../sessions/planMode.js";
+export { normalModeTools, parseProposedPlan, planModeTools, QUESTION_TOOL_NAMES } from "../../sessions/planMode.js";
 export type { ProposedPlan } from "../../sessions/planMode.js";

package/dist/sdk/terminal/tui/planMode.js

@@ -1,2 +1,2 @@
 // The terminal's plan mode uses the session's read-only tool set.
-export { parseProposedPlan, planModeTools } from "../../sessions/planMode.js";
+export { normalModeTools, parseProposedPlan, planModeTools, QUESTION_TOOL_NAMES } from "../../sessions/planMode.js";

package/dist/sdk/terminal/tui/pluginCommands.d.ts

@@ -0,0 +1,14 @@
+import type { AnnotateStart } from "./pages/annotatePage.js";
+import type { CommandPageId } from "./commandPages.js";
+import type { TerminalCommandHost } from "./commands.js";
+import { parseAnnotate } from "./annotateCommand.js";
+type PageOptions = {
+    runId?: string;
+    url?: string;
+    annotate?: AnnotateStart;
+};
+type OpenPage = (id: CommandPageId, options?: PageOptions) => Promise<void>;
+type Handler = (argument: string) => Promise<void>;
+/** Terminal adapters for commands declared by Harness-owned feature plugins. */
+export declare function createBuiltinPluginCommandHandlers(host: TerminalCommandHost, openPage: OpenPage): Map<string, Handler>;
+export { parseAnnotate };