@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/tui/model/trace-interaction.js

@@ -0,0 +1,87 @@
+/**
+ * UI-only fold/selection state. Tool lifecycle data remains immutable in the
+ * controller; live and settled renderers share this object so committing a
+ * turn cannot reset an expanded tool entry.
+ */
+export class TraceInteractionState {
+    revision = 0;
+    selectedKey;
+    selectedGroupKey;
+    hoveredGroupKey;
+    expandedGroups = new Set();
+    expandedItems = new Set();
+    groupKey(group) {
+        return `${group.kind}:${group.raw[0]?.id ?? group.title}`;
+    }
+    itemKey(group, toolId) {
+        return `${this.groupKey(group)}:item:${toolId}`;
+    }
+    isSelected(key) {
+        return this.selectedKey === key;
+    }
+    isGroupSelected(groupKey) {
+        return this.selectedGroupKey === groupKey;
+    }
+    isGroupHovered(groupKey) {
+        return this.hoveredGroupKey === groupKey;
+    }
+    isGroupExpanded(groupKey) {
+        return this.expandedGroups.has(groupKey);
+    }
+    isItemExpanded(itemKey) {
+        return this.expandedItems.has(itemKey);
+    }
+    /**
+     * Monotonic render revision for transcript projection caches. The tool
+     * lifecycle remains immutable in the controller; only these UI affordances
+     * can change the settled projection without replacing the transcript array.
+     */
+    getRevision() {
+        return this.revision;
+    }
+    activate(target, clickCount) {
+        const selectionChanged = this.selectedKey !== target.key || this.selectedGroupKey !== target.groupKey;
+        this.selectedKey = target.key;
+        this.selectedGroupKey = target.groupKey;
+        let foldChanged = false;
+        const actionClickCount = target.kind === "image" ? 1 : 2;
+        if (clickCount === actionClickCount && target.action) {
+            if (selectionChanged)
+                this.revision += 1;
+            return target.action;
+        }
+        if (clickCount !== 2 || !target.foldable) {
+            if (selectionChanged)
+                this.revision += 1;
+            return undefined;
+        }
+        if (target.kind === "group") {
+            this.toggle(this.expandedGroups, target.groupKey);
+            foldChanged = true;
+        }
+        else if (target.kind === "item") {
+            this.toggle(this.expandedItems, target.key);
+            foldChanged = true;
+        }
+        if (selectionChanged || foldChanged)
+            this.revision += 1;
+        return undefined;
+    }
+    hover(target) {
+        const next = target?.groupKey;
+        if (next === this.hoveredGroupKey)
+            return false;
+        this.hoveredGroupKey = next;
+        this.revision += 1;
+        return true;
+    }
+    clearHover() {
+        return this.hover(undefined);
+    }
+    toggle(values, key) {
+        if (values.has(key))
+            values.delete(key);
+        else
+            values.add(key);
+    }
+}

package/dist/tui/model/width.d.ts

@@ -0,0 +1,18 @@
+/** Current verdict — true when ambiguous-width chars occupy 2 terminal cells. */
+export declare function ambiguousIsWide(): boolean;
+/** Deterministic override for tests (force CJK-wide / narrow). */
+export declare function setAmbiguousWide(v: boolean): void;
+export declare function visualWidth(str: string): number;
+export declare function graphemeWidth(grapheme: string): number;
+/**
+ * Probe the real terminal once at startup, before Ink owns the TTY: print a
+ * single ambiguous-width glyph at column 1, ask where the cursor landed via the
+ * DSR cursor-position report (`CSI 6n` → `ESC [ row ; col R`), and read back the
+ * glyph's rendered width. Width 2 → ambiguous-wide; width 1 → narrow.
+ *
+ * An explicit env override wins and skips the probe entirely. A non-TTY (pipe,
+ * CI) or an unresponsive terminal (the `setTimeout` fires) leaves the locale
+ * guess untouched. The probe glyph is erased before returning so the first Ink
+ * paint sees a clean line.
+ */
+export declare function detectAmbiguousWidth(timeoutMs?: number): Promise<void>;

package/dist/tui/model/width.js

@@ -0,0 +1,130 @@
+import stringWidth from "string-width";
+/**
+ * One verdict for the whole TUI: does THIS terminal render East Asian
+ * *Ambiguous*-width characters as 2 cells?
+ *
+ * Ambiguous-width (Unicode EastAsianWidth=A) covers the curly quotes “ ”, the
+ * em dash —, the ● bullet, the ellipsis …, box-drawing ─│┼ and more. `string-
+ * width`'s default counts them as 1, but a terminal can render them as 2 — and
+ * crucially that choice is a property of the *terminal + font*, NOT the locale:
+ * this project's own author hits wide rendering under `LANG=en_US`. When our
+ * width math disagrees with the terminal, a line we packed to "exactly fits"
+ * overflows and the terminal applies its own hard wrap, dropping the overflow
+ * tail onto a stray physical row (the lone "顺" + vertical-gap corruption).
+ *
+ * So the verdict is resolved, in priority order:
+ *   1. explicit env override `BUBBLE_AMBIGUOUS_WIDTH=wide|narrow`,
+ *   2. a one-shot CSI 6n cursor probe of the real terminal at startup,
+ *   3. a CJK-locale guess as the last resort.
+ *
+ * EVERYTHING that measures display width for wrapping, cursor mapping, padding,
+ * truncation or gutter budgeting must go through `visualWidth`/`graphemeWidth`
+ * here, so the entire UI shares the single verdict and stays self-consistent.
+ */
+let ambiguousWide = initialGuess();
+function envOverride() {
+    const v = process.env.BUBBLE_AMBIGUOUS_WIDTH?.trim().toLowerCase();
+    if (!v)
+        return undefined;
+    if (/^(wide|double|full|2)$/.test(v))
+        return true;
+    if (/^(narrow|single|half|1)$/.test(v))
+        return false;
+    return undefined;
+}
+function localeIsCJK() {
+    const lang = process.env.LC_ALL || process.env.LC_CTYPE || process.env.LANG || "";
+    return /(^|[._-])(zh|ja|ko)/i.test(lang);
+}
+function initialGuess() {
+    const override = envOverride();
+    return override !== undefined ? override : localeIsCJK();
+}
+/** Current verdict — true when ambiguous-width chars occupy 2 terminal cells. */
+export function ambiguousIsWide() {
+    return ambiguousWide;
+}
+/** Deterministic override for tests (force CJK-wide / narrow). */
+export function setAmbiguousWide(v) {
+    ambiguousWide = v;
+}
+export function visualWidth(str) {
+    if (!str)
+        return 0;
+    return stringWidth(str, { ambiguousIsNarrow: !ambiguousWide });
+}
+export function graphemeWidth(grapheme) {
+    if (!grapheme)
+        return 0;
+    return stringWidth(grapheme, { ambiguousIsNarrow: !ambiguousWide });
+}
+/**
+ * Probe the real terminal once at startup, before Ink owns the TTY: print a
+ * single ambiguous-width glyph at column 1, ask where the cursor landed via the
+ * DSR cursor-position report (`CSI 6n` → `ESC [ row ; col R`), and read back the
+ * glyph's rendered width. Width 2 → ambiguous-wide; width 1 → narrow.
+ *
+ * An explicit env override wins and skips the probe entirely. A non-TTY (pipe,
+ * CI) or an unresponsive terminal (the `setTimeout` fires) leaves the locale
+ * guess untouched. The probe glyph is erased before returning so the first Ink
+ * paint sees a clean line.
+ */
+export async function detectAmbiguousWidth(timeoutMs = 150) {
+    if (envOverride() !== undefined)
+        return; // explicit choice already applied
+    const { stdin, stdout } = process;
+    if (!stdout.isTTY || !stdin.isTTY || typeof stdin.setRawMode !== "function")
+        return;
+    const wasRaw = stdin.isRaw ?? false;
+    const wasFlowing = stdin.readableFlowing ?? false;
+    const measured = await new Promise((resolve) => {
+        let buf = "";
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            stdin.removeListener("data", onData);
+            try {
+                stdin.setRawMode(wasRaw);
+            }
+            catch {
+                // teardown best-effort
+            }
+            if (!wasFlowing)
+                stdin.pause();
+            resolve(result);
+        };
+        const onData = (chunk) => {
+            buf += chunk.toString("latin1");
+            const m = /\x1b\[\d+;(\d+)R/.exec(buf);
+            if (m)
+                finish(Number(m[1]) - 1); // col is 1-based; col-1 = glyph width
+        };
+        const timer = setTimeout(() => finish(null), timeoutMs);
+        try {
+            stdin.setRawMode(true);
+            stdin.resume();
+            stdin.on("data", onData);
+            // \r → column 1, print the probe glyph (U+201C “), then request the cursor
+            // column. The reported column minus 1 is the glyph's rendered cell width.
+            stdout.write("\r“\x1b[6n");
+        }
+        catch {
+            finish(null);
+        }
+    });
+    if (measured === 2)
+        ambiguousWide = true;
+    else if (measured === 1)
+        ambiguousWide = false;
+    // measured === null → probe failed; keep the locale-based guess.
+    try {
+        if (stdout.isTTY)
+            stdout.write("\r\x1b[K"); // wipe the probe glyph
+    }
+    catch {
+        // stdout best-effort
+    }
+}

package/dist/tui/model-picker-data.d.ts

@@ -0,0 +1,9 @@
+import { type ModelInfo, type ProviderProfile, type ProviderRegistry } from "../provider-registry.js";
+export type ModelPickerRegistry = Pick<ProviderRegistry, "getEnabled" | "getModelConfig" | "listModels">;
+export type ModelProviderGroup = {
+    provider: ProviderProfile;
+    models: ModelInfo[];
+};
+export declare function localModelsForProvider(registry: Pick<ProviderRegistry, "getModelConfig">, provider: ProviderProfile): ModelInfo[];
+export declare function getVisibleModelProviders(registry: Pick<ProviderRegistry, "getEnabled">, providerId?: string): ProviderProfile[];
+export declare function discoverModelProviderGroups(registry: ModelPickerRegistry, providerId?: string): Promise<ModelProviderGroup[]>;

package/dist/tui/model-picker-data.js

@@ -0,0 +1,39 @@
+import { listBuiltinModels } from "../model-catalog.js";
+import { filterProviderModels } from "../provider-model-policy.js";
+import { isUserVisibleProvider, } from "../provider-registry.js";
+export function localModelsForProvider(registry, provider) {
+    const customModels = filterProviderModels(provider.id, registry.getModelConfig().getCustomModels(provider.id));
+    if (customModels.length > 0)
+        return customModels;
+    const builtinProviderId = provider.id === "openai" && provider.authType === "oauth"
+        ? "openai-codex"
+        : provider.id;
+    return listBuiltinModels(builtinProviderId).map((model) => ({
+        id: model.id,
+        name: model.name,
+        providerId: provider.id,
+        reasoningLevels: model.reasoningLevels,
+        defaultReasoningLevel: model.defaultReasoningLevel,
+        contextWindow: model.contextWindow,
+        useResponsesLite: model.useResponsesLite,
+        toolOutputTokenLimit: model.toolOutputTokenLimit,
+        tier: model.tier,
+    }));
+}
+export function getVisibleModelProviders(registry, providerId) {
+    return registry
+        .getEnabled()
+        .filter((provider) => isUserVisibleProvider(provider.id))
+        .filter((provider) => !providerId || provider.id === providerId);
+}
+export async function discoverModelProviderGroups(registry, providerId) {
+    const providers = getVisibleModelProviders(registry, providerId);
+    return Promise.all(providers.map(async (provider) => {
+        try {
+            return { provider, models: await registry.listModels(provider) };
+        }
+        catch {
+            return { provider, models: localModelsForProvider(registry, provider) };
+        }
+    }));
+}

package/dist/tui/model-switch.d.ts

@@ -0,0 +1,49 @@
+import type { Provider, ThinkingLevel } from "../types.js";
+import type { ProviderProfile } from "../provider-registry.js";
+import { type SystemPromptOptions } from "../system-prompt.js";
+export interface ModelSwitchAgent {
+    model: string;
+    providerId: string;
+    thinking: ThinkingLevel;
+    setProvider(provider: Provider): void;
+    setSystemPrompt(prompt: string): void;
+    /** Routing menu for the NEXT parent route (model-routing design §1.5). */
+    renderModelRoutingPromptFor?(parent: {
+        providerId: string;
+        model: string;
+    }): string | undefined;
+}
+export interface ModelSwitchRegistry {
+    prepareProvider(providerId: string): Promise<void>;
+    getConfigured(): ProviderProfile[];
+    getDefault(): ProviderProfile | undefined;
+}
+export interface ModelSwitchSession {
+    updateMetadata(metadata: {
+        model: string;
+        thinkingLevel: ThinkingLevel;
+        reasoningEffort: ThinkingLevel;
+    }): void;
+    appendMarker(kind: "model_switch", value: string): void;
+}
+export interface SwitchAgentModelOptions {
+    model: string;
+    agent: ModelSwitchAgent;
+    registry: ModelSwitchRegistry;
+    createProvider: ((providerId: string, apiKey: string, baseURL: string) => Provider) | undefined;
+    /** A side-effect-free provider instance prepared before an atomic session transition. */
+    preparedProvider?: Provider;
+    workingDir: string;
+    systemPromptOptions: Omit<SystemPromptOptions, "agentName" | "configuredProvider" | "configuredModel" | "configuredModelId" | "thinkingLevel" | "workingDir">;
+    thinkingLevel?: ThinkingLevel;
+    rememberModel(model: string): void;
+    setThinkingLevel(level: ThinkingLevel): void;
+    sessionManager?: ModelSwitchSession;
+}
+export declare function modelSwitchTarget(model: string, fallbackProviderId: string | undefined): {
+    providerId: string;
+    modelId: string;
+};
+export declare function errorMessage(error: unknown): string;
+export declare function formatModelSwitchError(model: string, error: unknown): string;
+export declare function switchAgentModel(options: SwitchAgentModelOptions): Promise<ThinkingLevel>;

package/dist/tui/model-switch.js

@@ -0,0 +1,67 @@
+import { decodeModel, displayModel } from "../provider-registry.js";
+import { buildSystemPrompt } from "../system-prompt.js";
+import { getAvailableThinkingLevels, normalizeThinkingLevel } from "../provider-transform.js";
+import { normalizeInheritedThinkingLevel } from "../variant/variant-resolver.js";
+import { assertProviderModelAllowed } from "../provider-model-policy.js";
+export function modelSwitchTarget(model, fallbackProviderId) {
+    const decoded = decodeModel(model);
+    return {
+        providerId: decoded.providerId || fallbackProviderId || "openai",
+        modelId: decoded.modelId,
+    };
+}
+export function errorMessage(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("refresh_token_reused")
+        || message.includes("invalid_grant")
+        || message.includes("Your refresh token has already been used")) {
+        return "OpenAI login expired. Run /login openai again to refresh your ChatGPT credentials.";
+    }
+    return message;
+}
+export function formatModelSwitchError(model, error) {
+    return `Failed to switch model to ${displayModel(model)}: ${errorMessage(error)}`;
+}
+export async function switchAgentModel(options) {
+    const { providerId, modelId } = modelSwitchTarget(options.model, options.agent.providerId || options.registry.getDefault()?.id);
+    assertProviderModelAllowed(providerId, modelId);
+    if (!options.preparedProvider) {
+        await options.registry.prepareProvider(providerId);
+    }
+    const provider = options.registry.getConfigured().find((item) => item.id === providerId);
+    if (!provider?.apiKey || (!options.createProvider && !options.preparedProvider)) {
+        throw new Error(`Provider ${providerId} is not configured or has no active credentials.`);
+    }
+    const nextThinkingLevel = options.thinkingLevel !== undefined
+        ? normalizeThinkingLevel(options.thinkingLevel, getAvailableThinkingLevels(providerId, modelId))
+        : normalizeInheritedThinkingLevel(providerId, modelId, options.agent.thinking);
+    const nextProvider = options.preparedProvider
+        ?? options.createProvider(providerId, provider.apiKey, provider.baseURL);
+    const nextSystemPrompt = buildSystemPrompt({
+        agentName: "Bubble",
+        configuredProvider: providerId,
+        configuredModel: displayModel(options.model),
+        configuredModelId: options.model,
+        thinkingLevel: nextThinkingLevel,
+        workingDir: options.workingDir,
+        ...options.systemPromptOptions,
+        // The spread carries the menu for the OLD parent; re-render for the model
+        // being switched to, before any agent state is mutated (design §1.5).
+        modelRoutingPrompt: options.agent.renderModelRoutingPromptFor?.({ providerId, model: modelId })
+            ?? options.systemPromptOptions.modelRoutingPrompt,
+    });
+    options.agent.model = options.model;
+    options.agent.thinking = nextThinkingLevel;
+    options.agent.setProvider(nextProvider);
+    options.agent.providerId = providerId;
+    options.agent.setSystemPrompt(nextSystemPrompt);
+    options.rememberModel(options.model);
+    options.setThinkingLevel(nextThinkingLevel);
+    options.sessionManager?.updateMetadata({
+        model: options.model,
+        thinkingLevel: nextThinkingLevel,
+        reasoningEffort: nextThinkingLevel,
+    });
+    options.sessionManager?.appendMarker("model_switch", options.model);
+    return nextThinkingLevel;
+}

package/dist/tui/paste-placeholder.d.ts

@@ -0,0 +1,11 @@
+export declare const LONG_PASTE_CHAR_THRESHOLD = 1000;
+export declare const LONG_PASTE_LINE_THRESHOLD = 20;
+export interface PastedContentReference {
+    marker: string;
+    content: string;
+}
+export declare function countTextLines(text: string): number;
+export declare function shouldCollapsePastedContent(text: string): boolean;
+export declare function createPastedContentMarker(content: string, index?: number): string;
+export declare function decodePastedBytes(bytes: unknown): string;
+export declare function expandPastedContentMarkers(displayText: string, references: PastedContentReference[]): string;

package/dist/tui/paste-placeholder.js

@@ -0,0 +1,52 @@
+export const LONG_PASTE_CHAR_THRESHOLD = 1000;
+export const LONG_PASTE_LINE_THRESHOLD = 20;
+export function countTextLines(text) {
+    return text.length === 0 ? 0 : text.split(/\r?\n/).length;
+}
+export function shouldCollapsePastedContent(text) {
+    if (text.length >= LONG_PASTE_CHAR_THRESHOLD)
+        return true;
+    return countTextLines(text) >= LONG_PASTE_LINE_THRESHOLD;
+}
+export function createPastedContentMarker(content, index = 1) {
+    const safeIndex = Math.max(1, Math.floor(index));
+    const lineCount = countTextLines(content);
+    const size = lineCount > 1
+        ? `${lineCount} ${lineCount === 1 ? "line" : "lines"}`
+        : `${content.length} ${content.length === 1 ? "char" : "chars"}`;
+    return `[Pasted text #${safeIndex} +${size}]`;
+}
+export function decodePastedBytes(bytes) {
+    if (typeof bytes === "string")
+        return bytes;
+    if (bytes instanceof Uint8Array)
+        return new TextDecoder().decode(bytes);
+    return "";
+}
+export function expandPastedContentMarkers(displayText, references) {
+    if (references.length === 0 || displayText.length === 0)
+        return displayText;
+    let expanded = "";
+    let index = 0;
+    const used = new Set();
+    while (index < displayText.length) {
+        let matched = -1;
+        for (let i = 0; i < references.length; i++) {
+            const ref = references[i];
+            if (!used.has(i) && displayText.startsWith(ref.marker, index)) {
+                matched = i;
+                break;
+            }
+        }
+        if (matched >= 0) {
+            const ref = references[matched];
+            expanded += ref.content;
+            index += ref.marker.length;
+            used.add(matched);
+            continue;
+        }
+        expanded += displayText[index];
+        index += 1;
+    }
+    return expanded;
+}

package/dist/tui/recent-activity.d.ts

@@ -0,0 +1,8 @@
+export interface RecentSession {
+    file: string;
+    modifiedAt: number;
+    preview: string;
+}
+export declare function getRecentSessions(cwd: string, limit?: number): RecentSession[];
+export declare function formatRelativeTime(timestampMs: number, now?: number): string;
+export declare function truncatePreview(preview: string, maxLen: number): string;

package/dist/tui/recent-activity.js

@@ -0,0 +1,71 @@
+import { readFileSync, readdirSync, statSync, existsSync } from "node:fs";
+import path from "node:path";
+import { getSessionsDir } from "../session.js";
+export function getRecentSessions(cwd, limit = 3) {
+    const dir = getSessionsDir(cwd);
+    if (!existsSync(dir))
+        return [];
+    const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+    const withMtime = files.map((f) => {
+        const full = path.join(dir, f);
+        try {
+            return { file: f, full, modifiedAt: statSync(full).mtimeMs };
+        }
+        catch {
+            return { file: f, full, modifiedAt: 0 };
+        }
+    });
+    withMtime.sort((a, b) => b.modifiedAt - a.modifiedAt);
+    return withMtime.slice(0, limit).map(({ file, full, modifiedAt }) => ({
+        file,
+        modifiedAt,
+        preview: extractFirstUserMessage(full) ?? "(no messages)",
+    }));
+}
+export function formatRelativeTime(timestampMs, now = Date.now()) {
+    const diffSec = Math.max(0, Math.floor((now - timestampMs) / 1000));
+    if (diffSec < 60)
+        return "just now";
+    if (diffSec < 3600)
+        return `${Math.floor(diffSec / 60)}m ago`;
+    if (diffSec < 86400)
+        return `${Math.floor(diffSec / 3600)}h ago`;
+    if (diffSec < 604800)
+        return `${Math.floor(diffSec / 86400)}d ago`;
+    const weeks = Math.floor(diffSec / 604800);
+    if (weeks < 5)
+        return `${weeks}w ago`;
+    const months = Math.floor(diffSec / (30 * 86400));
+    return `${months}mo ago`;
+}
+function extractFirstUserMessage(file) {
+    let raw;
+    try {
+        raw = readFileSync(file, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    const lines = raw.split("\n");
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry.type === "user_message" && typeof entry.message?.content === "string") {
+            return entry.message.content;
+        }
+    }
+    return null;
+}
+export function truncatePreview(preview, maxLen) {
+    const firstLine = preview.split("\n")[0]?.trim() ?? "";
+    if (firstLine.length <= maxLen)
+        return firstLine;
+    return firstLine.slice(0, Math.max(1, maxLen - 1)) + "…";
+}

package/dist/tui/run-session-picker.d.ts

@@ -0,0 +1,9 @@
+import { SessionSummary } from "../session.js";
+export interface RunSessionPickerOptions {
+    currentCwd: string;
+    currentSessions: SessionSummary[];
+    allSessions: SessionSummary[];
+    resolvedTheme?: "light" | "dark";
+    themeOverrides?: Record<string, string>;
+}
+export declare function runSessionPicker(options: RunSessionPickerOptions): Promise<string | undefined>;

package/dist/tui/run-session-picker.js

@@ -0,0 +1,64 @@
+/**
+ * Startup `--resume` session picker on the vendored Pi TUI renderer. Contract:
+ * resolve the chosen session file, or undefined on cancel.
+ */
+import { Box, ProcessTerminal, TuiMainScreen, Text, VStack, SelectList } from "@bubblebrain-ai/pi-tui";
+import { paletteFor } from "./model/theme.js";
+import { themeBackground, themeDim, themeForeground } from "./model/theme-style.js";
+export async function runSessionPicker(options) {
+    const terminal = new ProcessTerminal();
+    const tui = new TuiMainScreen(terminal);
+    const theme = paletteFor(options.resolvedTheme ?? "dark", options.themeOverrides);
+    const items = [];
+    for (const summary of options.currentSessions.slice(0, 10)) {
+        items.push({
+            value: summary.file,
+            label: summary.title ?? summary.file.split("/").pop() ?? summary.file,
+            description: "this project",
+        });
+    }
+    const otherCount = options.allSessions.length - options.currentSessions.length;
+    if (otherCount > 0) {
+        for (const summary of options.allSessions.filter((s) => !options.currentSessions.includes(s)).slice(0, 10)) {
+            items.push({
+                value: summary.file,
+                label: summary.title ?? summary.file.split("/").pop() ?? summary.file,
+                description: "other project",
+            });
+        }
+    }
+    if (items.length === 0)
+        return undefined;
+    return new Promise((resolve) => {
+        const finish = (value) => {
+            try {
+                tui.stop();
+            }
+            catch {
+                /* already stopped */
+            }
+            resolve(value);
+        };
+        const header = new VStack([
+            new Text(themeForeground(theme.accent, "Resume session"), 1, 0),
+            new Text(themeDim(theme.dim, "Enter to select · Esc to start fresh"), 1, 0),
+        ]);
+        const list = new SelectList(items, 10, {
+            selectedPrefix: () => themeForeground(theme.accent, "› "),
+            selectedText: (str) => themeForeground(theme.inputText, str),
+            description: (str) => themeDim(theme.dim, str),
+            scrollInfo: (str) => themeDim(theme.dim, str),
+            noMatch: (str) => themeDim(theme.dim, str),
+        }, {});
+        const content = new VStack([header, list]);
+        const box = theme.background
+            ? new Box(0, 0, (text) => themeBackground(theme.background, text))
+            : new Box(0, 0);
+        box.addChild(content);
+        list.onSelect = (item) => finish(item.value);
+        list.onCancel = () => finish(undefined);
+        tui.addChild(box);
+        tui.start();
+        tui.setFocus(list);
+    });
+}