@oh-my-pi/pi-tui 18.2.4 → 18.2.6

package/dist/types/overlays/session-observer-registry.d.ts

@@ -0,0 +1,77 @@
+import type { AgentProgress, AgentSource } from "../tools/task.js";
+/** EventBus channel for aggregated subagent progress */
+export declare const TASK_SUBAGENT_PROGRESS_CHANNEL = "task:subagent:progress";
+/** EventBus channel for subagent lifecycle (start/end) */
+export declare const TASK_SUBAGENT_LIFECYCLE_CHANNEL = "task:subagent:lifecycle";
+/** Payload emitted on TASK_SUBAGENT_PROGRESS_CHANNEL */
+export interface SubagentProgressPayload {
+    index: number;
+    agent: string;
+    agentSource: AgentSource;
+    task: string;
+    parentToolCallId?: string;
+    assignment?: string;
+    progress: AgentProgress;
+    sessionFile?: string;
+    /** See {@link SubagentLifecyclePayload.detached}. */
+    detached?: boolean;
+}
+/** Payload emitted on TASK_SUBAGENT_LIFECYCLE_CHANNEL */
+export interface SubagentLifecyclePayload {
+    id: string;
+    agent: string;
+    agentSource: AgentSource;
+    description?: string;
+    status: "started" | "completed" | "failed" | "aborted";
+    sessionFile?: string;
+    parentToolCallId?: string;
+    index: number;
+    /**
+     * Spawn runs as a detached background job: the parent turn keeps working
+     * while this agent runs. Sync task spawns (parent blocked on the call) and
+     * eval `agent()` bridge spawns (rendered inside their eval cell) leave this
+     * unset — surfaces like the subagent HUD only list detached spawns.
+     */
+    detached?: boolean;
+}
+/** Minimal event subscription surface supplied by the host. */
+export interface EventBusLike {
+    on(channel: string, listener: (data: unknown) => void): () => void;
+}
+export interface ObservableSession {
+    id: string;
+    kind: "main" | "subagent";
+    label: string;
+    agent?: string;
+    description?: string;
+    status: "active" | "completed" | "failed" | "aborted";
+    sessionFile?: string;
+    parentToolCallId?: string;
+    /**
+     * Spawn runs as a detached background job (parent turn not blocked on it).
+     * Sync task spawns and eval `agent()` spawns additionally render live in
+     * their own inline tool block / eval cell; the pinned HUD jump-lists every
+     * active subagent either way.
+     */
+    detached?: boolean;
+    index?: number;
+    lastUpdate: number;
+    /** Latest progress snapshot from the subagent executor */
+    progress?: AgentProgress;
+}
+/** Coarse source of an observer change; callers use it to separate lifecycle work from high-frequency progress. */
+export type SessionObserverChangeKind = "main" | "reset" | "lifecycle" | "progress";
+export declare class SessionObserverRegistry {
+    #private;
+    /** Add a change listener. Returns unsubscribe function. */
+    onChange(cb: (kind: SessionObserverChangeKind) => void): () => void;
+    setMainSession(sessionFile?: string): void;
+    /** Return one tracked session without copying or sorting the registry. */
+    getSession(id: string): ObservableSession | undefined;
+    getSessions(): ObservableSession[];
+    getActiveSubagentCount(): number;
+    /** Clear all tracked sessions (e.g. on session switch). Keeps EventBus subscriptions and listeners. */
+    resetSessions(): void;
+    dispose(): void;
+    subscribeToEventBus(eventBus: EventBusLike, subagentEventBus: EventBusLike): void;
+}

package/dist/types/overlays/session-selector.d.ts

@@ -0,0 +1,131 @@
+import { type Component } from "../index.js";
+/** Session lifecycle status presented by the picker. */
+export type SessionSelectorStatus = "complete" | "interrupted" | "aborted" | "error" | "pending" | "unknown";
+/** Session listing fields consumed by the picker. */
+export interface SessionSelectorEntry {
+    path: string;
+    id: string;
+    cwd: string;
+    title?: string;
+    modified: Date;
+    size: number;
+    firstMessage: string;
+    allMessagesText: string;
+    status?: SessionSelectorStatus;
+    /** Path to the parent session when this one was forked. */
+    parentSessionPath?: string;
+}
+import { OverlayPanel } from "../chrome/overlay-box.js";
+/** Returns the IDs of sessions whose recorded prompts match a query, best first. */
+export type SessionHistoryMatcher = (query: string) => string[];
+/**
+ * Filter and rank session picker search results.
+ *
+ * Exact and partial title matches lead. Other literal matches rank by recency
+ * rather than a slightly better fuzzy position match. Pure fuzzy/acronym
+ * matches still sort by fuzzy score after literal matches, but weak pure
+ * fuzzy tokens are dropped as noise.
+ *
+ * This is the synchronous reference implementation; {@link SessionList} runs
+ * the same primitives incrementally so huge listings never block a keystroke.
+ */
+export declare function rankSessionSearchMatches<T extends SessionSelectorEntry>(allSessions: T[], query: string): T[];
+/**
+ * Combine metadata matches with prompt-history matches for ranking, using both
+ * signals rather than replacing one with the other.
+ *
+ * - `fuzzy` is the ordered metadata/session-text result.
+ * - `historyIds` are session IDs whose recorded prompts matched the query,
+ *   ordered by prompt-history rank (typically newest matching prompt first); duplicates are tolerated.
+ *
+ * Ranking: prompt-history matches lead in history order, then remaining
+ * metadata matches keep their existing order. A metadata match is never dropped,
+ * and history matches not present in `allSessions` (e.g. deleted or out-of-scope
+ * sessions) are ignored since they cannot be resumed from here.
+ */
+export declare function mergeSessionRanking<T extends SessionSelectorEntry>(allSessions: T[], fuzzy: T[], historyIds: string[]): T[];
+/**
+ * Custom session list component with multi-line items and search
+ */
+declare class SessionList<T extends SessionSelectorEntry> implements Component {
+    #private;
+    onSelect?: (session: T) => void;
+    onCancel?: () => void;
+    onExit: () => void;
+    onToggleScope?: () => void;
+    onDeleteRequest?: (session: T) => void;
+    /** Re-render hook for async list updates (fuzzy scan chunks, history merge). */
+    onRequestRender?: () => void;
+    constructor(sessions: T[], showCwd?: boolean, historyMatcher?: SessionHistoryMatcher, getTerminalRows?: () => number, pinnedIds?: ReadonlySet<string>, currentSessionPath?: string | (() => string | undefined));
+    /** Replace the visible dataset, e.g. when toggling folder/all-projects scope. */
+    setSessions(sessions: T[], showCwd: boolean, pinnedIds?: ReadonlySet<string>): void;
+    /** Cancel pending async search work; idempotent, called on every picker exit path. */
+    dispose(): void;
+    removeSession(sessionPath: string): void;
+    /** Resolve a list-local rendered-line index to a filtered-session index. */
+    hitTestSession(line: number): number | undefined;
+    /** Wheel notch: move the selection one step (clamped, no wrap). */
+    handleWheel(delta: -1 | 1): void;
+    /** Mouse click: select the session under the pointer and resume it. */
+    selectAndConfirm(index: number): void;
+    invalidate(): void;
+    render(width: number): readonly string[];
+    handleInput(keyData: string): void;
+}
+export interface SessionSelectorOptions<T extends SessionSelectorEntry = SessionSelectorEntry> {
+    onDelete?: (session: T) => Promise<boolean>;
+    historyMatcher?: SessionHistoryMatcher;
+    /** Loads sessions across all projects for the all-projects scope toggle (Tab). */
+    loadAllSessions?: () => Promise<T[]>;
+    /** Preloaded all-projects list; cached so the first Tab toggle is instant. */
+    allSessions?: T[];
+    /** Picker heading; defaults to "Resume Session". */
+    title?: string;
+    /** Fixed scope label, or false to omit the scope suffix. */
+    scopeLabel?: string | false;
+    /** Show each session's working directory in the list. */
+    showCwd?: boolean;
+    /**
+     * Reads the live terminal height so the visible window fits the viewport.
+     * Omitted only in tests; defaults to a conservative 24 rows.
+     */
+    getTerminalRows?: () => number;
+    /**
+     * Fill the whole viewport and pin the footer (hint + bottom border) to the
+     * last rows, so the footer stops drifting as the list window changes height.
+     * Set by the standalone `--resume` picker (fullscreen alternate screen); the
+     * in-editor selector leaves it off and renders compactly.
+     */
+    fillHeight?: boolean;
+    /** Set of pinned session ids to display with a pin indicator. */
+    pinnedIds?: ReadonlySet<string>;
+    /** Path of the live session, or a getter so detach/newSession stays accurate. */
+    currentSessionPath?: string | (() => string | undefined);
+}
+/**
+ * Component that renders a session selector with optional confirmation dialog
+ */
+export declare class SessionSelectorComponent<T extends SessionSelectorEntry = SessionSelectorEntry> extends OverlayPanel {
+    #private;
+    constructor(sessions: T[], onSelect: (session: T) => void, onCancel: () => void, onExit: () => void, options?: SessionSelectorOptions<T>);
+    setOnRequestRender(callback: () => void): void;
+    /** Ignore input after selection while the host resumes the session. */
+    lockInput(): void;
+    /** Re-enable input after a failed resume so the user can pick again. */
+    unlockInput(): void;
+    /**
+     * Dispose the session list explicitly: while the delete-confirmation dialog
+     * is mounted the list is detached from the child tree, so Container's
+     * child-walking dispose would miss its pending history-merge timer.
+     */
+    dispose(): void;
+    /**
+     * Render the panel directly so fill-height mode can keep its footer pinned
+     * while sharing OverlayPanel's exact rounded-box chrome. Children receive
+     * the panel's inner width before their rows are wrapped.
+     */
+    render(width: number): readonly string[];
+    handleInput(keyData: string): void;
+    getSessionList(): SessionList<T>;
+}
+export {};

package/dist/types/overlays/settings-defs.d.ts

@@ -0,0 +1,119 @@
+/** Schema-independent display definitions for the settings overlay. */
+import type { SymbolKey } from "../theme/symbols.js";
+export type SettingTab = "appearance" | "model" | "interaction" | "context" | "memory" | "files" | "shell" | "tools" | "tasks" | "providers";
+/** Tab display metadata - icon is resolved via theme.symbol() */
+export type TabMetadata = {
+    label: string;
+    icon: Extract<SymbolKey, `tab.${string}`>;
+};
+/** Ordered list of tabs for UI rendering */
+export declare const SETTING_TABS: SettingTab[];
+/** Tab display metadata - icon is a symbol key from theme.ts (tab.*) */
+export declare const TAB_METADATA: Record<SettingTab, TabMetadata>;
+/**
+ * Ordered section groups per tab. Settings declare their section via `ui.group`;
+ * the settings UI renders groups in this order with a heading row between them.
+ * Ungrouped settings render first, before any section heading.
+ */
+export declare const TAB_GROUPS: Record<SettingTab, readonly string[]>;
+/** Submenu choice metadata. */
+export type SubmenuOption<V extends string = string> = {
+    value: V;
+    label: string;
+    description?: string;
+};
+export interface UiBase {
+    tab: SettingTab;
+    /** Section within the tab; must be listed in TAB_GROUPS[tab]. Ungrouped settings render at the top. */
+    group?: string;
+    label: string;
+    description: string;
+    /**
+     * Risk note. Marks the settings row with a warning glyph and renders above
+     * the description in warning styling. For settings that can get the user
+     * rate-limited, flagged, or banned — not for merely advanced options.
+     */
+    warning?: string;
+    /** Condition function name - setting only shown when true */
+    condition?: string;
+}
+/** Wide ui shape exposed to consumers that walk the schema generically. */
+export type AnyUiMetadata = UiBase & {
+    options?: ReadonlyArray<SubmenuOption> | "runtime";
+    secret?: boolean;
+    ordered?: boolean;
+};
+/** Structural schema entries supplied by the application host. */
+export interface SettingsDisplayEntry {
+    path: string;
+    type: string;
+    defaultValue: unknown;
+    ui?: AnyUiMetadata;
+    enumValues?: readonly string[];
+    credential?: boolean;
+    condition?: () => boolean;
+}
+export interface SettingsHost {
+    entries: readonly SettingsDisplayEntry[];
+    get(path: string): unknown;
+    set(path: string, value: unknown): void;
+    normalizeProviderLimits(value: unknown): Record<string, number>;
+    validateProviderLimits(value: unknown): Record<string, number>;
+}
+/** Primitive value displayed by a settings control. */
+export type SettingsDisplayValue = boolean | string;
+interface BaseSettingDef {
+    path: string;
+    defaultValue: unknown;
+    schemaType: string;
+    label: string;
+    description: string;
+    /** Risk note shown in warning styling; set for settings that can get the user flagged or banned. */
+    warning?: string;
+    tab: SettingTab;
+    /** Section within the tab; items are ordered by TAB_GROUPS[tab] and rendered under a heading row. */
+    group?: string;
+    /**
+     * Optional visibility predicate. When supplied and returning false, the
+     * setting is hidden from the UI. Applies to every variant — booleans,
+     * enums, submenus, and text inputs.
+     */
+    condition?: () => boolean;
+}
+export interface BooleanSettingDef extends BaseSettingDef {
+    type: "boolean";
+}
+export interface EnumSettingDef extends BaseSettingDef {
+    type: "enum";
+    values: readonly string[];
+}
+type OptionList = ReadonlyArray<SubmenuOption>;
+export interface SubmenuSettingDef extends BaseSettingDef {
+    type: "submenu";
+    options: OptionList;
+    onPreview?: (value: string) => void;
+    onPreviewCancel?: (originalValue: string) => void;
+}
+export interface TextInputSettingDef extends BaseSettingDef {
+    type: "text";
+    secret: boolean;
+}
+export interface ProviderLimitsSettingDef extends BaseSettingDef {
+    type: "providerLimits";
+}
+/** Array-of-enum setting edited as a toggle list; `ordered` lists render positions and support reordering. */
+export interface MultiSelectSettingDef extends BaseSettingDef {
+    type: "multiselect";
+    options: OptionList;
+    ordered: boolean;
+}
+export type SettingDef = BooleanSettingDef | EnumSettingDef | SubmenuSettingDef | TextInputSettingDef | ProviderLimitsSettingDef | MultiSelectSettingDef;
+/** Get all setting definitions with UI, retaining live host visibility predicates. */
+export declare function getAllSettingDefs(entries: readonly SettingsDisplayEntry[]): SettingDef[];
+/** Get settings ordered by their tab's section layout. */
+export declare function getSettingsForTab(entries: readonly SettingsDisplayEntry[], tab: SettingTab): SettingDef[];
+/** Find the display definition for a host setting path. */
+export declare function getSettingDef(entries: readonly SettingsDisplayEntry[], path: string): SettingDef | undefined;
+/** Format a setting's declared default for display. */
+export declare function getDisplayDefault(entries: readonly SettingsDisplayEntry[], path: string): string;
+export {};

package/dist/types/overlays/settings-selector.d.ts

@@ -0,0 +1,73 @@
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Effort } from "@oh-my-pi/pi-ai";
+import { type Component, type ImageBudget } from "../index.js";
+import type { ShapeTarget } from "@oh-my-pi/snapcompact";
+import type { ContextLineMode, StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../status-line/schema.js";
+import { type SettingsHost } from "./settings-defs.js";
+import { type ComposerPreviewStatusSource } from "./composer-shape-preview.js";
+import { type PluginSettingsHost } from "./plugin-settings.js";
+/**
+ * Dynamic context for settings that need runtime data.
+ * Some settings (like thinking level) are managed by the session, not Settings.
+ */
+export interface SettingsRuntimeContext {
+    settings: SettingsHost;
+    plugins: PluginSettingsHost;
+    /** Available thinking levels (from session) */
+    availableThinkingLevels: Effort[];
+    /** Current thinking level (from session) */
+    thinkingLevel: ThinkingLevel | undefined;
+    /** Available themes */
+    availableThemes: string[];
+    /** Provider/source ids shown in /model. */
+    providers: string[];
+    /** Active model (api + id); resolves what the snapcompact `auto` shape maps to. */
+    model?: ShapeTarget;
+    /** Shared TUI image budget (graphics ids + transmit-once) for image previews. */
+    imageBudget?: ImageBudget;
+    /** Schedules a re-render after async preview work completes. */
+    requestRender?: () => void;
+    /** Live status renderer for composer-shape previews (the session's status line). */
+    composerPreviewStatus?: ComposerPreviewStatusSource;
+}
+/** Status line settings subset for preview */
+export interface StatusLinePreviewSettings {
+    preset?: StatusLinePreset;
+    contextLine?: ContextLineMode;
+    leftSegments?: StatusLineSegmentId[];
+    rightSegments?: StatusLineSegmentId[];
+    separator?: StatusLineSeparatorStyle;
+    sessionAccent?: boolean;
+    transparent?: boolean;
+    compactThinkingLevel?: boolean;
+}
+export interface SettingsCallbacks {
+    /** Called when any setting value changes */
+    onChange: (path: string, newValue: unknown) => void;
+    /** Called for theme preview while browsing */
+    onThemePreview?: (theme: string) => void | Promise<void>;
+    /** Called for status line preview while configuring */
+    onStatusLinePreview?: (settings: StatusLinePreviewSettings) => void;
+    /** Get current rendered status line for inline preview */
+    getStatusLinePreview?: () => string;
+    /** Called when plugins change */
+    onPluginsChanged?: () => void | Promise<void>;
+    /** Called when settings panel is closed */
+    onCancel: () => void;
+}
+/**
+ * Main tabbed settings selector component.
+ * Uses declarative settings definitions from settings-defs.ts.
+ */
+export declare class SettingsSelectorComponent implements Component {
+    #private;
+    constructor(context: SettingsRuntimeContext, callbacks: SettingsCallbacks);
+    invalidate(): void;
+    /**
+     * Fullscreen frame: title border, tab row, divider, optional search banner,
+     * the active content sized to fill the terminal, the appearance preview,
+     * then a footer hint pinned above the bottom border.
+     */
+    render(width: number): readonly string[];
+    handleInput(data: string): void;
+}

package/dist/types/overlays/show-images-selector.d.ts

@@ -0,0 +1,11 @@
+import { SelectList, type SgrMouseEvent } from "../index.js";
+import { OverlayPanel } from "../chrome/overlay-box.js";
+/**
+ * Component that renders a show images selector with borders
+ */
+export declare class ShowImagesSelectorComponent extends OverlayPanel {
+    #private;
+    constructor(currentValue: boolean, onSelect: (show: boolean) => void, onCancel: () => void);
+    getSelectList(): SelectList;
+    routeMouse(event: SgrMouseEvent, line: number, col: number): void;
+}

package/dist/types/overlays/snapcompact-shape-preview.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Live preview for the `snapcompact.shape` setting: renders a sample session
+ * transcript through the real snapcompact rasterizer as a miniature page and
+ * shows it zoomed, so cell size, ink hues, highlight bands, and dim tool-result
+ * spans are legible at terminal scale.
+ *
+ * The mini-frame (a {@link SRC_FRAME_PX}px page) is upscaled with
+ * nearest-neighbor so the glyph pixels stay crisp when the terminal scales the
+ * placement box. Graphics display requires the Kitty unicode-placeholder path —
+ * `renderImage` returning `lines` is the gate — because the bordered settings
+ * frame re-fits every row, which direct cursor-positioned placements (iTerm2,
+ * Sixel, Kitty `a=p`) do not survive. Everything else falls back to the stats
+ * line plus a dim notice.
+ */
+import { type Component, type ImageBudget } from "../index.js";
+import { type ShapeTarget } from "@oh-my-pi/snapcompact";
+export interface SnapcompactShapePreviewOptions {
+    /** Active model (api + id); resolves what `auto` maps to for this reader. */
+    model?: ShapeTarget;
+    /** Shared TUI image budget: stable graphics ids, transmit-once, exit cleanup. */
+    imageBudget?: ImageBudget;
+    /** Schedules a re-render once an async sample render completes. */
+    requestRender?: () => void;
+}
+export declare class SnapcompactShapePreview implements Component {
+    #private;
+    constructor(currentValue: string, options?: SnapcompactShapePreviewOptions);
+    /** Track the highlighted option; the next render reflects it. */
+    setValue(value: string): void;
+    render(width: number): readonly string[];
+}

package/dist/types/overlays/theme-selector.d.ts

@@ -0,0 +1,12 @@
+import { SelectList, type SgrMouseEvent } from "../index.js";
+import { OverlayPanel } from "../chrome/overlay-box.js";
+/**
+ * Component that renders a theme selector.
+ * Themes must be pre-loaded and passed to the constructor.
+ */
+export declare class ThemeSelectorComponent extends OverlayPanel {
+    #private;
+    constructor(currentTheme: string, themes: string[], onSelect: (themeName: string) => void, onCancel: () => void, onPreview: (themeName: string) => void);
+    getSelectList(): SelectList;
+    routeMouse(event: SgrMouseEvent, line: number, col: number): void;
+}

package/dist/types/overlays/thinking-selector.d.ts

@@ -0,0 +1,12 @@
+import type { Effort } from "@oh-my-pi/pi-ai";
+import { SelectList, type SgrMouseEvent } from "../index.js";
+import { OverlayPanel } from "../chrome/overlay-box.js";
+/**
+ * Component that renders a thinking level selector with borders
+ */
+export declare class ThinkingSelectorComponent extends OverlayPanel {
+    #private;
+    constructor(currentLevel: Effort, availableLevels: Effort[], onSelect: (level: Effort) => void, onCancel: () => void);
+    getSelectList(): SelectList;
+    routeMouse(event: SgrMouseEvent, line: number, col: number): void;
+}

package/dist/types/overlays/tiny-title-download-progress.d.ts

@@ -0,0 +1,21 @@
+import { type Component } from "../index.js";
+/** Download progress fields consumed by the status display. */
+export interface TinyTitleDownloadProgress {
+    status: "initiate" | "download" | "progress" | "progress_total" | "done" | "ready" | "error";
+    file?: string;
+    progress?: number;
+    loaded?: number;
+    total?: number;
+    files?: Record<string, {
+        loaded: number;
+        total: number;
+    }>;
+}
+export declare class TinyTitleDownloadProgressComponent implements Component {
+    #private;
+    constructor(modelLabel: string);
+    update(event: TinyTitleDownloadProgress): void;
+    isComplete(): boolean;
+    invalidate(): void;
+    render(width: number): readonly string[];
+}

package/dist/types/overlays/tree-selector.d.ts

@@ -0,0 +1,92 @@
+import { type Component } from "../index.js";
+/** Available session-tree display filters. */
+export declare const TREE_FILTER_MODES: readonly ["default", "no-tools", "user-only", "labeled-only", "all"];
+/** Session-tree display filter. */
+export type TreeFilterMode = (typeof TREE_FILTER_MODES)[number];
+import { type TranscriptEntryLike } from "../chat/transcript-entry.js";
+/** Fields consumed when displaying persisted entries in the session tree. */
+export type SessionTreeEntry = {
+    id: string;
+    parentId: string | null;
+} & (TranscriptEntryLike | {
+    type: "compaction";
+    tokensBefore: number;
+} | {
+    type: "branch_summary";
+    summary: string;
+} | {
+    type: "model_change";
+    model: string;
+} | {
+    type: "model_usage";
+    purpose: string;
+    role?: string;
+    provider: string;
+    model: string;
+} | {
+    type: "thinking_level_change";
+    thinkingLevel?: string | null;
+} | {
+    type: "custom";
+    customType: string;
+} | {
+    type: "label";
+    label?: string;
+} | {
+    type: "service_tier_change";
+    serviceTier: Partial<Record<string, string>> | null;
+} | {
+    type: "title_change";
+    title: string;
+} | {
+    type: "mode_change";
+    mode: string;
+} | {
+    type: "credential_pin";
+    provider: string;
+} | {
+    type: "ttsr_injection";
+    injectedRules: string[];
+} | {
+    type: "session_init" | "reset_boundary";
+});
+/** Session tree shape consumed by the selector. */
+export interface TreeSelectorNode {
+    entry: SessionTreeEntry;
+    children: TreeSelectorNode[];
+    label?: string;
+}
+import { OverlayPanel } from "../chrome/overlay-box.js";
+/** Filter mode for tree display */
+type FilterMode = TreeFilterMode;
+declare class TreeList implements Component {
+    #private;
+    private readonly currentLeafId;
+    private readonly maxVisibleLines;
+    onSelect?: (entryId: string, options: {
+        summarize: boolean;
+    }) => void;
+    onCancel?: () => void;
+    onLabelEdit?: (entryId: string, currentLabel: string | undefined) => void;
+    constructor(tree: TreeSelectorNode[], currentLeafId: string | null, maxVisibleLines: number, initialFilterMode?: FilterMode, initialSelectedId?: string);
+    invalidate(): void;
+    dispose(): void;
+    getSearchQuery(): string;
+    getSelectedNode(): TreeSelectorNode | undefined;
+    updateNodeLabel(entryId: string, label: string | undefined): void;
+    render(width: number): readonly string[];
+    handleInput(keyData: string): void;
+}
+/**
+ * Component that renders a session tree selector for navigation
+ */
+export declare class TreeSelectorComponent extends OverlayPanel {
+    #private;
+    private readonly onLabelChangeCallback?;
+    constructor(tree: TreeSelectorNode[], currentLeafId: string | null, terminalHeight: number, onSelect: (entryId: string, options: {
+        summarize: boolean;
+    }) => void, onCancel: () => void, onLabelChangeCallback?: ((entryId: string, label: string | undefined) => void) | undefined, initialFilterMode?: FilterMode);
+    handleInput(keyData: string): void;
+    getTreeList(): TreeList;
+}
+export {};