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

package/dist/types/overlays/ask-dialog.d.ts

@@ -0,0 +1,88 @@
+import { type Component, type TUI } from "../index.js";
+/** One selectable answer in an ask dialog. */
+export interface ExtensionAskDialogOption {
+    label: string;
+    description?: string;
+    preview?: string;
+}
+/** Question and answer choices displayed by the ask dialog. */
+export interface ExtensionAskDialogQuestion {
+    id: string;
+    question: string;
+    header?: string;
+    options: ExtensionAskDialogOption[];
+    multi?: boolean;
+    recommended?: number;
+}
+/** Submitted answer to one dialog question. */
+export interface ExtensionAskDialogResultItem {
+    id: string;
+    question: string;
+    options: string[];
+    multi: boolean;
+    selectedOptions: string[];
+    customInput?: string;
+    note?: string;
+    timedOut?: boolean;
+}
+/** Answers submitted from the dialog. */
+export interface ExtensionAskDialogSubmitResult {
+    kind: "submit";
+    results: ExtensionAskDialogResultItem[];
+}
+/** Request to discuss the question instead of answering it. */
+export interface ExtensionAskDialogChatResult {
+    kind: "chat";
+}
+/** Completed dialog action, distinct from cancellation. */
+export type ExtensionAskDialogResult = ExtensionAskDialogSubmitResult | ExtensionAskDialogChatResult;
+/** Bound a prompt editor title to a fixed row/width budget so long or
+ *  multi-line questions stay usable inside the small prompt overlay. */
+export declare function boundPromptTitle(prefix: string, question: string): string;
+interface AskDialogCallbacks {
+    onSubmit(result: ExtensionAskDialogSubmitResult): void;
+    onCancel(): void;
+    onPrompt(title: string, prefill?: string): Promise<string | undefined>;
+}
+interface AskDialogInputGuard {
+    isBlocked(): boolean;
+    handleInput(keyData: string): void;
+    hint: string;
+    /** Mirror the guard's blocked state onto the proxied draft surface each
+     *  render, so a draft that owns input shows a visible insertion cursor even
+     *  though this dialog holds TUI focus. */
+    syncPresentation?(): void;
+}
+interface AskDialogOptions {
+    timeout?: number;
+    onTimeout?: () => void;
+    tui?: TUI;
+    inputGuard?: AskDialogInputGuard;
+}
+/**
+ * Coerce untrusted dialog questions into a render-safe shape. The live ask
+ * dialog is reached from the public `askDialog` extension surface and from
+ * streamed tool args, where a question entry can arrive with a missing or
+ * non-string `question` field. The render helpers (`replaceTabs`,
+ * `renderQuestionTitle`, `questionTabLabel`) assume strings, so a malformed
+ * entry throws and takes down the whole TUI render loop. Mirrors
+ * `normalizeRenderQuestions` on the transcript path.
+ */
+export declare function normalizeDialogQuestions(questions: ExtensionAskDialogQuestion[]): ExtensionAskDialogQuestion[];
+export declare class AskDialogComponent implements Component {
+    #private;
+    private readonly callbacks;
+    private readonly options;
+    constructor(questions: ExtensionAskDialogQuestion[], callbacks: AskDialogCallbacks, options?: AskDialogOptions);
+    invalidate(): void;
+    dispose(): void;
+    /**
+     * Toggle truncated question headers and option descriptions. Returns false
+     * when there is nothing to expand so the global Ctrl+O listener can still
+     * expand transcript tools.
+     */
+    toggleQuestionExpansion(): boolean;
+    handleInput(keyData: string): void;
+    render(width: number): readonly string[];
+}
+export {};

package/dist/types/overlays/bordered-loader.d.ts

@@ -0,0 +1,11 @@
+import { Container, type TUI } from "../index.js";
+import type { Theme } from "../theme/theme.js";
+/** Loader wrapped with borders for hook UI */
+export declare class BorderedLoader extends Container {
+    #private;
+    constructor(tui: TUI, theme: Theme, message: string);
+    get signal(): AbortSignal;
+    set onAbort(fn: (() => void) | undefined);
+    handleInput(data: string): void;
+    dispose(): void;
+}

package/dist/types/overlays/btw-history-panel.d.ts

@@ -0,0 +1,29 @@
+import { type Component, type Focusable } from "../index.js";
+import { type BtwHistoryRecord } from "./btw-history.js";
+interface BtwHistoryPanelOptions {
+    records: readonly BtwHistoryRecord[];
+    onClose: () => void;
+    onCopy: (record: BtwHistoryRecord) => void;
+    onCancel: (record: BtwHistoryRecord) => void;
+    canFollowUp?: (record: BtwHistoryRecord) => boolean;
+    onFollowUp?: (record: BtwHistoryRecord, question: string, signal: AbortSignal) => Promise<boolean>;
+    requestRender: () => void;
+    getHeight: () => number;
+}
+/** Session-local side questions. Selecting or copying never promotes them into chat. */
+export declare class BtwHistoryPanel implements Component, Focusable {
+    #private;
+    constructor(options: BtwHistoryPanelOptions);
+    get focused(): boolean;
+    set focused(value: boolean);
+    update(records: readonly BtwHistoryRecord[]): void;
+    /** Visual confirmation that `c` copied this record's answer to the clipboard. */
+    markCopied(recordId: string, text: string): void;
+    invalidate(): void;
+    openFollowUp(recordId: string): boolean;
+    /** Enhanced clipboard pastes belong only to the active composer. */
+    pasteText(text: string): void;
+    handleInput(data: string): void;
+    render(width: number): readonly string[];
+}
+export {};

package/dist/types/overlays/btw-history.d.ts

@@ -0,0 +1,17 @@
+export interface BtwHistoryTurn {
+    question: string;
+    answer: string;
+    status: "running" | "complete" | "cancelled" | "error" | "interrupted";
+    createdAt: number;
+    updatedAt: number;
+    error?: string;
+}
+export interface BtwHistoryRecord extends BtwHistoryTurn {
+    id: string;
+    leafId: string | null;
+    followUps?: readonly BtwHistoryTurn[];
+}
+export declare function getBtwLatestTurn(record: BtwHistoryRecord): BtwHistoryTurn;
+export declare function getBtwTurns(record: BtwHistoryRecord): readonly BtwHistoryTurn[];
+/** Copy the most recent nonblank answer, preserving its original whitespace. */
+export declare function getBtwCopyText(record: BtwHistoryRecord): string | undefined;

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

@@ -0,0 +1,26 @@
+import { type TUI } from "../index.js";
+import { OverlayPanel } from "../chrome/overlay-box.js";
+interface BtwPanelComponentOptions {
+    question: string;
+    tui: TUI;
+    canBranch?: () => boolean;
+    canFollowUp?: () => boolean;
+}
+export declare class BtwPanelComponent extends OverlayPanel {
+    #private;
+    constructor(options: BtwPanelComponentOptions);
+    appendText(delta: string): void;
+    setAnswer(text: string): void;
+    markComplete(): void;
+    /** Visual confirmation that `c` copied the answer to the clipboard. */
+    markCopied(): void;
+    /** Shows that the completed answer is being promoted into the chat session. */
+    markBranching(): void;
+    markAborted(): void;
+    markError(message: string): void;
+    isBranchable(): boolean;
+    isCopyable(): boolean;
+    getCopyText(): string | undefined;
+    close(): void;
+}
+export {};

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

@@ -0,0 +1,36 @@
+/** Anchored `/cleanse` overlay rendering the host's live board above the editor. */
+import { type TUI } from "../index.js";
+import type { AgentProgress } from "../tools/task.js";
+import { OverlayPanel } from "../chrome/overlay-box.js";
+import type { CleanseBoardModel, CleanseCheckerDescriptor, CleanseCheckResult, CleanseAssignment, CleanseAgentOutcome } from "../apps/cleanse-board.js";
+export type CleansePanelRunStatus = "clean" | "unresolved" | "unsupported" | "cancelled";
+interface CleansePanelComponentOptions {
+    model: CleanseBoardModel;
+    /** Free-form request shown in the header; omitted for checker-discovery runs. */
+    request?: string;
+    tui: TUI;
+}
+export declare class CleansePanelComponent extends OverlayPanel {
+    #private;
+    readonly interactive = true;
+    constructor(options: CleansePanelComponentOptions);
+    log(text: string): void;
+    /** Permanent line styled as a failure (the core's stderr-equivalent). */
+    logError(text: string): void;
+    phase(text: string | undefined): void;
+    checkerStarted(checker: CleanseCheckerDescriptor): void;
+    checkerFinished(check: CleanseCheckResult, durationMs: number): void;
+    repairFinished(): void;
+    agentStarted(name: string, assignment: CleanseAssignment): void;
+    agentProgress(name: string, progress: AgentProgress): void;
+    agentFinished(outcome: CleanseAgentOutcome, assignment: CleanseAssignment): void;
+    /** Stop the live area; the panel stays mounted until the user dismisses it. */
+    close(): void;
+    /** Record the settled run result and switch the footer to its dismiss hint. */
+    finish(status: CleansePanelRunStatus): void;
+    /** Record an unexpected failure and switch the footer to its dismiss hint. */
+    markError(message: string): void;
+    /** Release the repaint timer during teardown. */
+    dispose(): void;
+}
+export {};

package/dist/types/overlays/codex-reset-fireworks.d.ts

@@ -0,0 +1,52 @@
+import { type Component, type OverlayHandle, type OverlayOptions } from "../index.js";
+/** The active Codex account fields retained between status refreshes. */
+export interface CodexResetUsageSnapshot {
+    /** When this usage report was observed, if supplied by the provider. */
+    observedAt?: number;
+    /** Weekly usage, its quota identity, and its previously scheduled reset deadline. */
+    sevenDay?: {
+        percent: number;
+        resetsAt?: number;
+        tier?: string;
+        plan?: string;
+    };
+    savedResets?: number;
+}
+/** A detected Codex quota event that can trigger the fireworks presentation. */
+export type CodexResetFireworksEvent = {
+    kind: "unscheduled-weekly-reset";
+} | {
+    kind: "saved-reset-banked";
+    added: number;
+    available: number;
+};
+interface CodexResetFireworksHost {
+    ui: {
+        showOverlay(component: Component, options?: OverlayOptions): OverlayHandle;
+        setFocus(component: Component): void;
+        requestRender(): void;
+        readonly terminal: {
+            readonly rows: number;
+        };
+    };
+}
+/**
+ * Compare consecutive reports for one Codex account. A saved-reset grant takes
+ * precedence when both changes arrive in the same report. A verified decrease,
+ * or a prior positive balance becoming unavailable, suppresses the weekly event
+ * because the user may have redeemed a credit. Other weekly usage drops are
+ * celebrated only when the provider advances the quota deadline before the
+ * previously scheduled reset.
+ */
+export declare function detectCodexResetFireworks(previous: CodexResetUsageSnapshot, current: CodexResetUsageSnapshot): CodexResetFireworksEvent | undefined;
+/** Owns the at-most-one modal celebration lifecycle for an interactive session. */
+export declare class CodexResetFireworksController {
+    #private;
+    private readonly host;
+    constructor(host: CodexResetFireworksHost);
+    /** Present a celebration unless another one already owns the modal overlay. */
+    show(event: CodexResetFireworksEvent): boolean;
+    /** Stop the active celebration and release its overlay, if present. */
+    dispose(): void;
+}
+export {};

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

@@ -0,0 +1,47 @@
+/**
+ * Live preview for the `composer.shape` setting and the setup-wizard composer
+ * scene. Chrome is rendered through the same {@link ComposerStyle} objects the
+ * real editor uses, and status rows come from the live
+ * {@link ComposerPreviewStatusSource} (the session's StatusLineComponent) —
+ * nothing about the preview is a re-implementation. Prompt text is a preview
+ * stand-in, and the `session_name` segment falls back to a stand-in title
+ * (passed via `previewTitle`) when the session is unnamed.
+ */
+import { type Component } from "../index.js";
+import type { ComposerShape } from "./composer-shape-registry.js";
+/**
+ * Real status renderer the preview borrows rows from — structurally satisfied
+ * by {@link StatusLineComponent}. Layout is parameterized so a preview can
+ * render a candidate shape's placement instead of the active one.
+ */
+export interface ComposerPreviewStatusSource {
+    /** Powerline bar with the context gauge (box top border content). */
+    getTopBorder(width: number, previewTitle?: string): {
+        content: string;
+        width: number;
+    };
+    /** Flush soft-capped powerline band (band composer top row). */
+    getBandTopBorder(width: number, previewTitle?: string): {
+        content: string;
+        width: number;
+    };
+    /** Plain right-group chip (claude top rule content). */
+    getStandaloneTopBorder(width: number, previewTitle?: string): {
+        content: string;
+        width: number;
+    };
+    /** Plain standalone bottom bar carrying the given segment groups. */
+    renderBottomBar(width: number, groups: "left" | "full", previewTitle?: string): string;
+}
+export interface ComposerShapePreviewOptions {
+    requestRender?: () => void;
+    /** Live status renderer; omitted (tests), the chrome renders without status rows. */
+    status?: ComposerPreviewStatusSource;
+}
+export declare function renderComposerShapePreview(shape: ComposerShape, width: number, status?: ComposerPreviewStatusSource): readonly string[];
+export declare class ComposerShapePreview implements Component {
+    #private;
+    constructor(initialValue?: ComposerShape, options?: ComposerShapePreviewOptions);
+    setValue(shape: ComposerShape): void;
+    render(width: number): readonly string[];
+}

package/dist/types/overlays/composer-shape-registry.d.ts

@@ -0,0 +1,50 @@
+import { type ComposerStyle } from "../index.js";
+import type { SubmenuOption } from "./settings-defs.js";
+/** Composer shape id; extensions may register additional values at runtime. */
+export type ComposerShape = string;
+/** Built-in composer choices and their shared settings/setup copy. */
+export declare const BUILTIN_COMPOSER_SHAPES: readonly [{
+    readonly value: "band";
+    readonly label: "Status Band (Default)";
+    readonly description: "Flush soft-capped status band above a curved prompt, no frame";
+}, {
+    readonly value: "box";
+    readonly label: "Rounded Box";
+    readonly description: "Status line embedded in top border, compact 2-line prompt";
+}, {
+    readonly value: "claude";
+    readonly label: "Claude Code";
+    readonly description: "Full-width horizontal rules above and below, status line at bottom";
+}, {
+    readonly value: "pi";
+    readonly label: "Pi";
+    readonly description: "Framed horizontal rules with status line at bottom";
+}, {
+    readonly value: "borderless";
+    readonly label: "Borderless";
+    readonly description: "Clean prompt glyph with status line at bottom, no box borders";
+}, {
+    readonly value: "rule";
+    readonly label: "Top Rule Dock";
+    readonly description: "Single top rule with status docked onto it and below";
+}, {
+    readonly value: "field";
+    readonly label: "Compact Field";
+    readonly description: "Filled one-row field with accent end caps";
+}, {
+    readonly value: "rail";
+    readonly label: "Accent Rail";
+    readonly description: "Filled one-row field anchored by a single accent rail";
+}];
+/** Built-in composer ids used by tests and non-runtime consumers. */
+export declare const COMPOSER_SHAPE_VALUES: ("band" | "borderless" | "box" | "claude" | "field" | "pi" | "rail" | "rule")[];
+/** Visual composer style and selector copy registered by an extension. */
+export interface ComposerShapeDefinition {
+    label: string;
+    description?: string;
+    style: ComposerStyle;
+}
+/** Install one extension composer shape into rendering and selector registries. */
+export declare function installExtensionComposerShape(definition: ComposerShapeDefinition): () => void;
+/** Available built-in and extension composer choices in selector order. */
+export declare function getComposerShapeOptions(): readonly SubmenuOption[];

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

@@ -0,0 +1,48 @@
+/**
+ * Fullscreen `/copy` picker over the transcript itself.
+ *
+ * Replays the current branch with {@link ChatTranscriptBuilder} on the
+ * alternate screen and moves the same dotted outline the esc-esc rewind
+ * selector uses over the rendered items; Enter copies the outlined turn's
+ * text. Right descends into the turn's inner blocks — fenced code, `>`-quotes,
+ * bash/eval commands, tool output, and links — replacing the turn's rendered
+ * region with a stacked, syntax-highlighted block view whose outline steps per
+ * block; Left/Esc ascend back to the transcript. Every block caption carries a
+ * clickable `⧉ copy` control and link blocks add `↗ open`; the overlay is
+ * fullscreen, so the terminal reports clicks here (SGR mouse) even though the
+ * main transcript never captures the mouse. Keyboard: Enter copies, `o` opens.
+ * A URL that wrapped across terminal rows therefore needs neither a careful
+ * mouse selection nor cmd-click.
+ */
+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";
+export interface CopySelectorDeps {
+    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;
+    /** The outlined content was chosen — copy it. `label` feeds the status line. */
+    onPick: (content: string, label: string) => void;
+    /** `o` on a link block — open `href` with the system opener. Absent: `o` is ignored. */
+    onOpen?: (href: string, label: string) => void;
+    onCancel: () => void;
+}
+export declare class CopySelectorComponent implements Component {
+    #private;
+    private readonly deps;
+    constructor(entries: TranscriptEntry[], deps: CopySelectorDeps);
+    /** Number of copyable transcript items; 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/copy-targets.d.ts

@@ -0,0 +1,63 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { ToolCall } from "@oh-my-pi/pi-ai";
+/** A fenced code block extracted from assistant markdown. */
+export interface CodeBlock {
+    /** Info string after the opening fence (language id), trimmed. */
+    lang: string;
+    /** Block body with the trailing newline stripped. */
+    code: string;
+}
+/** A blockquote block: a maximal run of `>`-prefixed lines from markdown. */
+export interface QuoteBlock {
+    /** Block body with each line's `>` marker (and one optional space) removed. */
+    text: string;
+}
+/** A drillable block within an assistant message, in document order. */
+export type MessageBlock = ({
+    kind: "code";
+} & CodeBlock) | ({
+    kind: "quote";
+} & QuoteBlock);
+/** A runnable command found in the transcript. */
+export interface LastCommand {
+    kind: "bash" | "eval";
+    code: string;
+    /** Highlight language: "bash" for bash, or the resolved eval language ("python"/"javascript"). */
+    language: string;
+}
+/**
+ * Split assistant markdown into drillable blocks — fenced code and `>`-quoted
+ * runs — in document order. Fences mask their bodies, so a `>` line inside a
+ * code block is never mistaken for a quote. An unclosed fence is treated as
+ * ordinary text, matching the fenced-block grammar.
+ */
+export declare function extractBlocks(text: string): MessageBlock[];
+/** Extract fenced code blocks from assistant markdown, in document order. */
+export declare function extractCodeBlocks(text: string): CodeBlock[];
+/** Walk the transcript backwards for the most recent fenced assistant code block. */
+export declare function extractLastCodeBlock(messages: readonly AgentMessage[]): CodeBlock | undefined;
+/** Extract `>`-quoted blocks from assistant markdown, in document order. */
+export declare function extractQuoteBlocks(text: string): QuoteBlock[];
+/** A hyperlink found in assistant markdown: inline `[text](href)`, `<autolink>`, bare URL, or reference link. */
+export interface LinkTarget {
+    /** Visible link label flattened to one display row; falls back to `href` when empty. */
+    text: string;
+    /** Absolute http(s) URL as marked resolved it. */
+    href: string;
+}
+/**
+ * Hyperlinks the renderer would draw for `text`, in document order and
+ * deduplicated by href. Tokenization is the renderer's own
+ * ({@link extractMarkdownLinks}), so fenced code, code spans, escapes,
+ * reference definitions and GFM autolink rules agree with the screen. Only
+ * http(s) targets qualify: the result feeds both the clipboard and the system
+ * opener, and a `mailto:`/`file:` destination is not something to hand to
+ * either from a transcript.
+ */
+export declare function extractLinks(text: string): LinkTarget[];
+/** Walk the transcript backwards for the most recent link in an assistant message. */
+export declare function extractLastLink(messages: readonly AgentMessage[]): LinkTarget | undefined;
+/** Runnable command carried by a `bash`/`eval` tool call, if any. */
+export declare function commandFromToolCall(tc: ToolCall): LastCommand | undefined;
+/** Walk the transcript backwards for the most recent bash command or eval code. */
+export declare function extractLastCommand(messages: readonly AgentMessage[]): LastCommand | undefined;

package/dist/types/overlays/error-banner.d.ts

@@ -0,0 +1,13 @@
+import { Container } from "../index.js";
+/**
+ * A persistent error banner pinned above the editor. Unlike the transcript
+ * "Error: …" line (which scrolls away as the conversation grows), this stays in
+ * the fixed region directly above the input so a turn that ended on a provider
+ * error — e.g. Anthropic's "Output blocked by content filtering policy" — cannot
+ * be missed. It is cleared when the next turn starts. The message wraps to the
+ * render width and keeps {@link MAX_BANNER_ROWS} rows; the expand hint on the
+ * overflow row reveals the full body inline in the transcript.
+ */
+export declare class ErrorBannerComponent extends Container {
+    constructor(message: string);
+}

package/dist/types/overlays/extensions/display-text.d.ts

@@ -0,0 +1,10 @@
+/** Strip ANSI/C0/C1/malformed unicode, then expand tabs. Call before theming. */
+export declare function sanitizeDisplayText(text: string): string;
+/** Collapse newlines to spaces so a hostile title cannot inject extra TUI rows (no trimming). */
+export declare function sanitizeDisplaySingleLine(text: string): string;
+/** Collapse newlines so a hostile title cannot inject extra TUI rows. */
+export declare function sanitizeDisplayLine(text: string): string;
+/** Like {@link sanitizeDisplayText}, dropping empty results. */
+export declare function sanitizeDisplayField(text: string | undefined | null): string | undefined;
+/** Like {@link sanitizeDisplayLine}, dropping empty results. */
+export declare function sanitizeDisplayLineField(text: string | undefined | null): string | undefined;

package/dist/types/overlays/extensions/extension-dashboard.d.ts

@@ -0,0 +1,63 @@
+/**
+ * ExtensionDashboard - Fullscreen alternate-screen control center for extensions.
+ *
+ * Chrome mirrors the `/settings` overlay: a titled rounded box, a shared
+ * {@link TabBar} for provider selection, and a two-column body (inventory list |
+ * inspector). Both panes are mouse-aware — wheel scrolls, hover highlights, and
+ * clicks select/activate — routed from a single SGR-mouse handler.
+ *
+ * Navigation:
+ * - Tab/Shift+Tab or ←/→: switch provider tab
+ * - Up/Down or wheel: move list selection
+ * - Space/Enter or click: toggle selected item (or provider master switch)
+ * - Wheel over the inspector, or PageUp/PageDown when the inspector overflows: scroll the detail pane
+ * - Esc: clear search (if active) then close
+ */
+import type { Component } from "../../tui.js";
+import { type Tab } from "../../components/tab-bar.js";
+import { type ToolRuntimeSource } from "./inspector-panel.js";
+import type { ExtensionInspectorSource } from "./inspector-model.js";
+import type { MCPRuntimeSource } from "./mcp-runtime.js";
+import { type Extension, type ExtensionProvider, type ProviderTab } from "./types.js";
+/** Runtime operations remain owned by the embedding application. */
+export interface ExtensionDashboardRuntime {
+    getDisabledExtensions(): string[];
+    setDisabledExtensions(ids: string[]): void;
+    getProviders(): readonly ExtensionProvider[];
+    loadExtensions(disabledIds: string[]): Promise<Extension[]>;
+    toggleProvider(providerId: string): boolean;
+    toggleUserSource(providerId: string): boolean;
+    persistMcpToggle(name: string, enabled: boolean, sourcePath?: string): Promise<void>;
+    applyMcpToggle(name: string, enabled: boolean): Promise<void>;
+    subscribeMcpChanges(onChange: () => void): Array<() => void>;
+    mcpSource?: MCPRuntimeSource;
+    inspectorSource?: ExtensionInspectorSource;
+}
+export interface ExtensionDashboardOptions {
+    runtime: ExtensionDashboardRuntime;
+    terminalHeight?: number;
+    toolSource?: ToolRuntimeSource;
+}
+/**
+ * Map dashboard provider tabs to {@link TabBar} tabs. Empty *enabled* providers
+ * are muted — skipped by keyboard nav and unclickable; disabled providers stay
+ * selectable (with a leading disabled glyph) so their master switch can be
+ * re-enabled from the list. The "all" tab is never muted or marked.
+ */
+export declare function buildTabBarTabs(tabs: ProviderTab[]): Tab[];
+export declare class ExtensionDashboard implements Component {
+    #private;
+    onClose?: () => void;
+    onRequestRender?: () => void;
+    private constructor();
+    static create(options: ExtensionDashboardOptions): Promise<ExtensionDashboard>;
+    /**
+     * Fullscreen frame: titled top border, the tab row(s), a divider, the
+     * two-column body sized to fill the viewport, a divider, the footer hint, and
+     * the bottom border.
+     */
+    render(width: number): readonly string[];
+    invalidate(): void;
+    handleInput(data: string): void;
+    dispose(): void;
+}

package/dist/types/overlays/extensions/extension-list.d.ts

@@ -0,0 +1,54 @@
+/**
+ * ExtensionList - Inventory list with Master Switch and fuzzy search.
+ *
+ * When viewing a specific provider (not "ALL"), Row #0 is the Master Switch
+ * that toggles the entire provider. All items below are dimmed when the
+ * master switch is off.
+ */
+import type { Component } from "../../tui.js";
+import { type ToolRuntimeSource } from "./inspector-model.js";
+import { type MCPRuntimeSource } from "./mcp-runtime.js";
+import { type Extension, type ExtensionKind, type ExtensionProvider } from "./types.js";
+export interface ExtensionListCallbacks {
+    getProviders?: () => readonly ExtensionProvider[];
+    onSelectionChange?: (extension: Extension | null) => void;
+    onToggle?: (extensionId: string, enabled: boolean) => void;
+    onMasterToggle?: (providerId: string) => void;
+    onUserSourceToggle?: (providerId: string) => void;
+    masterSwitchProvider?: string | null;
+    mcpSource?: MCPRuntimeSource;
+    toolSource?: ToolRuntimeSource;
+}
+export declare class ExtensionList implements Component {
+    #private;
+    constructor(extensions: Extension[], callbacks?: ExtensionListCallbacks, maxVisible?: number);
+    setMaxVisible(maxVisible: number): void;
+    setExtensions(extensions: Extension[]): void;
+    setFocused(focused: boolean): void;
+    setMasterSwitchProvider(providerId: string | null): void;
+    setMcpSource(source: MCPRuntimeSource | undefined): void;
+    setToolSource(source: ToolRuntimeSource | undefined): void;
+    getSearchQuery(): string;
+    resetSelection(): void;
+    getSelectedExtension(): Extension | null;
+    /** Get the currently selected kind header (for preview purposes) */
+    getSelectedKind(): ExtensionKind | null;
+    setSearchQuery(query: string): void;
+    clearSearch(): void;
+    invalidate(): void;
+    render(width: number): readonly string[];
+    /** Highlight the row under the pointer (null clears). */
+    setHoverIndex(index: number | null): void;
+    /**
+     * Map a 0-based line within this component's render to the absolute list-item
+     * index, or null when the line is the search banner, a padding row, or outside
+     * the visible window. The first two lines are the search banner and a blank
+     * separator; item rows follow, windowed at the current scroll offset.
+     */
+    hitTest(line: number): number | null;
+    /** Wheel notch: move the selection (and the inspector) one row. */
+    handleWheel(delta: -1 | 1): void;
+    /** Click: select the row under the pointer, or activate it when already selected. */
+    handleClick(line: number): void;
+    handleInput(data: string): void;
+}