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

package/dist/types/overlays/move-overlay.d.ts

@@ -0,0 +1,39 @@
+/**
+ * `/move` overlay: a path input with live directory autocomplete.
+ *
+ * Rendered as a centered modal via `showHookCustom(..., { overlay: true })`.
+ * The user types a path, Tab autocompletes the highlighted directory, and Enter
+ * confirms — yielding the resolved directory string (or `undefined` on cancel).
+ */
+import { type Component, type Focusable } from "../index.js";
+export interface MoveOverlayResult {
+    directory: string;
+}
+/** Directory suggestion displayed by the move dialog. */
+export interface MoveDirectoryEntry {
+    /** Full absolute path. */
+    value: string;
+    /** Display label (basename + trailing slash). */
+    label: string;
+}
+/** Directory autocomplete supplied by the host. */
+export interface MoveDirectorySource {
+    search(prefix: string, cwd: string, max: number): MoveDirectoryEntry[];
+}
+/**
+ * Overlay component for `/move`: a single-line path input with a live-filtered
+ * list of matching directories. Tab accepts the highlighted suggestion; Enter
+ * confirms the current input (or the highlighted suggestion if the input is
+ * empty); Escape cancels.
+ */
+export declare class MoveOverlay implements Component, Focusable {
+    #private;
+    constructor(cwd: string, done: (result: MoveOverlayResult | undefined) => void, source: MoveDirectorySource);
+    get focused(): boolean;
+    set focused(value: boolean);
+    setUseTerminalCursor(useTerminalCursor: boolean): void;
+    pasteText(text: string): void;
+    handleInput(data: string): void;
+    render(width: number): readonly string[];
+    invalidate(): void;
+}

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

@@ -0,0 +1,41 @@
+import { type SgrMouseEvent } from "../index.js";
+import { OverlayPanel } from "../chrome/overlay-box.js";
+/** Credential presence and provenance needed by the provider picker. */
+export interface OAuthSelectorAuthSource {
+    has(providerId: string): boolean;
+    hasAuth(providerId: string): boolean;
+    getCredentialOrigin(providerId: string): {
+        kind: "runtime" | "config" | "oauth" | "api_key" | "env" | "fallback";
+        envVar?: string;
+    } | undefined;
+}
+/**
+ * Component that renders an OAuth provider selector.
+ */
+export declare class OAuthSelectorComponent extends OverlayPanel {
+    #private;
+    constructor(mode: "login" | "logout", authStorage: OAuthSelectorAuthSource, onSelect: (providerId: string) => void, onCancel: () => void, options?: {
+        disabledProviders?: readonly string[];
+        validateAuth?: (providerId: string) => Promise<boolean>;
+        requestRender?: () => void;
+    });
+    stopValidation(): void;
+    /**
+     * Fit the selector into `lines` rendered rows by shrinking the visible list
+     * window (the window is centered on the selection, so the selected row is
+     * always visible at any height). Prefers keeping the full chrome — borders,
+     * spacers, title, search status — but sacrifices the trailing spacer/border
+     * (clipped by the host) before dropping below three visible rows.
+     */
+    setMaxHeight(lines: number): void;
+    handleInput(keyData: string): void;
+    /** Move the selection one step for a wheel notch (clamped, no wrap). */
+    handleWheel(delta: -1 | 1): void;
+    /**
+     * Route an SGR mouse report at component-local coordinates. Provider rows
+     * start LIST_ROW_OFFSET lines into the render; the ScrollView window shows
+     * #visibleCount rows from #scrollStart. Wheel moves the selection, motion
+     * drives the hover band, and a left click selects and confirms like Enter.
+     */
+    routeMouse(event: SgrMouseEvent, line: number, _col: number): void;
+}

package/dist/types/overlays/omfg-panel.d.ts

@@ -0,0 +1,20 @@
+import { type TUI } from "../index.js";
+import { OverlayPanel } from "../chrome/overlay-box.js";
+export type OmfgPanelState = "generating" | "validating" | "confirming" | "saving" | "saved" | "rejected" | "aborted" | "error";
+interface OmfgPanelComponentOptions {
+    complaint: string;
+    tui: TUI;
+}
+export declare class OmfgPanelComponent extends OverlayPanel {
+    #private;
+    constructor(options: OmfgPanelComponentOptions);
+    appendDraft(delta: string): void;
+    setRule(text: string): void;
+    setStatus(state: OmfgPanelState, status: string): void;
+    markSaved(path: string): void;
+    markRejected(): void;
+    markAborted(): void;
+    markError(message: string): void;
+    close(): void;
+}
+export {};

package/dist/types/overlays/pause-screen.d.ts

@@ -0,0 +1,43 @@
+import { type Component, type OverlayFocusOwner, type OverlayHandle, type OverlayOptions } from "../index.js";
+/**
+ * Slice of `InteractiveModeContext` the pause screen drives. Narrow so tests
+ * can exercise the full engage → hold → release lifecycle without a real TUI.
+ */
+export interface PauseScreenHost {
+    ui: {
+        showOverlay(component: Component, options?: OverlayOptions): OverlayHandle;
+        setFocus(component: Component): void;
+        requestRender(): void;
+        readonly terminal: {
+            readonly rows: number;
+        };
+    };
+    showStatus(message: string, options?: {
+        dim?: boolean;
+    }): void;
+    readonly sessionName?: string;
+}
+/**
+ * Paint the pause scene as exactly `height` rows, vertically centered.
+ * Exported for tests.
+ */
+export declare function renderPauseScreen(width: number, height: number, elapsedMs: number, sessionName?: string): string[];
+/** Fullscreen overlay component; resolves {@link run} when a resume key lands. */
+export declare class PauseScreenComponent implements Component, OverlayFocusOwner {
+    #private;
+    readonly host: PauseScreenHost;
+    constructor(host: PauseScreenHost);
+    /** Start the clock; resolves once the user asks to resume. */
+    run(): Promise<void>;
+    dispose(): void;
+    ownsOverlayFocusTarget(component: Component): boolean;
+    handleInput(data: string): void;
+    render(width: number): readonly string[];
+}
+/**
+ * Engage the global pause gate and hold the fullscreen pause screen until the
+ * user resumes. No-op when the gate is already engaged. Always releases the
+ * gate on the way out (including teardown throws) — a leaked pause would
+ * freeze every agent in the process with no UI left to release it.
+ */
+export declare function runPauseScreen(host: PauseScreenHost): Promise<void>;

package/dist/types/overlays/plan-review-overlay.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Fullscreen plan-review overlay. The overlay owns its entire content: the plan
+ * is split into sections (preamble + one per heading), each rendered through its
+ * own {@link Markdown} and windowed by a {@link ScrollView}, while the approval
+ * options (plus the optional model-tier slider) sit beneath inside the same
+ * outlined box — one self-contained surface in the spirit of the `/copy` picker.
+ *
+ * When the terminal is wide enough and the plan has ≥2 headings, a Contents
+ * sidebar appears: it tracks the scrolled section with an accent "glow", and —
+ * when focused — lets the operator jump between sections, delete a section
+ * (with undo), and annotate sections with feedback that feeds the Refine loop.
+ *
+ * Focus regions (`toc`/`body`/`actions`) cycle with Tab/Shift+Tab; arrows move
+ * within the focused region and step left into the sidebar. The default focus is
+ * `actions`, so the muscle memory of the old single-target overlay carries over:
+ * ↑/↓ select options, Enter confirms, ←/→ drives the slider when there is no
+ * sidebar, g/G + PgUp/PgDn scroll, and the external-editor key opens the plan.
+ */
+import { type Component } from "../index.js";
+import type { HookSelectorSlider } from "./hook-selector.js";
+/** Serializable annotations retained by the plan-review owner between overlays. */
+export interface PlanReviewAnnotationState {
+    annotations: Array<{
+        section: {
+            index: number;
+            title: string;
+            /** Heading ancestry from the document root, when emitted by this overlay. */
+            path?: string[];
+            /** Hash of the section source, used to reject ambiguous moved headings. */
+            contentHash?: string;
+        };
+        target: {
+            kind: "section";
+        } | {
+            kind: "line";
+            row: number;
+            context: string;
+            contextTruncated?: boolean;
+        };
+        note: string;
+    }>;
+}
+export interface PlanReviewOverlayCallbacks {
+    /** Invoked with the chosen option label (never a disabled one). */
+    onPick: (label: string) => void;
+    /** Invoked on Esc / cancel. */
+    onCancel: () => void;
+    /** Invoked with the current full plan text when the copy hotkey is pressed. */
+    onCopyPlan?: (content: string) => void | Promise<void>;
+    /** Invoked when the external-editor key is pressed (overlay stays open). */
+    onExternalEditor?: () => void;
+    /** Invoked when the external-editor key edits the active annotation draft. */
+    onAnnotationExternalEditor?: (draft: string, commit: (text: string | null) => void) => void;
+    /** Invoked with the new full plan text after an in-overlay delete/undo. */
+    onPlanEdited?: (content: string) => void;
+    /** Invoked with the Refine feedback markdown whenever annotations change. */
+    onFeedbackChange?: (feedback: string) => void;
+    /** Invoked with a serializable annotation snapshot whenever annotations change. */
+    onAnnotationStateChange?: (state: PlanReviewAnnotationState) => void;
+}
+export interface PlanReviewOverlayOptions {
+    /** Prompt rendered above the options (e.g. "Plan mode - next step"). */
+    promptTitle?: string;
+    options: string[];
+    /** Indices into `options` that render dimmed and cannot be selected. */
+    disabledIndices?: number[];
+    /** Trailing footer hint (cancel hint); the overlay prepends dynamic help. */
+    helpText?: string;
+    /** Initially highlighted option index. */
+    initialIndex?: number;
+    /** Optional model-tier slider rendered between the plan body and options. */
+    slider?: HookSelectorSlider;
+    /** Display label for the external-editor key, surfaced in the footer help. */
+    externalEditorLabel?: string;
+    /** Serializable annotations restored into this overlay instance. */
+    annotationState?: PlanReviewAnnotationState;
+}
+export declare class PlanReviewOverlay implements Component {
+    #private;
+    private readonly callbacks;
+    constructor(planContent: string, options: PlanReviewOverlayOptions, callbacks: PlanReviewOverlayCallbacks);
+    invalidate(): void;
+    /** Swap the displayed plan (e.g. after an external-editor round-trip) and
+     *  reset scroll/focus so the operator starts at the top. Does not emit
+     *  `onPlanEdited` (the editor round-trip already persisted the file). */
+    setPlanContent(planContent: string): void;
+    handleInput(keyData: string): void;
+    render(width: number): readonly string[];
+}

package/dist/types/overlays/plan-save-overlay.d.ts

@@ -0,0 +1,19 @@
+import { type Component, type Focusable } from "../index.js";
+/** A confirmed destination chosen from {@link PlanSaveOverlay}. */
+export interface PlanSaveOverlayResult {
+    path: string;
+}
+/** Collects a destination path before saving a plan and starting a new session. */
+export declare class PlanSaveOverlay implements Component, Focusable {
+    #private;
+    constructor(suggestedPath: string, done: (result: PlanSaveOverlayResult | undefined) => void);
+    get focused(): boolean;
+    set focused(value: boolean);
+    /** Replaces the dimmed path accepted when the operator submits an empty input. */
+    setSuggestedPath(path: string): void;
+    handleInput(data: string): void;
+    /** Routes enhanced clipboard pastes into the path input. */
+    pasteText(text: string): void;
+    invalidate(): void;
+    render(width: number): readonly string[];
+}

package/dist/types/overlays/plan-toc.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Pure heading/section parser for the plan-review overlay. It splits a plan's
+ * markdown into a flat list of sections — a leading preamble (text before the
+ * first heading) followed by one entry per ATX heading — preserving the exact
+ * source bytes of each section so the overlay can render, reorder-free delete,
+ * and round-trip the document without a full markdown re-render.
+ *
+ * No TUI dependencies: this module is unit-tested in isolation.
+ */
+export interface PlanSection {
+    /** `0` = preamble (no heading, no ToC entry); `1..6` = heading depth. */
+    level: number;
+    /** Plain-text heading label with inline markdown lightly stripped. */
+    title: string;
+    /** Exact source slice for this section, including its trailing newline(s). */
+    raw: string;
+}
+/**
+ * Collapse inline markdown emphasis/link/code syntax to readable text. This is
+ * a deliberately light strip (not a full markdown render) just so ToC entries
+ * read cleanly — `**Goal** & [docs](x)` becomes `Goal & docs`.
+ */
+export declare function stripInlineMarkdown(text: string): string;
+/**
+ * Split `text` into preamble + heading sections. `#` characters inside fenced
+ * code blocks are never treated as headings. Concatenating every section's
+ * `raw` reproduces the original text exactly.
+ */
+export declare function parsePlanSections(text: string): PlanSection[];
+/**
+ * Concatenate every section's `raw` back into a single document and guarantee a
+ * single trailing newline. Inverse of {@link parsePlanSections} for any input
+ * that already ends with a newline.
+ */
+export declare function joinPlanSections(sections: readonly PlanSection[]): string;
+/**
+ * Indices to remove when deleting `sections[index]`: the heading itself plus
+ * every following section nested deeper than it (its sub-headings). The
+ * preamble (level 0) is never a deletion target and yields an empty span.
+ */
+export declare function sectionDeletionSpan(sections: readonly PlanSection[], index: number): number[];

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

@@ -0,0 +1,28 @@
+/**
+ * Interactive marketplace plugin selector.
+ *
+ * Shows available plugins from all configured marketplaces in a SelectList.
+ * Selecting a plugin triggers installation. Esc cancels.
+ */
+import { SelectList, type SgrMouseEvent } from "../index.js";
+import { OverlayPanel } from "../chrome/overlay-box.js";
+export interface PluginSelectorCallbacks {
+    onSelect: (pluginName: string, marketplace: string, scope?: "user" | "project") => void;
+    onCancel: () => void;
+}
+export interface PluginItem {
+    plugin: {
+        name: string;
+        version?: string;
+        description?: string;
+    };
+    marketplace: string;
+    /** Scope of this entry. When set, appended to the label and forwarded to onSelect. */
+    scope?: "user" | "project";
+}
+export declare class PluginSelectorComponent extends OverlayPanel {
+    #private;
+    constructor(marketplaceCount: number, plugins: PluginItem[], installedIds: Set<string>, callbacks: PluginSelectorCallbacks);
+    getSelectList(): SelectList;
+    routeMouse(event: SgrMouseEvent, line: number, col: number): void;
+}

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

@@ -0,0 +1,180 @@
+/**
+ * Plugin settings UI components.
+ *
+ * Provides a hierarchical settings interface:
+ * - Plugin list (npm plugins + marketplace plugins)
+ *   - Plugin details (enablement, manifest settings, and marketplace metadata)
+ */
+import { Container } from "../index.js";
+import { OverlayPanel } from "../chrome/overlay-box.js";
+/** Setting metadata consumed by the plugin settings UI. */
+export type PluginSettingSchema = {
+    description?: string;
+    secret?: boolean;
+} & ({
+    type: "string";
+    default?: string;
+} | {
+    type: "number";
+    default?: number;
+    min?: number;
+    max?: number;
+} | {
+    type: "boolean";
+    default?: boolean;
+} | {
+    type: "enum";
+    default?: string;
+    values: string[];
+});
+/** Installed runtime plugin fields consumed by the settings UI. */
+export interface InstalledPlugin {
+    name: string;
+    version: string;
+    enabled: boolean;
+    enabledFeatures: string[] | null;
+    manifest: {
+        description?: string;
+        features?: Record<string, {
+            description?: string;
+            default?: boolean;
+        }>;
+        settings?: Record<string, PluginSettingSchema>;
+    };
+}
+/** Installed marketplace metadata consumed by the settings UI. */
+export interface InstalledPluginSummary {
+    id: string;
+    scope: "user" | "project";
+    shadowedBy?: "project";
+    entries: {
+        installPath: string;
+        version: string;
+        installedAt: string;
+        lastUpdated: string;
+        gitCommitSha?: string;
+        enabled?: boolean;
+    }[];
+}
+/** Runtime plugin manager capabilities required by the settings UI. */
+export interface PluginSettingsManager {
+    list(): Promise<InstalledPlugin[]>;
+    getPlugin(name: string, options?: {
+        path?: string;
+    }): Promise<InstalledPlugin | undefined>;
+    getPluginSettings(name: string): Promise<Record<string, unknown>>;
+    setEnabled(name: string, enabled: boolean): Promise<void>;
+    getEnabledFeatures(name: string): Promise<string[] | null>;
+    setEnabledFeatures(name: string, features: string[] | null): Promise<void>;
+    setPluginSetting(name: string, key: string, value: unknown): Promise<void>;
+}
+/** Marketplace manager capabilities required by the settings UI. */
+export interface PluginSettingsMarketplaceManager {
+    listInstalledPlugins(): Promise<InstalledPluginSummary[]>;
+    setPluginEnabled(pluginId: string, enabled: boolean, scope?: "user" | "project"): Promise<void>;
+}
+/** Host-owned managers and plugin identifier parsing. */
+export interface PluginSettingsHost {
+    manager: PluginSettingsManager;
+    createMarketplaceManager(): Promise<PluginSettingsMarketplaceManager>;
+    parsePluginId(id: string): {
+        name: string;
+    } | null;
+}
+/**
+ * Forwards a keystroke to `input`, but cancels via `onCancel` when the user presses Escape.
+ *
+ * Escape is decoded via `matchesKey` rather than a raw `\x1b` compare: inside the
+ * fullscreen settings overlay the kitty keyboard protocol is active (ghostty/kitty),
+ * where the Escape key arrives as the CSI-u sequence `\x1b[27u`, not a bare `\x1b`.
+ * The literal fallbacks preserve legacy single/double-escape on terminals without it.
+ */
+export declare function handleInputOrEscape(data: string, input: {
+    handleInput(data: string): void;
+}, onCancel: () => void): void;
+/**
+ * One row in the unified plugin list. npm and marketplace plugins live in
+ * separate registries with different shapes, so a tagged union keeps both
+ * paths type-safe end-to-end (list rendering, value lookup, detail callback).
+ */
+export type PluginListEntry = {
+    kind: "npm";
+    plugin: InstalledPlugin;
+} | {
+    kind: "marketplace";
+    plugin: InstalledPluginSummary;
+};
+export interface PluginListCallbacks {
+    onNpmSelect: (plugin: InstalledPlugin) => void;
+    onMarketplaceSelect: (plugin: InstalledPluginSummary) => void;
+    onCancel: () => void;
+}
+/**
+ * Shows installed plugins from both registries (npm + marketplace) with
+ * enable/disable status, scope tag, and shadow indicator. Selecting an entry
+ * fans out to the kind-specific detail callback.
+ */
+export declare class PluginListComponent extends OverlayPanel {
+    #private;
+    private readonly entries;
+    constructor(entries: ReadonlyArray<PluginListEntry>, callbacks: PluginListCallbacks);
+    handleInput(data: string): void;
+}
+export interface PluginDetailCallbacks {
+    onEnabledChange: (enabled: boolean) => void;
+    onFeatureChange: (feature: string, enabled: boolean) => void;
+    onConfigChange: (key: string, value: unknown) => void | Promise<void>;
+    /** Schedules a frame after an asynchronous config submission settles. */
+    requestRender?: () => void;
+    onBack: () => void;
+}
+/**
+ * Shows detail settings for a single plugin:
+ * - Enable/disable toggle
+ * - Feature toggles
+ * - Config settings
+ */
+export declare class PluginDetailComponent extends OverlayPanel {
+    #private;
+    private plugin;
+    private readonly manager;
+    private readonly callbacks;
+    constructor(plugin: InstalledPlugin, manager: PluginSettingsManager, callbacks: PluginDetailCallbacks);
+    handleInput(data: string): void;
+}
+export interface MarketplacePluginDetailCallbacks {
+    parsePluginId: PluginSettingsHost["parsePluginId"];
+    onEnabledChange: (enabled: boolean) => void;
+    onConfigChange: (pluginName: string, key: string, value: unknown) => void;
+    /** Schedules a TUI frame after asynchronous manifest settings load. */
+    requestRender?: () => void;
+    onBack: () => void;
+}
+/**
+ * Detail view for a marketplace plugin, including settings declared by its
+ * runtime package and metadata from the installed-plugins registry.
+ */
+export declare class MarketplacePluginDetailComponent extends OverlayPanel {
+    #private;
+    private plugin;
+    private readonly manager;
+    private readonly callbacks;
+    constructor(plugin: InstalledPluginSummary, manager: PluginSettingsManager, callbacks: MarketplacePluginDetailCallbacks);
+    handleInput(data: string): void;
+}
+export interface PluginSettingsCallbacks {
+    onClose: () => void;
+    onPluginChanged: () => void | Promise<void>;
+    /** Schedules a TUI frame after asynchronous plugin data loads. */
+    requestRender?: () => void;
+}
+/**
+ * Top-level plugin settings component.
+ * Manages navigation between plugin list and plugin detail views.
+ */
+export declare class PluginSettingsComponent extends Container {
+    #private;
+    private readonly callbacks;
+    constructor(host: PluginSettingsHost, callbacks: PluginSettingsCallbacks);
+    handleInput(data: string): void;
+}

package/dist/types/overlays/queue-mode-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 queue mode selector with borders
+ */
+export declare class QueueModeSelectorComponent extends OverlayPanel {
+    #private;
+    constructor(currentMode: "all" | "one-at-a-time", onSelect: (mode: "all" | "one-at-a-time") => void, onCancel: () => void);
+    getSelectList(): SelectList;
+    routeMouse(event: SgrMouseEvent, line: number, col: number): void;
+}

package/dist/types/overlays/reset-usage-selector.d.ts

@@ -0,0 +1,23 @@
+import { OverlayPanel } from "../chrome/overlay-box.js";
+/** One account row with its redeemable rate-limit reset credits. */
+export interface ResetUsageAccount {
+    label: string;
+    availableCount: number;
+    target: {
+        credentialId?: number;
+        accountId?: string;
+        email?: string;
+    };
+    active: boolean;
+    error?: string;
+}
+/**
+ * Account picker for `/usage reset`. Lists Codex accounts with their saved
+ * rate-limit reset counts; selecting one redeems a reset. Because a reset is a
+ * scarce, irreversible credit, Enter requires a second press to confirm.
+ */
+export declare class ResetUsageSelectorComponent extends OverlayPanel {
+    #private;
+    constructor(accounts: ResetUsageAccount[], onSelect: (account: ResetUsageAccount) => void, onCancel: () => void);
+    handleInput(keyData: string): void;
+}

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

@@ -0,0 +1,61 @@
+/**
+ * Fullscreen esc-esc rewind selector.
+ *
+ * Replays the current session's branch with {@link ChatTranscriptBuilder} on
+ * the alternate screen (`ui.showOverlay(..., { fullscreen: true })`) and moves
+ * a dotted outline over the rendered transcript block the rewind would land
+ * on, instead of listing user messages in a detached picker. Entries that
+ * render nothing (notices, hidden custom messages, tool results folded into
+ * their call cards) are never outlined: results fold into the turn that
+ * rendered their call so rewinding a turn keeps its tool output, and the rest
+ * are skipped entirely.
+ *
+ * When the outlined turn has sibling branches in the session tree, the region
+ * below the divergence renders as a horizontal strip of half-width columns —
+ * the current path first, each alternate branch beside it — and Left/Right
+ * slide between them with an eased camera animation. Sibling columns are
+ * fully rendered transcripts of that branch's most-recent path, built lazily
+ * and cached per divergence.
+ *
+ * Keys: Up/Down step through rendered items in transcript order (within the
+ * active column when a strip is open), Left/Right slide between branch
+ * variants at a fork and jump between user turns elsewhere, Enter rewinds to
+ * the outlined item, Esc cancels.
+ */
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { type Component, type TUI } from "../index.js";
+import type { MessageRenderer } from "../chat/extension-types.js";
+import type { TranscriptEntryLike as TranscriptEntry } from "../chat/transcript-entry.js";
+/** One alternate branch at a divergence: its root and message path root → most-recent leaf. */
+export interface BranchVariantPath {
+    rootId: string;
+    entries: TranscriptEntry[];
+}
+export interface RewindSelectorDeps {
+    ui: TUI;
+    getTool?: (name: string) => AgentTool | undefined;
+    /** Whether the active registry entry came from a built-in factory. */
+    isBuiltInTool?: (name: string) => boolean;
+    getMessageRenderer?: (customType: string) => MessageRenderer | undefined;
+    cwd: string;
+    hideThinkingBlock?: () => boolean;
+    proseOnlyThinking?: () => boolean;
+    linkTargets?: ReadonlyMap<string, string>;
+    requestRender: () => void;
+    /** Sibling branch paths of `entryId`'s turn (excluding the turn itself). */
+    siblingPaths?: (entryId: string) => BranchVariantPath[];
+    /** Rewind the session to `entryId` (a message entry anywhere in the tree). */
+    onSelect: (entryId: string) => void;
+    onCancel: () => void;
+}
+export declare class RewindSelectorComponent implements Component {
+    #private;
+    private readonly deps;
+    constructor(entries: TranscriptEntry[], deps: RewindSelectorDeps);
+    /** Number of selectable rewind points on the current path; hosts skip mounting when zero. */
+    get targetCount(): number;
+    invalidate(): void;
+    dispose(): void;
+    handleInput(data: string): void;
+    render(width: number): readonly string[];
+}

package/dist/types/overlays/running-subagent-badge.d.ts

@@ -0,0 +1,6 @@
+import type { AgentHubRegistry } from "./agent-hub-types.js";
+export interface RunningSubagentRegistrySource<T extends AgentHubRegistry = AgentHubRegistry> {
+    agentRegistry: T;
+}
+export declare function getRunningSubagentBadgeRegistry<T extends AgentHubRegistry>(collabGuest: RunningSubagentRegistrySource<T> | undefined, localRegistry: T): T;
+export declare function getRunningSubagentBadgeAgentIds(registry: AgentHubRegistry): string[];

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

@@ -0,0 +1,24 @@
+import { type SgrMouseEvent } from "../index.js";
+import { OverlayPanel } from "../chrome/overlay-box.js";
+/** Stored account identity rendered and matched by the session account picker. */
+export interface SessionPinAccount {
+    position: number;
+    credentialId: number;
+    accountId?: string;
+    email?: string;
+    projectId?: string;
+    enterpriseUrl?: string;
+    orgId?: string;
+    orgName?: string;
+    active: boolean;
+    label: string;
+}
+/** Account picker opened by `/session pin` for the current model provider. */
+export declare class SessionAccountSelectorComponent extends OverlayPanel {
+    #private;
+    constructor(providerName: string, accounts: readonly SessionPinAccount[], onSelect: (account: SessionPinAccount) => void, onCancel: () => void);
+    /** Forward keyboard navigation and cancellation when the wrapper owns focus. */
+    handleInput(keyData: string): void;
+    /** Route mouse selection through the title rows into the account list. */
+    routeMouse(event: SgrMouseEvent, line: number, col: number): void;
+}

package/dist/types/overlays/session-info-overlay.d.ts

@@ -0,0 +1,17 @@
+import { type Component } from "../index.js";
+/** Terminal surface needed to size the session info viewport. */
+export interface SessionInfoOverlayHost {
+    readonly terminal: {
+        readonly rows: number;
+    };
+}
+/** Focused, dismissible `/session` information panel. */
+export declare class SessionInfoOverlay implements Component {
+    #private;
+    constructor(host: SessionInfoOverlayHost, info: string, onClose: () => void);
+    handleInput(data: string): void;
+    invalidate(): void;
+    setIgnoreTight(ignore: boolean): this;
+    dispose(): void;
+    render(width: number): readonly string[];
+}