@oh-my-pi/pi-coding-agent 15.1.0 → 15.1.2

package/dist/types/modes/components/session-observer-overlay.d.ts

@@ -0,0 +1,11 @@
+import { Container } from "@oh-my-pi/pi-tui";
+import type { KeyId } from "../../config/keybindings";
+import type { SessionObserverRegistry } from "../session-observer-registry";
+export declare class SessionObserverOverlayComponent extends Container {
+    #private;
+    constructor(registry: SessionObserverRegistry, onDone: () => void, observeKeys: KeyId[]);
+    render(width: number): string[];
+    /** Rebuild content from live registry data */
+    refreshFromRegistry(): void;
+    handleInput(keyData: string): void;
+}

package/dist/types/modes/components/session-selector.d.ts

@@ -0,0 +1,30 @@
+import { type Component, Container } from "@oh-my-pi/pi-tui";
+import type { SessionInfo } from "../../session/session-manager";
+/**
+ * Custom session list component with multi-line items and search
+ */
+declare class SessionList implements Component {
+    #private;
+    private readonly allSessions;
+    private readonly showCwd;
+    onSelect?: (sessionPath: string) => void;
+    onCancel?: () => void;
+    onExit: () => void;
+    onDeleteRequest?: (session: SessionInfo) => void;
+    constructor(allSessions: SessionInfo[], showCwd?: boolean);
+    removeSession(sessionPath: string): void;
+    invalidate(): void;
+    render(width: number): string[];
+    handleInput(keyData: string): void;
+}
+/**
+ * Component that renders a session selector with optional confirmation dialog
+ */
+export declare class SessionSelectorComponent extends Container {
+    #private;
+    constructor(sessions: SessionInfo[], onSelect: (sessionPath: string) => void, onCancel: () => void, onExit: () => void, onDelete?: (session: SessionInfo) => Promise<boolean>);
+    setOnRequestRender(callback: () => void): void;
+    handleInput(keyData: string): void;
+    getSessionList(): SessionList;
+}
+export {};

package/dist/types/modes/components/settings-defs.d.ts

@@ -0,0 +1,50 @@
+/**
+ * UI adapter over the schema. Reads `ui.options` declared inline in
+ * settings-schema.ts and produces typed widget definitions for the
+ * settings selector.
+ *
+ * To add a new setting to the UI: declare it in `settings-schema.ts`
+ * with a `ui` block. If it needs a submenu, include `options: [...]`
+ * (or `options: "runtime"` for runtime-injected lists like themes).
+ */
+import { type SettingPath, type SettingTab, type SubmenuOption } from "../../config/settings-schema";
+export type SettingValue = boolean | string;
+interface BaseSettingDef {
+    path: SettingPath;
+    label: string;
+    description: string;
+    tab: SettingTab;
+    /**
+     * 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";
+}
+export type SettingDef = BooleanSettingDef | EnumSettingDef | SubmenuSettingDef | TextInputSettingDef;
+/** Get all setting definitions with UI */
+export declare function getAllSettingDefs(): SettingDef[];
+/** Get settings for a specific tab */
+export declare function getSettingsForTab(tab: SettingTab): SettingDef[];
+/** Get a setting definition by path */
+export declare function getSettingDef(path: SettingPath): SettingDef | undefined;
+/** Get default value for display */
+export declare function getDisplayDefault(path: SettingPath): string;
+export {};

package/dist/types/modes/components/settings-selector.d.ts

@@ -0,0 +1,54 @@
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Effort } from "@oh-my-pi/pi-ai";
+import { Container, SettingsList } from "@oh-my-pi/pi-tui";
+import { type SettingPath } from "../../config/settings";
+import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../config/settings-schema";
+import { PluginSettingsComponent } from "./plugin-settings";
+/**
+ * Dynamic context for settings that need runtime data.
+ * Some settings (like thinking level) are managed by the session, not Settings.
+ */
+export interface SettingsRuntimeContext {
+    /** Available thinking levels (from session) */
+    availableThinkingLevels: Effort[];
+    /** Current thinking level (from session) */
+    thinkingLevel: ThinkingLevel | undefined;
+    /** Available themes */
+    availableThemes: string[];
+    /** Working directory for plugins tab */
+    cwd: string;
+}
+/** Status line settings subset for preview */
+export interface StatusLinePreviewSettings {
+    preset?: StatusLinePreset;
+    leftSegments?: StatusLineSegmentId[];
+    rightSegments?: StatusLineSegmentId[];
+    separator?: StatusLineSeparatorStyle;
+    sessionAccent?: boolean;
+}
+export interface SettingsCallbacks {
+    /** Called when any setting value changes */
+    onChange: (path: SettingPath, 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;
+    /** 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 extends Container {
+    #private;
+    private readonly context;
+    private readonly callbacks;
+    constructor(context: SettingsRuntimeContext, callbacks: SettingsCallbacks);
+    getFocusComponent(): SettingsList | PluginSettingsComponent;
+    handleInput(data: string): void;
+}

package/dist/types/modes/components/show-images-selector.d.ts

@@ -0,0 +1,9 @@
+import { Container, SelectList } from "@oh-my-pi/pi-tui";
+/**
+ * Component that renders a show images selector with borders
+ */
+export declare class ShowImagesSelectorComponent extends Container {
+    #private;
+    constructor(currentValue: boolean, onSelect: (show: boolean) => void, onCancel: () => void);
+    getSelectList(): SelectList;
+}

package/dist/types/modes/components/skill-message.d.ts

@@ -0,0 +1,9 @@
+import { Container } from "@oh-my-pi/pi-tui";
+import type { CustomMessage, SkillPromptDetails } from "../../session/messages";
+export declare class SkillMessageComponent extends Container {
+    #private;
+    private readonly message;
+    constructor(message: CustomMessage<SkillPromptDetails>);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+}

package/dist/types/modes/components/status-line/context-thresholds.d.ts

@@ -0,0 +1,4 @@
+import type { ThemeColor } from "../../../modes/theme/theme";
+export type ContextUsageLevel = "normal" | "warning" | "purple" | "error";
+export declare function getContextUsageLevel(contextPercent: number, contextWindow: number): ContextUsageLevel;
+export declare function getContextUsageThemeColor(level: ContextUsageLevel): ThemeColor;

package/dist/types/modes/components/status-line/git-utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Extract "owner/repo" from a GitHub remote URL.
+ * Handles HTTPS, SSH (scp-style), and git:// protocols.
+ *
+ * @returns "owner/repo" or null if the URL isn't a recognized GitHub remote.
+ */
+export declare function parseGitHubRepo(remoteUrl: string): string | null;
+/**
+ * Extract the branch name from a remote HEAD ref like "origin/main".
+ * Returns the portion after the first "/" or the whole string if no "/" is present.
+ */
+export declare function parseDefaultBranch(ref: string): string;
+export interface PrCacheContext {
+    branch: string;
+    repoId: string | null;
+}
+export declare function createPrCacheContext(branch: string, repoId: string | null): PrCacheContext;
+export declare function isSamePrCacheContext(a: PrCacheContext | undefined, b: PrCacheContext | undefined): boolean;
+export declare function canReuseCachedPr(cachedPr: {
+    number: number;
+    url: string;
+} | null | undefined, cachedContext: PrCacheContext | undefined, currentContext: PrCacheContext | null): boolean;

package/dist/types/modes/components/status-line/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./presets";
+export * from "./segments";
+export * from "./separators";
+export * from "./types";

package/dist/types/modes/components/status-line/presets.d.ts

@@ -0,0 +1,3 @@
+import type { PresetDef, StatusLinePreset } from "./types";
+export declare const STATUS_LINE_PRESETS: Record<StatusLinePreset, PresetDef>;
+export declare function getPreset(name: StatusLinePreset): PresetDef;

package/dist/types/modes/components/status-line/segments.d.ts

@@ -0,0 +1,5 @@
+import type { RenderedSegment, SegmentContext, StatusLineSegment, StatusLineSegmentId } from "./types";
+export type { SegmentContext } from "./types";
+export declare const SEGMENTS: Record<StatusLineSegmentId, StatusLineSegment>;
+export declare function renderSegment(id: StatusLineSegmentId, ctx: SegmentContext): RenderedSegment;
+export declare const ALL_SEGMENT_IDS: StatusLineSegmentId[];

package/dist/types/modes/components/status-line/separators.d.ts

@@ -0,0 +1,3 @@
+import type { Theme } from "../../../modes/theme/theme";
+import type { SeparatorDef, StatusLineSeparatorStyle } from "./types";
+export declare function getSeparator(style: StatusLineSeparatorStyle, theme: Theme): SeparatorDef;

package/dist/types/modes/components/status-line/token-rate.d.ts

@@ -0,0 +1,10 @@
+type MaybeAssistantMessage = {
+    role?: string;
+    timestamp?: number;
+    duration?: number;
+    usage?: {
+        output?: number;
+    };
+};
+export declare function calculateTokensPerSecond(messages: ReadonlyArray<MaybeAssistantMessage>, isStreaming: boolean, nowMs?: number): number | null;
+export {};

package/dist/types/modes/components/status-line/types.d.ts

@@ -0,0 +1,70 @@
+import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../../config/settings-schema";
+import type { AgentSession } from "../../../session/agent-session";
+import type { StatusLineSegmentOptions, StatusLineSettings } from "../status-line";
+export type { StatusLinePreset, StatusLineSegmentId, StatusLineSegmentOptions, StatusLineSeparatorStyle, StatusLineSettings, };
+export type RGB = readonly [number, number, number];
+export interface SegmentContext {
+    session: AgentSession;
+    width: number;
+    options: StatusLineSegmentOptions;
+    planMode: {
+        enabled: boolean;
+        paused: boolean;
+    } | null;
+    loopMode: {
+        enabled: boolean;
+    } | null;
+    goalMode: {
+        enabled: boolean;
+        paused: boolean;
+    } | null;
+    usageStats: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        premiumRequests: number;
+        cost: number;
+        tokensPerSecond: number | null;
+    };
+    contextPercent: number;
+    contextWindow: number;
+    autoCompactEnabled: boolean;
+    subagentCount: number;
+    sessionStartTime: number;
+    git: {
+        branch: string | null;
+        status: {
+            staged: number;
+            unstaged: number;
+            untracked: number;
+        } | null;
+        pr: {
+            number: number;
+            url: string;
+        } | null;
+    };
+}
+export interface RenderedSegment {
+    content: string;
+    visible: boolean;
+}
+export interface StatusLineSegment {
+    id: StatusLineSegmentId;
+    render(ctx: SegmentContext): RenderedSegment;
+}
+export interface SeparatorDef {
+    left: string;
+    right: string;
+    endCaps?: {
+        left: string;
+        right: string;
+        useBgAsFg: boolean;
+    };
+}
+export interface PresetDef {
+    leftSegments: StatusLineSegmentId[];
+    rightSegments: StatusLineSegmentId[];
+    separator: StatusLineSeparatorStyle;
+    segmentOptions?: StatusLineSegmentOptions;
+}

package/dist/types/modes/components/status-line-segment-editor.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Status Line Segment Editor
+ *
+ * Interactive component for configuring status line segments.
+ * - Three-column layout: Left | Right | Disabled
+ * - Space: Toggle segment visibility (disabled ↔ left)
+ * - Tab: Cycle segment between columns (left → right → disabled → left)
+ * - Shift+J/K: Reorder segment within column
+ * - Live preview shown in the actual status line above
+ */
+import { Container } from "@oh-my-pi/pi-tui";
+import type { StatusLineSegmentId } from "../../config/settings-schema";
+export interface SegmentEditorCallbacks {
+    onSave: (leftSegments: StatusLineSegmentId[], rightSegments: StatusLineSegmentId[]) => void;
+    onCancel: () => void;
+    onPreview?: (leftSegments: StatusLineSegmentId[], rightSegments: StatusLineSegmentId[]) => void;
+}
+export declare class StatusLineSegmentEditorComponent extends Container {
+    #private;
+    private readonly callbacks;
+    constructor(currentLeft: StatusLineSegmentId[], currentRight: StatusLineSegmentId[], callbacks: SegmentEditorCallbacks);
+    handleInput(data: string): void;
+    render(width: number): string[];
+}

package/dist/types/modes/components/status-line.d.ts

@@ -0,0 +1,61 @@
+import { type Component } from "@oh-my-pi/pi-tui";
+import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../config/settings-schema";
+import type { AgentSession } from "../../session/agent-session";
+export interface StatusLineSegmentOptions {
+    model?: {
+        showThinkingLevel?: boolean;
+    };
+    path?: {
+        abbreviate?: boolean;
+        maxLength?: number;
+        stripWorkPrefix?: boolean;
+    };
+    git?: {
+        showBranch?: boolean;
+        showStaged?: boolean;
+        showUnstaged?: boolean;
+        showUntracked?: boolean;
+    };
+    time?: {
+        format?: "12h" | "24h";
+        showSeconds?: boolean;
+    };
+}
+export interface StatusLineSettings {
+    preset?: StatusLinePreset;
+    leftSegments?: StatusLineSegmentId[];
+    rightSegments?: StatusLineSegmentId[];
+    separator?: StatusLineSeparatorStyle;
+    segmentOptions?: StatusLineSegmentOptions;
+    showHookStatus?: boolean;
+    sessionAccent?: boolean;
+}
+export declare class StatusLineComponent implements Component {
+    #private;
+    private readonly session;
+    constructor(session: AgentSession);
+    updateSettings(settings: StatusLineSettings): void;
+    setAutoCompactEnabled(enabled: boolean): void;
+    setSubagentCount(count: number): void;
+    setSessionStartTime(time: number): void;
+    setPlanModeStatus(status: {
+        enabled: boolean;
+        paused: boolean;
+    } | undefined): void;
+    setLoopModeStatus(status: {
+        enabled: boolean;
+    } | undefined): void;
+    setGoalModeStatus(status: {
+        enabled: boolean;
+        paused: boolean;
+    } | undefined): void;
+    setHookStatus(key: string, text: string | undefined): void;
+    watchBranch(onBranchChange: () => void): void;
+    dispose(): void;
+    invalidate(): void;
+    getTopBorder(width: number): {
+        content: string;
+        width: number;
+    };
+    render(width: number): string[];
+}

package/dist/types/modes/components/theme-selector.d.ts

@@ -0,0 +1,10 @@
+import { Container, SelectList } from "@oh-my-pi/pi-tui";
+/**
+ * Component that renders a theme selector.
+ * Themes must be pre-loaded and passed to the constructor.
+ */
+export declare class ThemeSelectorComponent extends Container {
+    #private;
+    constructor(currentTheme: string, themes: string[], onSelect: (themeName: string) => void, onCancel: () => void, onPreview: (themeName: string) => void);
+    getSelectList(): SelectList;
+}

package/dist/types/modes/components/thinking-selector.d.ts

@@ -0,0 +1,10 @@
+import type { Effort } from "@oh-my-pi/pi-ai";
+import { Container, SelectList } from "@oh-my-pi/pi-tui";
+/**
+ * Component that renders a thinking level selector with borders
+ */
+export declare class ThinkingSelectorComponent extends Container {
+    #private;
+    constructor(currentLevel: Effort, availableLevels: Effort[], onSelect: (level: Effort) => void, onCancel: () => void);
+    getSelectList(): SelectList;
+}

package/dist/types/modes/components/todo-reminder.d.ts

@@ -0,0 +1,13 @@
+import { Container } from "@oh-my-pi/pi-tui";
+import type { TodoItem } from "../../tools/todo-write";
+/**
+ * Component that renders a todo completion reminder notification.
+ * Shows when the agent stops with incomplete todos.
+ */
+export declare class TodoReminderComponent extends Container {
+    #private;
+    private readonly todos;
+    private readonly attempt;
+    private readonly maxAttempts;
+    constructor(todos: TodoItem[], attempt: number, maxAttempts: number);
+}

package/dist/types/modes/components/tool-execution.d.ts

@@ -0,0 +1,53 @@
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { Container, type TUI } from "@oh-my-pi/pi-tui";
+export interface ToolExecutionOptions {
+    showImages?: boolean;
+    editFuzzyThreshold?: number;
+    editAllowFuzzy?: boolean;
+    hashlineAutoDropPureInsertDuplicates?: boolean;
+}
+export interface ToolExecutionHandle {
+    updateArgs(args: any, toolCallId?: string): void;
+    updateResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+            data?: string;
+            mimeType?: string;
+        }>;
+        details?: any;
+        isError?: boolean;
+    }, isPartial?: boolean, toolCallId?: string): void;
+    setArgsComplete(toolCallId?: string): void;
+    setExpanded(expanded: boolean): void;
+}
+/**
+ * Component that renders a tool call with its result (updateable)
+ */
+export declare class ToolExecutionComponent extends Container {
+    #private;
+    constructor(toolName: string, args: any, options: ToolExecutionOptions | undefined, tool: AgentTool | undefined, ui: TUI, cwd?: string, _toolCallId?: string);
+    updateArgs(args: any, _toolCallId?: string): void;
+    /**
+     * Signal that args are complete (tool is about to execute).
+     * This triggers an immediate final diff computation for edit-like tools.
+     */
+    setArgsComplete(_toolCallId?: string): void;
+    updateResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+            data?: string;
+            mimeType?: string;
+        }>;
+        details?: any;
+        isError?: boolean;
+    }, isPartial?: boolean, _toolCallId?: string): void;
+    /**
+     * Stop spinner animation and cleanup resources.
+     */
+    stopAnimation(): void;
+    setExpanded(expanded: boolean): void;
+    setShowImages(show: boolean): void;
+    invalidate(): void;
+}

package/dist/types/modes/components/tree-selector.d.ts

@@ -0,0 +1,31 @@
+import { type Component, Container } from "@oh-my-pi/pi-tui";
+import type { TreeFilterMode } from "../../config/settings-schema";
+import type { SessionTreeNode } from "../../session/session-manager";
+/** Filter mode for tree display */
+type FilterMode = TreeFilterMode;
+declare class TreeList implements Component {
+    #private;
+    private readonly currentLeafId;
+    private readonly maxVisibleLines;
+    onSelect?: (entryId: string) => void;
+    onCancel?: () => void;
+    onLabelEdit?: (entryId: string, currentLabel: string | undefined) => void;
+    constructor(tree: SessionTreeNode[], currentLeafId: string | null, maxVisibleLines: number, initialFilterMode?: FilterMode, initialSelectedId?: string);
+    invalidate(): void;
+    getSearchQuery(): string;
+    getSelectedNode(): SessionTreeNode | undefined;
+    updateNodeLabel(entryId: string, label: string | undefined): void;
+    render(width: number): string[];
+    handleInput(keyData: string): void;
+}
+/**
+ * Component that renders a session tree selector for navigation
+ */
+export declare class TreeSelectorComponent extends Container {
+    #private;
+    private readonly onLabelChangeCallback?;
+    constructor(tree: SessionTreeNode[], currentLeafId: string | null, terminalHeight: number, onSelect: (entryId: string) => void, onCancel: () => void, onLabelChangeCallback?: ((entryId: string, label: string | undefined) => void) | undefined, initialFilterMode?: FilterMode);
+    handleInput(keyData: string): void;
+    getTreeList(): TreeList;
+}
+export {};

package/dist/types/modes/components/ttsr-notification.d.ts

@@ -0,0 +1,13 @@
+import { Container } from "@oh-my-pi/pi-tui";
+import type { Rule } from "../../capability/rule";
+/**
+ * Component that renders a TTSR (Time Traveling Stream Rules) notification.
+ * Shows when a rule violation is detected and the stream is being rewound.
+ */
+export declare class TtsrNotificationComponent extends Container {
+    #private;
+    private readonly rules;
+    constructor(rules: Rule[]);
+    setExpanded(expanded: boolean): void;
+    isExpanded(): boolean;
+}

package/dist/types/modes/components/user-message-selector.d.ts

@@ -0,0 +1,28 @@
+import { type Component, Container } from "@oh-my-pi/pi-tui";
+interface UserMessageItem {
+    id: string;
+    text: string;
+    timestamp?: string;
+}
+/**
+ * Custom user message list component with selection
+ */
+declare class UserMessageList implements Component {
+    #private;
+    private readonly messages;
+    onSelect?: (entryId: string) => void;
+    onCancel?: () => void;
+    constructor(messages: UserMessageItem[]);
+    invalidate(): void;
+    render(width: number): string[];
+    handleInput(keyData: string): void;
+}
+/**
+ * Component that renders a user message selector for branching
+ */
+export declare class UserMessageSelectorComponent extends Container {
+    #private;
+    constructor(messages: UserMessageItem[], onSelect: (entryId: string) => void, onCancel: () => void);
+    getMessageList(): UserMessageList;
+}
+export {};

package/dist/types/modes/components/user-message.d.ts

@@ -0,0 +1,8 @@
+import { Container } from "@oh-my-pi/pi-tui";
+/**
+ * Component that renders a user message
+ */
+export declare class UserMessageComponent extends Container {
+    constructor(text: string, synthetic?: boolean);
+    render(width: number): string[];
+}

package/dist/types/modes/components/visual-truncate.d.ts

@@ -0,0 +1,19 @@
+export interface VisualTruncateResult {
+    /** The visual lines to display */
+    visualLines: string[];
+    /** Number of visual lines that were skipped (hidden) */
+    skippedCount: number;
+}
+/**
+ * Truncate text to a maximum number of visual lines (from the end).
+ * This accounts for line wrapping based on terminal width.
+ *
+ * @param text - The text content (may contain newlines)
+ * @param maxVisualLines - Maximum number of visual lines to show
+ * @param width - Terminal/render width
+ * @param paddingX - Horizontal padding for Text component (default 0).
+ *                   Use 0 when result will be placed in a Box (Box adds its own padding).
+ *                   Use 1 when result will be placed in a plain Container.
+ * @returns The truncated visual lines and count of skipped lines
+ */
+export declare function truncateToVisualLines(text: string, maxVisualLines: number, width: number, paddingX?: number): VisualTruncateResult;

package/dist/types/modes/components/welcome.d.ts

@@ -0,0 +1,33 @@
+import { type Component } from "@oh-my-pi/pi-tui";
+export interface RecentSession {
+    name: string;
+    timeAgo: string;
+}
+export interface LspServerInfo {
+    name: string;
+    status: "ready" | "error" | "connecting";
+    fileTypes: string[];
+}
+/**
+ * Premium welcome screen with block-based OMP logo and two-column layout.
+ */
+export declare class WelcomeComponent implements Component {
+    #private;
+    private readonly version;
+    private modelName;
+    private providerName;
+    private recentSessions;
+    private lspServers;
+    constructor(version: string, modelName: string, providerName: string, recentSessions?: RecentSession[], lspServers?: LspServerInfo[]);
+    invalidate(): void;
+    /**
+     * Play a one-shot intro that sweeps the gradient through every phase
+     * before settling on the resting frame. Safe to call multiple times —
+     * subsequent calls reset and replay.
+     */
+    playIntro(requestRender: () => void): void;
+    setModel(modelName: string, providerName: string): void;
+    setRecentSessions(sessions: RecentSession[]): void;
+    setLspServers(servers: LspServerInfo[]): void;
+    render(termWidth: number): string[];
+}

package/dist/types/modes/controllers/btw-controller.d.ts

@@ -0,0 +1,10 @@
+import type { InteractiveModeContext } from "../types";
+export declare class BtwController {
+    #private;
+    private readonly ctx;
+    constructor(ctx: InteractiveModeContext);
+    hasActiveRequest(): boolean;
+    handleEscape(): boolean;
+    dispose(): void;
+    start(question: string): Promise<void>;
+}