@xingular/harness 0.1.7 → 1.1.1

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/piAdapter.d.ts

@@ -0,0 +1,18 @@
+import type { InlineExtension, Theme, ToolRenderers } from '@earendil-works/pi-coding-agent';
+export interface PiAdapter {
+    builtins: InlineExtension[];
+    setTheme(theme: Theme): void;
+    withBuiltInRenderers(toolName: string, definition: ToolRenderers | undefined): ToolRenderers | undefined;
+    readClipboardText(): Promise<string | null>;
+    readClipboardFilePaths(): Promise<string[] | null>;
+    readClipboardImage(): Promise<{
+        bytes: Uint8Array;
+        mimeType: string;
+    } | null>;
+    extensionForImageMimeType(mimeType: string): string | null;
+}
+export declare function assertPiAdapterVersion(version: string): void;
+export declare function loadPiAdapter(): Promise<PiAdapter>;
+/** Initialize once with loadPiAdapter() before rendering native rich tool components. */
+export declare function setPiTheme(theme: Theme): void;
+export declare function withBuiltInRenderers(toolName: string, definition: ToolRenderers | undefined): ToolRenderers | undefined;

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

@@ -0,0 +1,48 @@
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { loadPi, PINNED_PI_VERSION } from "../../pi/runtime.js";
+let adapter;
+let loading;
+export function assertPiAdapterVersion(version) {
+    if (version !== PINNED_PI_VERSION)
+        throw new Error(`The Harness terminal adapter requires Pi ${PINNED_PI_VERSION}; found ${version}. Install the Harness package's pinned dependencies.`);
+}
+export function loadPiAdapter() {
+    loading ??= (async () => {
+        const pi = await loadPi();
+        assertPiAdapterVersion(pi.VERSION);
+        const root = pi.getPackageDir();
+        const [extensions, theme, renderers, clipboard, images] = await Promise.all([
+            import(pathToFileURL(join(root, 'dist/extensions/index.js')).href),
+            import(pathToFileURL(join(root, 'dist/modes/interactive/theme/theme.js')).href),
+            import(pathToFileURL(join(root, 'dist/core/tools/renderers/index.js')).href),
+            import(pathToFileURL(join(root, 'dist/utils/clipboard.js')).href),
+            import(pathToFileURL(join(root, 'dist/utils/clipboard-image.js')).href)
+        ]);
+        if (!Array.isArray(extensions.builtInExtensions) || typeof theme.setThemeInstance !== 'function' || typeof renderers.withBuiltInRenderers !== 'function' || typeof clipboard.readClipboardText !== 'function' || typeof clipboard.readClipboardFilePaths !== 'function' || typeof images.readClipboardImage !== 'function' || typeof images.extensionForImageMimeType !== 'function') {
+            throw new Error('The pinned Pi terminal adapter no longer exposes its required builtin or theme hooks.');
+        }
+        adapter = {
+            builtins: extensions.builtInExtensions,
+            setTheme: theme.setThemeInstance,
+            withBuiltInRenderers: renderers.withBuiltInRenderers,
+            readClipboardText: clipboard.readClipboardText,
+            readClipboardFilePaths: clipboard.readClipboardFilePaths,
+            readClipboardImage: images.readClipboardImage,
+            extensionForImageMimeType: images.extensionForImageMimeType
+        };
+        return adapter;
+    })();
+    return loading;
+}
+/** Initialize once with loadPiAdapter() before rendering native rich tool components. */
+export function setPiTheme(theme) {
+    if (!adapter)
+        throw new Error('Initialize the Pi terminal adapter before setting its theme.');
+    adapter.setTheme(theme);
+}
+export function withBuiltInRenderers(toolName, definition) {
+    if (!adapter)
+        throw new Error('Initialize the Pi terminal adapter before resolving builtin renderers.');
+    return adapter.withBuiltInRenderers(toolName, definition);
+}

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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,2 @@
+// The terminal's plan mode uses the session's read-only tool set.
+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 };

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

@@ -0,0 +1,27 @@
+import { BUILTIN_PLUGIN_REGISTRY } from "../../plugins/builtin.js";
+import { parseAnnotate } from "./annotateCommand.js";
+/** Terminal adapters for commands declared by Harness-owned feature plugins. */
+export function createBuiltinPluginCommandHandlers(host, openPage) {
+    const handlers = new Map([
+        ['doctor', async () => openPage('doctor')],
+        ['worktree', async () => openPage('worktree')],
+        ['trajectory', async (argument) => openPage('trajectory', { runId: argument })],
+        ['subagents', async () => openPage('subagents')],
+        ['agents', async () => openPage('agents')],
+        ['notes', async () => openPage('notes')],
+        ['annotate', async (argument) => {
+                const start = parseAnnotate(argument);
+                if (typeof start === 'string')
+                    host.ui.notify(start, 'error');
+                else
+                    await openPage('annotate', { annotate: start });
+            }]
+    ]);
+    const commands = BUILTIN_PLUGIN_REGISTRY.commands();
+    for (const command of commands) {
+        if (!handlers.has(command.name))
+            throw new Error(`No terminal handler for built-in plugin command ${command.pluginId}:${command.name}.`);
+    }
+    return handlers;
+}
+export { parseAnnotate };

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

@@ -0,0 +1,20 @@
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import { type TUI } from '@earendil-works/pi-tui';
+import type { QuestionOption } from "../../sessions/contracts.js";
+import { DialogPanel } from "./dialogs.js";
+type DisplayOption = {
+    option: QuestionOption;
+    index: number;
+};
+export type QuestionPickerResult = {
+    type: 'answer';
+    selected: string[];
+} | {
+    type: 'text';
+    selected: string[];
+} | {
+    type: 'cancel';
+};
+export declare function questionOptionsInDisplayOrder(options: readonly QuestionOption[]): DisplayOption[];
+export declare function createQuestionPicker(tui: TUI, theme: Theme, title: string, question: string | undefined, options: readonly QuestionOption[], multiSelect: boolean, allowText: boolean, selected: readonly string[], done: (result: QuestionPickerResult) => void): DialogPanel;
+export {};

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

@@ -0,0 +1,150 @@
+import { SelectList, stripTerminalSequences, truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
+import { selectedRow, selectionText } from "./chrome.js";
+import { centeredDialogHost, dialogFits } from "./dialogGeometry.js";
+import { DialogPanel } from "./dialogs.js";
+const RECOMMENDED = '(Recommended)';
+export function questionOptionsInDisplayOrder(options) {
+    const indexed = options.map((option, index) => ({ option, index }));
+    return [...indexed.filter(({ option }) => option.recommended), ...indexed.filter(({ option }) => !option.recommended)];
+}
+function recommendedSelectTheme(theme) {
+    return {
+        selectedPrefix: text => selectionText(theme, text),
+        selectedText: text => {
+            const marker = text.lastIndexOf(RECOMMENDED);
+            if (marker < 0)
+                return selectionText(theme, text.replace(/^→/, '❯'));
+            const afterMarker = marker + RECOMMENDED.length;
+            return selectionText(theme, text.slice(0, marker).replace(/^→/, '❯')) + theme.fg('warning', RECOMMENDED) + selectionText(theme, text.slice(afterMarker));
+        },
+        description: text => theme.fg('muted', text),
+        scrollInfo: text => theme.fg('dim', text),
+        noMatch: text => theme.fg('warning', text.replace('commands', 'options'))
+    };
+}
+class QuestionPickerContent {
+    tui;
+    theme;
+    options;
+    multiSelect;
+    allowText;
+    done;
+    list;
+    selectedIndexes;
+    focusedValue = false;
+    displayOptions;
+    constructor(tui, theme, options, multiSelect, allowText, selected, done) {
+        this.tui = tui;
+        this.theme = theme;
+        this.options = options;
+        this.multiSelect = multiSelect;
+        this.allowText = allowText;
+        this.done = done;
+        this.displayOptions = questionOptionsInDisplayOrder(options);
+        this.selectedIndexes = [];
+        const remaining = [...selected];
+        options.forEach((option, index) => {
+            const selectedIndex = remaining.indexOf(option.label);
+            if (selectedIndex >= 0) {
+                this.selectedIndexes.push(index);
+                remaining.splice(selectedIndex, 1);
+            }
+        });
+        this.rebuild();
+    }
+    get focused() { return this.focusedValue; }
+    set focused(value) { this.focusedValue = value; }
+    labels() {
+        return this.selectedIndexes.map(index => this.options[index].label);
+    }
+    rebuild() {
+        const selectedValue = this.list?.getSelectedItem()?.value;
+        const items = this.displayOptions.map(({ option }, displayIndex) => ({
+            value: `option:${displayIndex}`,
+            label: `${displayIndex + 1}. ${this.selectedIndexes.includes(this.displayOptions[displayIndex].index) ? '✓ ' : ''}${option.label}${option.recommended ? ` ${RECOMMENDED}` : ''}`,
+            description: option.description
+        }));
+        if (this.allowText)
+            items.push({ value: 'write', label: 'Write an answer', description: undefined });
+        if (this.multiSelect)
+            items.push({ value: 'submit', label: 'Submit choices', description: undefined });
+        const maxVisible = Math.min(12, Math.max(1, Math.floor(this.tui.terminal.rows * 0.6) - 5));
+        const theme = recommendedSelectTheme(this.theme);
+        this.list = new SelectList(items, maxVisible, theme, {
+            minPrimaryColumnWidth: 1,
+            maxPrimaryColumnWidth: 60,
+            truncatePrimary: ({ text, maxWidth, isSelected }) => {
+                const marker = text.lastIndexOf(RECOMMENDED);
+                if (marker < 0)
+                    return truncateToWidth(text, maxWidth, '');
+                const label = text.slice(0, marker).trimEnd();
+                const suffix = text.slice(marker);
+                const suffixWidth = visibleWidth(suffix);
+                const shortened = suffixWidth >= maxWidth ? truncateToWidth(suffix, maxWidth, '') : `${truncateToWidth(label, Math.max(1, maxWidth - suffixWidth), '…')} ${suffix}`;
+                if (isSelected)
+                    return shortened;
+                const shortenedMarker = shortened.lastIndexOf(RECOMMENDED);
+                return shortenedMarker < 0
+                    ? shortened
+                    : shortened.slice(0, shortenedMarker) + this.theme.fg('warning', shortened.slice(shortenedMarker));
+            }
+        });
+        if (selectedValue) {
+            const index = items.findIndex(item => item.value === selectedValue);
+            if (index >= 0)
+                this.list.setSelectedIndex(index);
+        }
+        this.list.onSelect = item => {
+            if (item.value === 'write') {
+                this.done({ type: 'text', selected: this.labels() });
+                return;
+            }
+            if (item.value === 'submit') {
+                this.done({ type: 'answer', selected: this.labels() });
+                return;
+            }
+            const displayIndex = Number(item.value.slice('option:'.length));
+            const originalIndex = this.displayOptions[displayIndex]?.index;
+            if (originalIndex === undefined)
+                return;
+            if (!this.multiSelect) {
+                this.done({ type: 'answer', selected: [this.options[originalIndex].label] });
+                return;
+            }
+            const selectedIndex = this.selectedIndexes.indexOf(originalIndex);
+            if (selectedIndex >= 0)
+                this.selectedIndexes.splice(selectedIndex, 1);
+            else
+                this.selectedIndexes.push(originalIndex);
+            this.rebuild();
+            this.tui.requestRender();
+        };
+        this.list.onCancel = () => this.done({ type: 'cancel' });
+    }
+    invalidate() { this.list.invalidate(); }
+    handleInput(data) {
+        if (/^[1-9]$/.test(data)) {
+            const index = Number(data) - 1;
+            if (index >= 0 && index < this.displayOptions.length) {
+                this.list.setSelectedIndex(index);
+                this.list.handleInput('\r');
+                return;
+            }
+        }
+        this.list.handleInput(data === 'j' ? '\x1b[B' : data === 'k' ? '\x1b[A' : data);
+    }
+    render(width) {
+        return this.list.render(width).map(line => {
+            const bounded = truncateToWidth(line, width, '');
+            return stripTerminalSequences(line).startsWith('❯') ? selectedRow(bounded, width, this.theme) : bounded;
+        });
+    }
+}
+export function createQuestionPicker(tui, theme, title, question, options, multiSelect, allowText, selected, done) {
+    const content = new QuestionPickerContent(tui, theme, options, multiSelect, allowText, selected, done);
+    const hint = multiSelect ? '↑/↓ select · Enter toggle · Submit choices · Esc cancel' : '↑/↓ select · Enter choose · Esc cancel';
+    const panel = new DialogPanel(title, content, () => theme, hint, question);
+    panel.centered = centeredDialogHost(tui) && dialogFits(tui.terminal.columns, tui.terminal.rows);
+    panel.maxRows = () => Math.max(3, Math.floor(tui.terminal.rows * 0.8));
+    return panel;
+}

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

@@ -0,0 +1,21 @@
+import type { ExtensionUIContext } from '@earendil-works/pi-coding-agent';
+import type { QuestionAnswer } from "../../sessions/registry.js";
+export interface TerminalQuestion {
+    requestId: string;
+    question?: string;
+    summary?: string;
+    uiSketch?: true;
+    options: {
+        label: string;
+        description?: string;
+        recommended?: boolean;
+        sketch?: string;
+    }[];
+    multiSelect?: boolean;
+    allowText?: boolean;
+    batchId?: string;
+    batchIndex?: number;
+    batchCount?: number;
+}
+/** Answers stay local until the complete group can be submitted to the registry. */
+export declare function answerTerminalQuestion(ui: ExtensionUIContext, request: TerminalQuestion, signal: AbortSignal): Promise<QuestionAnswer | undefined>;

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

@@ -0,0 +1,42 @@
+import { createQuestionPicker } from "./questionPicker.js";
+/** Answers stay local until the complete group can be submitted to the registry. */
+export async function answerTerminalQuestion(ui, request, signal) {
+    const choices = request.options;
+    const progress = request.batchId ? `${request.batchIndex} of ${request.batchCount} · ` : '';
+    const title = `${progress}${request.summary ?? 'Question'}`;
+    const inputTitle = `${progress}${request.summary ? `${request.summary}: ` : ''}${request.question ?? 'Question'}`;
+    if (!Array.isArray(choices) || choices.length === 0)
+        throw new Error('Every question needs at least one choice.');
+    if (!choices.some(choice => choice.recommended))
+        throw new Error('Every question needs at least one recommended choice.');
+    let selected = [];
+    while (!signal.aborted) {
+        let cancelPicker = () => { };
+        const onAbort = () => cancelPicker();
+        signal.addEventListener('abort', onAbort, { once: true });
+        const picker = ui.custom((tui, theme, _keybindings, done) => {
+            cancelPicker = () => done({ type: 'cancel' });
+            if (signal.aborted)
+                cancelPicker();
+            return createQuestionPicker(tui, theme, title, request.question, choices, request.multiSelect === true, request.allowText !== false, selected, done);
+        });
+        let result;
+        try {
+            result = await picker;
+        }
+        finally {
+            signal.removeEventListener('abort', onAbort);
+        }
+        if (!result || result.type === 'cancel' || signal.aborted)
+            return undefined;
+        selected = result.selected;
+        if (result.type === 'answer')
+            return { selected };
+        const text = await ui.input(inputTitle, undefined, { signal });
+        if (signal.aborted)
+            return undefined;
+        if (text !== undefined)
+            return { selected, text };
+    }
+    return undefined;
+}