@xingular/harness 0.1.7 → 1.0.0

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

@@ -0,0 +1,251 @@
+import { matchesKey, sliceByColumn, truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
+import { centerDialogChromeRows, centerDialogContentWidth, centerDialogFrame, contentWidth, pageFrame, safeText, selectedRow, selectionText, tabStrip } from "./chrome.js";
+import { centeredDialogHost, dialogFits, pageRows } from "./dialogGeometry.js";
+import { SearchField, searchFieldRowsFor } from "./search.js";
+import { TREE_FILTER_MODES, TreeModel } from "./treeModel.js";
+const GUTTER = 2;
+const MIN_ANCHOR_CONTENT = 4;
+const MAX_ANCHOR_CONTENT = 20;
+const MIN_ANCHOR_CONTEXT = 2;
+const MAX_ANCHOR_CONTEXT = 12;
+const FILTER_TITLES = {
+    default: 'Default', 'no-tools': 'No tools', 'user-only': 'User only', 'labeled-only': 'Labeled', all: 'All'
+};
+const FILTERS = TREE_FILTER_MODES.map(id => ({ id, title: FILTER_TITLES[id] }));
+/** Keeps the gutter in view and pans the bodies only as far as needed to show the selected row's text. */
+function viewport(rows, width, theme) {
+    const room = Math.max(0, width - GUTTER);
+    const widest = rows.reduce((most, row) => Math.max(most, row.width), 0);
+    const maxScroll = Math.max(0, widest - room);
+    const selected = rows.find(row => row.selected);
+    let scroll = 0;
+    if (selected && maxScroll > 0) {
+        const needed = Math.min(MAX_ANCHOR_CONTENT, Math.max(MIN_ANCHOR_CONTENT, Math.floor(room / 3)));
+        if (selected.anchor > room - needed) {
+            const context = Math.min(MAX_ANCHOR_CONTEXT, Math.max(MIN_ANCHOR_CONTEXT, Math.floor(room / 4)));
+            scroll = Math.min(maxScroll, selected.anchor - context);
+        }
+    }
+    return rows.map(row => {
+        const line = scroll > 0 ? `${row.gutter}${sliceByColumn(row.body, scroll, room, true)}\x1b[0m` : row.gutter + row.body;
+        return row.selected ? selectedRow(line, width, theme) : truncateToWidth(line, width, '');
+    });
+}
+function formatTime(iso) {
+    const date = new Date(iso);
+    const now = new Date();
+    const time = `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`;
+    if (date.getFullYear() === now.getFullYear() && date.getMonth() === now.getMonth() && date.getDate() === now.getDate())
+        return time;
+    if (date.getFullYear() === now.getFullYear())
+        return `${date.getMonth() + 1}/${date.getDate()} ${time}`;
+    return `${String(date.getFullYear()).slice(-2)}/${date.getMonth() + 1}/${date.getDate()} ${time}`;
+}
+export class TreePicker {
+    options;
+    model;
+    search;
+    focusedValue = false;
+    editing = false;
+    closed = false;
+    constructor(options) {
+        this.options = options;
+        this.model = new TreeModel(options.tree, options.currentLeafId, undefined, options.initialFilterMode);
+        this.search = new SearchField(options.theme);
+        // A conversation with nothing in it has nothing to navigate.
+        if (!options.tree.length)
+            setTimeout(() => this.cancel(), 100).unref?.();
+    }
+    get focused() { return this.focusedValue; }
+    set focused(value) { this.focusedValue = value; this.search.focused = value; }
+    get state() { return this.model; }
+    invalidate() { this.search.invalidate(); }
+    dispose() { this.closed = true; }
+    cancel() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.options.cancel();
+    }
+    async editLabel() {
+        const node = this.model.selectedNode;
+        if (!node || this.editing)
+            return;
+        this.editing = true;
+        try {
+            const value = await this.options.editLabel(node.entry.id, node.label);
+            if (value === undefined || this.closed)
+                return;
+            const label = value.trim() || undefined;
+            this.model.setLabel(node.entry.id, label);
+            this.options.labelChanged(node.entry.id, label);
+        }
+        finally {
+            this.editing = false;
+            this.options.changed();
+        }
+    }
+    handleInput(data) {
+        const { matches } = this.options;
+        const model = this.model;
+        const centered = centeredDialogHost(this.options.tui) && dialogFits(this.options.tui.terminal.columns, this.options.tui.terminal.rows);
+        if (this.editing)
+            return;
+        if (matchesKey(data, 'ctrl+c')) {
+            this.cancel();
+            return;
+        }
+        if (matchesKey(data, 'escape')) {
+            if (this.search.clear())
+                model.setSearch('');
+            else
+                this.cancel();
+        }
+        else if (matchesKey(data, 'up'))
+            model.move(-1);
+        else if (matchesKey(data, 'down'))
+            model.move(1);
+        else if (matches(data, 'app.tree.foldOrUp'))
+            model.foldOrUp();
+        else if (matches(data, 'app.tree.unfoldOrDown'))
+            model.unfoldOrDown();
+        else if (matchesKey(data, 'left') && centered)
+            model.cycleFilter(-1);
+        else if (matchesKey(data, 'right') && centered)
+            model.cycleFilter(1);
+        else if (matchesKey(data, 'pageUp'))
+            model.move(-this.listRows());
+        else if (matchesKey(data, 'pageDown'))
+            model.move(this.listRows());
+        else if (matchesKey(data, 'home'))
+            model.move(-model.rows.length);
+        else if (matchesKey(data, 'end'))
+            model.move(model.rows.length);
+        else if (matchesKey(data, 'enter')) {
+            const node = model.selectedNode;
+            if (node)
+                this.options.select(node.entry.id);
+            return;
+        }
+        else if (matches(data, 'app.message.copy')) {
+            const text = model.copyText();
+            if (text)
+                this.options.copy(text);
+        }
+        else if (matches(data, 'app.tree.filter.default'))
+            model.setFilter('default');
+        else if (matches(data, 'app.tree.filter.noTools'))
+            model.toggleFilter('no-tools');
+        else if (matches(data, 'app.tree.filter.userOnly'))
+            model.toggleFilter('user-only');
+        else if (matches(data, 'app.tree.filter.labeledOnly'))
+            model.toggleFilter('labeled-only');
+        else if (matches(data, 'app.tree.filter.all'))
+            model.toggleFilter('all');
+        else if (matches(data, 'app.tree.filter.cycleForward'))
+            model.cycleFilter(1);
+        else if (matches(data, 'app.tree.filter.cycleBackward'))
+            model.cycleFilter(-1);
+        else if (matches(data, 'app.tree.editLabel')) {
+            void this.editLabel();
+            return;
+        }
+        else if (matches(data, 'app.tree.toggleLabelTimestamp'))
+            model.showLabelTimestamps = !model.showLabelTimestamps;
+        else if (this.search.handleInput(data))
+            model.setSearch(this.search.value);
+        else
+            return;
+        this.options.changed();
+    }
+    searchRows() {
+        const rows = pageRows(this.options.tui);
+        const centered = centeredDialogHost(this.options.tui) && dialogFits(this.options.tui.terminal.columns, this.options.tui.terminal.rows);
+        const chromeRows = centered ? centerDialogChromeRows(rows) : 4;
+        return searchFieldRowsFor(rows - chromeRows - 1);
+    }
+    /** Rows the list can show: the page (or dialog), less the frame, the search field and filter strip. */
+    listRows() {
+        const rows = pageRows(this.options.tui);
+        const centered = centeredDialogHost(this.options.tui) && dialogFits(this.options.tui.terminal.columns, this.options.tui.terminal.rows);
+        return Math.max(1, rows - (centered ? centerDialogChromeRows(rows) : 4) - this.searchRows() - 1);
+    }
+    prefix(flat, entryId) {
+        const model = this.model;
+        const indent = model.roots ? Math.max(0, flat.indent - 1) : flat.indent;
+        const connector = flat.showConnector && !flat.isVirtualRootChild;
+        const connectorLevel = connector ? indent - 1 : -1;
+        const chars = [];
+        for (let i = 0; i < indent * 3; i++) {
+            const level = Math.floor(i / 3);
+            const place = i % 3;
+            const gutter = flat.gutters.find(item => item.position === level);
+            if (gutter)
+                chars.push(place === 0 && gutter.show ? '│' : ' ');
+            else if (connector && level === connectorLevel) {
+                if (place === 0)
+                    chars.push(flat.isLast ? '└' : '├');
+                else if (place === 1)
+                    chars.push(model.isFolded(entryId) ? '⊞' : model.isFoldable(entryId) ? '⊟' : '─');
+                else
+                    chars.push(' ');
+            }
+            else
+                chars.push(' ');
+        }
+        return chars.join('');
+    }
+    row(flat, selected) {
+        const theme = this.options.theme();
+        const model = this.model;
+        const entry = flat.node.entry;
+        const connector = flat.showConnector && !flat.isVirtualRootChild;
+        const foldText = model.isFolded(entry.id) && !connector ? '⊞ ' : '';
+        const pathText = model.isOnActivePath(entry.id) ? '• ' : '';
+        const fold = foldText ? theme.fg('accent', foldText) : '';
+        const path = pathText ? theme.fg('accent', pathText) : '';
+        const labelText = flat.node.label ? `[${safeText(flat.node.label)}] ` : '';
+        const label = flat.node.label ? theme.fg('warning', `[${safeText(flat.node.label)}] `) : '';
+        const stampText = model.showLabelTimestamps && flat.node.label && flat.node.labelTimestamp ? `${formatTime(flat.node.labelTimestamp)} ` : '';
+        const stamp = model.showLabelTimestamps && flat.node.label && flat.node.labelTimestamp ? theme.fg('muted', `${formatTime(flat.node.labelTimestamp)} `) : '';
+        const text = model.describe(flat.node);
+        const content = theme.fg(text.leadTone, safeText(text.lead)) + (text.textTone ? theme.fg(text.textTone, safeText(text.text)) : safeText(text.text));
+        const contentText = safeText(text.lead) + safeText(text.text);
+        const leadText = this.prefix(flat, entry.id) + foldText + pathText;
+        const lead = theme.fg('dim', this.prefix(flat, entry.id)) + fold + path;
+        const marker = selected ? selectionText(theme, '❯ ') : '  ';
+        const body = selected
+            ? selectionText(theme, leadText + labelText + stampText + contentText)
+            : lead + label + stamp + content;
+        return { gutter: marker, body, anchor: visibleWidth(lead), width: visibleWidth(body), selected };
+    }
+    render(width) {
+        const rows = pageRows(this.options.tui);
+        const theme = this.options.theme();
+        if (width < 1 || rows < 1)
+            return [];
+        const centered = centeredDialogHost(this.options.tui) && dialogFits(this.options.tui.terminal.columns, this.options.tui.terminal.rows);
+        const inner = centered ? centerDialogContentWidth(width) : contentWidth(width);
+        const model = this.model;
+        const total = model.rows.length;
+        const count = this.listRows();
+        const start = Math.max(0, Math.min(Math.max(0, total - count), model.selectedIndex - Math.floor(count / 2)));
+        const shown = model.rows.slice(start, start + count).map((flat, offset) => this.row(flat, start + offset === model.selectedIndex));
+        const stamps = model.showLabelTimestamps ? theme.fg('dim', '  [label time]') : '';
+        const strip = tabStrip(FILTERS, model.filterMode, inner, theme, 'sub') + stamps;
+        const searchNote = model.searchQuery ? `${total} ${total === 1 ? 'entry' : 'entries'} · all entries` : `${total} ${total === 1 ? 'entry' : 'entries'}`;
+        const body = [
+            ...this.search.renderLines(inner, searchNote, this.searchRows()),
+            strip,
+            ...(total ? viewport(shown, inner, theme) : [theme.fg('dim', 'No entries found')])
+        ];
+        if (centered)
+            return centerDialogFrame({ title: 'Session tree', body: body.map(line => truncateToWidth(line, inner, '')), width, rows, theme });
+        return pageFrame({
+            title: 'Session tree', meta: total ? `(${model.selectedIndex + 1}/${total})` : '(0/0)', body,
+            footer: '↑/↓ move · ←/→ page · Alt+←/→ branch · Ctrl+E label · Ctrl+X copy · Ctrl+O filter · Enter go · Esc cancel',
+            width, rows, theme
+        });
+    }
+}
+export { TREE_FILTER_MODES };

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

@@ -0,0 +1,47 @@
+import { Theme, type AutocompleteProviderFactory, type ExtensionUIContext, type KeybindingsManager, type WorkingIndicatorOptions } from '@earendil-works/pi-coding-agent';
+import { type AutocompleteProvider, type EditorComponent, type TUI } from '@earendil-works/pi-tui';
+type EditorFactory = Parameters<ExtensionUIContext['setEditorComponent']>[0];
+type HeaderFactory = Parameters<ExtensionUIContext['setHeader']>[0];
+type FooterFactory = Parameters<ExtensionUIContext['setFooter']>[0];
+type WidgetContent = string[] | ((...args: Parameters<NonNullable<HeaderFactory>>) => ReturnType<NonNullable<HeaderFactory>>) | undefined;
+export interface TerminalUiState {
+    theme: Theme;
+    workingMessage?: string;
+    workingVisible: boolean;
+    workingIndicator?: WorkingIndicatorOptions;
+    hiddenThinkingLabel?: string;
+    toolsExpanded: boolean;
+    autocompleteFactories: AutocompleteProviderFactory[];
+}
+export interface TerminalUiOptions {
+    tui: TUI;
+    theme: Theme;
+    keybindings: KeybindingsManager;
+    changed(): void;
+    notify(message: string, type?: string): void;
+    setEditor(factory: EditorFactory): void;
+    getEditorText(): string;
+    setEditorText(value: string): void;
+    setStatus(key: string, value: string | undefined): void;
+    setWidget(key: string, content: WidgetContent, placement?: string): void;
+    setHeader(factory: HeaderFactory): void;
+    setFooter(factory: FooterFactory): void;
+    getEditor?(): EditorComponent;
+    getAutocompleteProvider?(): AutocompleteProvider;
+    setAutocompleteProvider?(provider: AutocompleteProvider): void;
+    themes?: Theme[];
+    themeChanged?(theme: Theme): void;
+    getToolsExpanded?(): boolean;
+    setToolsExpanded?(expanded: boolean): void;
+}
+export interface TerminalUi extends ExtensionUIContext {
+    readonly state: TerminalUiState;
+    secretInput: ExtensionUIContext['input'];
+    wrapAutocomplete(provider: AutocompleteProvider): AutocompleteProvider;
+    reset(): void;
+    setThemes(themes: Theme[]): void;
+    dispose(): void;
+}
+/** UI adaptation only: the Application owns component mounting and terminal lifecycle. */
+export declare function createTerminalUi(options: TerminalUiOptions): TerminalUi;
+export {};

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

@@ -0,0 +1,148 @@
+import { Theme } from '@earendil-works/pi-coding-agent';
+import { stripTerminalSequences } from '@earendil-works/pi-tui';
+import { TerminalDialogs } from "./dialogs.js";
+/** UI adaptation only: the Application owns component mounting and terminal lifecycle. */
+export function createTerminalUi(options) {
+    const state = {
+        theme: options.theme, workingVisible: true, toolsExpanded: false, autocompleteFactories: []
+    };
+    const dialogs = new TerminalDialogs(options.tui, () => state.theme, options.keybindings, options.changed);
+    const inputSubscriptions = new Set();
+    const builtInThemes = options.themes ?? [];
+    const themes = new Map(builtInThemes.filter(theme => theme.name).map(theme => [theme.name, theme]));
+    if (options.theme.name)
+        themes.set(options.theme.name, options.theme);
+    const statusKeys = new Set();
+    const widgetKeys = new Set();
+    let editorFactory;
+    let disposed = false;
+    const changed = () => { if (!disposed)
+        options.changed(); };
+    const wrapAutocomplete = (provider) => state.autocompleteFactories.reduce((current, factory) => factory(current), provider);
+    return {
+        state,
+        select: (title, items, opts) => dialogs.select(title, items, opts),
+        confirm: (title, message, opts) => dialogs.confirm(title, message, opts),
+        input: (title, placeholder, opts) => dialogs.input(title, placeholder, opts),
+        secretInput: (title, placeholder, opts) => dialogs.input(title, placeholder, opts, true),
+        editor: (title, prefill) => dialogs.editor(title, prefill),
+        custom: (factory, opts) => dialogs.custom(factory, opts),
+        notify: (message, type) => options.notify(message, type),
+        onTerminalInput(handler) {
+            if (disposed)
+                return () => { };
+            const remove = options.tui.addInputListener(handler);
+            const unsubscribe = () => { if (inputSubscriptions.delete(unsubscribe))
+                remove(); };
+            inputSubscriptions.add(unsubscribe);
+            return unsubscribe;
+        },
+        setStatus(key, value) { if (value === undefined)
+            statusKeys.delete(key);
+        else
+            statusKeys.add(key); options.setStatus(key, value); changed(); },
+        setWorkingMessage(message) { state.workingMessage = message; changed(); },
+        setWorkingVisible(visible) { state.workingVisible = visible; changed(); },
+        setWorkingIndicator(indicator) {
+            state.workingIndicator = indicator ? { ...indicator, frames: indicator.frames?.slice() } : undefined;
+            changed();
+        },
+        setHiddenThinkingLabel(label) { state.hiddenThinkingLabel = label; changed(); },
+        setWidget(key, content, placement) { if (content === undefined)
+            widgetKeys.delete(key);
+        else
+            widgetKeys.add(key); options.setWidget(key, content, placement?.placement); changed(); },
+        setHeader(factory) { options.setHeader(factory); changed(); },
+        setFooter(factory) { options.setFooter(factory); changed(); },
+        setTitle(title) { options.tui.terminal.setTitle(stripTerminalSequences(title).replace(/[\x00-\x1f\x7f]/g, ' ')); },
+        pasteToEditor(text) {
+            const editor = options.getEditor?.();
+            if (editor)
+                editor.handleInput(`\x1b[200~${text}\x1b[201~`);
+            else
+                options.setEditorText(options.getEditorText() + text);
+            changed();
+        },
+        setEditorText(text) { options.setEditorText(text); changed(); },
+        getEditorText: options.getEditorText,
+        addAutocompleteProvider(factory) {
+            state.autocompleteFactories.push(factory);
+            const base = options.getAutocompleteProvider?.();
+            if (base)
+                options.setAutocompleteProvider?.(wrapAutocomplete(base));
+            changed();
+        },
+        wrapAutocomplete,
+        setEditorComponent(factory) { editorFactory = factory; options.setEditor(factory); changed(); },
+        getEditorComponent: () => editorFactory,
+        get theme() { return state.theme; },
+        getAllThemes: () => [...themes].map(([name, theme]) => ({ name, path: theme.sourcePath })),
+        getTheme: name => themes.get(name),
+        setTheme(themeOrName) {
+            const theme = typeof themeOrName === 'string' ? themes.get(themeOrName) : themeOrName;
+            if (!(theme instanceof Theme))
+                return { success: false, error: `Unknown theme: ${String(themeOrName)}` };
+            state.theme = theme;
+            if (theme.name)
+                themes.set(theme.name, theme);
+            options.themeChanged?.(theme);
+            options.tui.invalidate();
+            changed();
+            return { success: true };
+        },
+        getToolsExpanded: () => options.getToolsExpanded?.() ?? state.toolsExpanded,
+        setToolsExpanded(expanded) { state.toolsExpanded = expanded; options.setToolsExpanded?.(expanded); changed(); },
+        setThemes(loaded) {
+            themes.clear();
+            for (const theme of builtInThemes)
+                if (theme.name)
+                    themes.set(theme.name, theme);
+            for (const theme of loaded)
+                if (theme.name)
+                    themes.set(theme.name, theme);
+            if (options.theme.name && !themes.has(options.theme.name))
+                themes.set(options.theme.name, options.theme);
+            if (state.theme.name && !themes.has(state.theme.name))
+                themes.set(state.theme.name, state.theme);
+            changed();
+        },
+        reset() {
+            if (disposed)
+                return;
+            dialogs.reset();
+            for (const unsubscribe of [...inputSubscriptions])
+                unsubscribe();
+            inputSubscriptions.clear();
+            for (const key of statusKeys)
+                options.setStatus(key, undefined);
+            for (const key of widgetKeys)
+                options.setWidget(key, undefined);
+            statusKeys.clear();
+            widgetKeys.clear();
+            state.autocompleteFactories = [];
+            state.workingMessage = undefined;
+            state.workingVisible = true;
+            state.workingIndicator = undefined;
+            state.hiddenThinkingLabel = undefined;
+            state.toolsExpanded = false;
+            editorFactory = undefined;
+            options.setHeader(undefined);
+            options.setFooter(undefined);
+            options.setEditor(undefined);
+            options.setToolsExpanded?.(false);
+            const base = options.getAutocompleteProvider?.();
+            if (base)
+                options.setAutocompleteProvider?.(base);
+            changed();
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            dialogs.dispose();
+            for (const unsubscribe of [...inputSubscriptions])
+                unsubscribe();
+            inputSubscriptions.clear();
+        }
+    };
+}

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

@@ -0,0 +1,9 @@
+export declare const WORKING_VERBS: readonly ["Accomplishing", "Actioning", "Actualizing", "Architecting", "Baking", "Beaming", "Beboppin'", "Befuddling", "Billowing", "Blanching", "Bloviating", "Boogieing", "Boondoggling", "Booping", "Bootstrapping", "Brewing", "Bunning", "Burrowing", "Calculating", "Canoodling", "Caramelizing", "Cascading", "Catapulting", "Cerebrating", "Channeling", "Choreographing", "Churning", "Clauding", "Coalescing", "Cogitating", "Combobulating", "Composing", "Computing", "Concocting", "Considering", "Contemplating", "Cooking", "Crafting", "Creating", "Crunching", "Crystallizing", "Cultivating", "Deciphering", "Deliberating", "Determining", "Dilly-dallying", "Discombobulating", "Doing", "Doodling", "Drizzling", "Ebbing", "Effecting", "Elucidating", "Embellishing", "Enchanting", "Envisioning", "Fermenting", "Fiddle-faddling", "Finagling", "Flambéing", "Flibbertigibbeting", "Flowing", "Flummoxing", "Fluttering", "Forging", "Forming", "Frolicking", "Frosting", "Gallivanting", "Galloping", "Garnishing", "Generating", "Gesticulating", "Germinating", "Gitifying", "Grooving", "Gusting", "Harmonizing", "Hashing", "Hatching", "Herding", "Honking", "Hullaballooing", "Hyperspacing", "Ideating", "Imagining", "Improvising", "Incubating", "Inferring", "Infusing", "Ionizing", "Jitterbugging", "Julienning", "Kerfuffling", "Kneading", "Leavening", "Levitating", "Lollygagging", "Manifesting", "Marinating", "Meandering", "Metamorphosing", "Misting", "Moonwalking", "Moseying", "Mulling", "Mustering", "Nebulizing", "Nesting", "Newspapering", "Noodling", "Nucleating", "Onioning", "Orbiting", "Orchestrating", "Osmosing", "Perambulating", "Percolating", "Perusing", "Philosophizing", "Photosynthesizing", "Polishing", "Pollinating", "Pondering", "Pontificating", "Pouncing", "Precipitating", "Prestidigitating", "Processing", "Proofing", "Propagating", "Puttering", "Puzzling", "Quantumizing", "Razzle-dazzling", "Razzmatazzing", "Recombobulating", "Reticulating", "Roosting", "Ruminating", "Sautéing", "Scampering", "Schlepping", "Scurrying", "Seasoning", "Shenaniganing", "Shimmying", "Simmering", "Skedaddling", "Sketching", "Slithering", "Smooshing", "Sock-hopping", "Spelunking", "Spinning", "Sprouting", "Stewing", "Sublimating", "Swirling", "Swooping", "Symbioting", "Synthesizing", "Tempering", "Thinking", "Thundering", "Tinkering", "Tomfoolering", "Topsy-turvying", "Transfiguring", "Transmogrifying", "Transmuting", "Twisting", "Undulating", "Unfurling", "Unraveling", "Vibing", "Waddling", "Wandering", "Warping", "Whatchamacalliting", "Whirlpooling", "Whirring", "Whisking", "Wibbling", "Working", "Wrangling", "Zesting", "Zigzagging"];
+export declare const COMPLETION_VERBS: readonly ["Baked", "Brewed", "Churned", "Cogitated", "Cooked", "Crunched", "Sautéed", "Worked"];
+export declare const SPINNER_INTERVAL_MS = 80;
+export declare function getWorkingSpinnerFrames(term?: string): readonly string[];
+export declare function spinnerFrameAt(elapsedMs: number, frames: readonly string[], intervalMs?: number): string;
+export declare function chooseWorkingVerb(random?: () => number): string;
+export declare function chooseCompletionVerb(turnId: string): string;
+export declare function formatWorkingDuration(durationMs: number): string;
+export declare function createCompletionStatus(turnId: string, durationMs: number): string;