jeopi-cli 16.2.14 → 16.2.15

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

@@ -0,0 +1,147 @@
+/**
+ * Types for the Extension Control Center dashboard.
+ */
+import type { SourceMeta } from "../../../capability/types";
+/**
+ * Extension kinds matching capability types.
+ */
+export type ExtensionKind = "extension-module" | "skill" | "rule" | "tool" | "mcp" | "prompt" | "instruction" | "context-file" | "hook" | "slash-command";
+/**
+ * Extension state (active, disabled, or shadowed).
+ */
+export type ExtensionState = "active" | "disabled" | "shadowed";
+/**
+ * Reason why an extension is disabled.
+ */
+export type DisabledReason = "provider-disabled" | "item-disabled" | "shadowed";
+/**
+ * Unified extension representation for the dashboard.
+ * Normalizes all capability types into a common shape.
+ */
+export interface Extension {
+    /** Unique ID: `${kind}:${name}` */
+    id: string;
+    /** Extension kind */
+    kind: ExtensionKind;
+    /** Extension name */
+    name: string;
+    /** Display name (may differ from name) */
+    displayName: string;
+    /** Description if available */
+    description?: string;
+    /** Trigger pattern (slash command, glob, regex) */
+    trigger?: string;
+    /** Absolute path to source file */
+    path: string;
+    /** Source metadata */
+    source: {
+        provider: string;
+        providerName: string;
+        level: "user" | "project" | "native";
+    };
+    /** Current state */
+    state: ExtensionState;
+    /** Reason for disabled state */
+    disabledReason?: DisabledReason;
+    /** If shadowed, what shadows it */
+    shadowedBy?: string;
+    /** Raw item data for inspector */
+    raw: unknown;
+}
+/**
+ * Tree node types for sidebar hierarchy.
+ */
+export type TreeNodeType = "provider" | "kind" | "item";
+/**
+ * Sidebar tree node.
+ */
+export interface TreeNode {
+    /** Unique ID */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Node type (provider can be toggled, kind groups items) */
+    type: TreeNodeType;
+    /** Whether this node/provider is enabled */
+    enabled: boolean;
+    /** Whether collapsed */
+    collapsed: boolean;
+    /** Child nodes */
+    children: TreeNode[];
+    /** Extension count (for display) */
+    count?: number;
+}
+/**
+ * Flattened tree item for navigation.
+ */
+export interface FlatTreeItem {
+    node: TreeNode;
+    depth: number;
+    index: number;
+}
+/**
+ * Focus region in the tabbed dashboard.
+ */
+export type FocusRegion = "tabs" | "list";
+/**
+ * Provider tab representation.
+ */
+export interface ProviderTab {
+    /** Provider ID (or "all" for the ALL tab) */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Whether provider is enabled (always true for "all") */
+    enabled: boolean;
+    /** Extension count for this provider */
+    count: number;
+}
+/**
+ * Tabbed dashboard state.
+ */
+export interface DashboardState {
+    /** Provider tabs */
+    tabs: ProviderTab[];
+    /** Active tab index */
+    activeTabIndex: number;
+    /** All extensions (unfiltered) */
+    extensions: Extension[];
+    /** Extensions filtered by active tab */
+    tabFiltered: Extension[];
+    /** Extensions filtered by search (applied after tab filter) */
+    searchFiltered: Extension[];
+    /** Current search query */
+    searchQuery: string;
+    /** Selected index in main list */
+    listIndex: number;
+    /** Scroll offset for main list */
+    scrollOffset: number;
+    /** Currently selected extension for inspector */
+    selected: Extension | null;
+}
+/**
+ * Callbacks from dashboard to parent.
+ */
+export interface DashboardCallbacks {
+    /** Called when provider is toggled */
+    onProviderToggle: (providerId: string, enabled: boolean) => void;
+    /** Called when extension item is toggled */
+    onExtensionToggle: (extensionId: string, enabled: boolean) => void;
+    /** Called when dashboard is closed */
+    onClose: () => void;
+}
+/**
+ * Create extension ID from kind and name.
+ */
+export declare function makeExtensionId(kind: ExtensionKind, name: string): string;
+/**
+ * Parse extension ID into kind and name.
+ */
+export declare function parseExtensionId(id: string): {
+    kind: ExtensionKind;
+    name: string;
+} | null;
+/**
+ * Map SourceMeta to extension source shape.
+ */
+export declare function sourceFromMeta(meta: SourceMeta): Extension["source"];

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

@@ -0,0 +1,30 @@
+import { type Component } from "jeopi-tui";
+import type { AgentSession } from "../../session/agent-session";
+/**
+ * Footer component that shows pwd, token stats, and context usage
+ */
+export declare class FooterComponent implements Component {
+    #private;
+    private readonly session;
+    constructor(session: AgentSession);
+    setAutoCompactEnabled(enabled: boolean): void;
+    /**
+     * Set extension status text to display in the footer.
+     * Text is sanitized (newlines/tabs replaced with spaces) and truncated to terminal width.
+     * ANSI escape codes for styling are preserved.
+     * @param key - Unique key to identify this status
+     * @param text - Status text, or undefined to clear
+     */
+    setExtensionStatus(key: string, text: string | undefined): void;
+    /**
+     * Set up a file watcher on .git/HEAD to detect branch changes.
+     * Call the provided callback when branch changes.
+     */
+    watchBranch(onBranchChange: () => void): void;
+    /**
+     * Clean up the file watcher
+     */
+    dispose(): void;
+    invalidate(): void;
+    render(width: number): readonly string[];
+}

package/dist/types/modes/components/history-search.d.ts

@@ -0,0 +1,7 @@
+import { Container } from "jeopi-tui";
+import type { HistoryStorage } from "../../session/history-storage";
+export declare class HistorySearchComponent extends Container {
+    #private;
+    constructor(historyStorage: HistoryStorage, onSelect: (prompt: string) => void, onCancel: () => void);
+    handleInput(keyData: string): void;
+}

package/dist/types/modes/components/hook-editor.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Multi-line editor component for hooks and ask custom input.
+ * Supports Ctrl+G for external editor.
+ *
+ * Two modes:
+ * - Default (hook): Enter inserts newline, the `app.message.followUp` chord
+ *   (Ctrl+Q / Ctrl+Enter) submits, bordered popup
+ * - Prompt-style (ask): Enter submits, Shift+Enter inserts newline, legacy ask chrome
+ */
+import { Container, type TUI } from "jeopi-tui";
+export interface HookEditorOptions {
+    /** When true, use prompt-style keybindings with the legacy ask prompt chrome. */
+    promptStyle?: boolean;
+}
+export declare class HookEditorComponent extends Container {
+    #private;
+    constructor(tui: TUI, title: string, prefill: string | undefined, onSubmit: (value: string) => void, onCancel: () => void, options?: HookEditorOptions);
+    handleInput(keyData: string): void;
+    /** Route non-bracketed paste transports (e.g. kitty's OSC 5522 enhanced clipboard)
+     *  into the inner editor, mirroring bracketed-paste semantics. Without this hook,
+     *  enhanced-paste routing falls back to the main prompt editor hidden behind the
+     *  dialog (#2127 routing contract). */
+    pasteText(text: string): void;
+}

package/dist/types/modes/components/hook-input.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Simple text input component for hooks.
+ */
+import { Container, type TUI } from "jeopi-tui";
+export interface HookInputOptions {
+    tui?: TUI;
+    timeout?: number;
+    onTimeout?: () => void;
+}
+export declare class HookInputComponent extends Container {
+    #private;
+    constructor(title: string, _placeholder: string | undefined, onSubmit: (value: string) => void, onCancel: () => void, opts?: HookInputOptions);
+    handleInput(keyData: string): void;
+    /** Route non-bracketed paste transports (e.g. kitty's OSC 5522 enhanced clipboard)
+     *  into the inner input, mirroring bracketed-paste semantics. Pasting counts as
+     *  interaction, so the timeout countdown resets like any keystroke. */
+    pasteText(text: string): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,15 @@
+import { Container } from "jeopi-tui";
+import type { HookMessageRenderer } from "../../extensibility/hooks/types";
+import type { HookMessage } from "../../session/messages";
+/**
+ * Component that renders a custom message entry from hooks.
+ * Uses distinct styling to differentiate from user messages.
+ */
+export declare class HookMessageComponent extends Container {
+    #private;
+    private readonly message;
+    private readonly customRenderer?;
+    constructor(message: HookMessage<unknown>, customRenderer?: HookMessageRenderer | undefined);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+}

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

@@ -0,0 +1,68 @@
+/**
+ * Generic selector component for hooks.
+ * Displays a list of string options with keyboard navigation.
+ */
+import { Container, type TUI } from "jeopi-tui";
+/** One segment of a {@link HookSelectorSlider} — a label and an optional
+ *  detail line (e.g. the resolved model name) shown beneath the track while
+ *  the segment is active. Segment colors come from the track's theme palette,
+ *  assigned by position. */
+export interface HookSelectorSliderSegment {
+    label: string;
+    /** Secondary line rendered under the track when this segment is selected. */
+    detail?: string;
+}
+/**
+ * A horizontal left/right selector rendered above the option list. Unlike the
+ * up/down option cursor, the slider is moved with the left/right arrows from
+ * any list position, letting the caller capture an orthogonal choice (e.g. the
+ * model tier to continue execution with) alongside the selected option.
+ */
+export interface HookSelectorSlider {
+    /** Dim caption rendered before the slider track (e.g. "continue with"). */
+    caption?: string;
+    segments: HookSelectorSliderSegment[];
+    /** Initially highlighted segment index. */
+    index: number;
+    /** Invoked with the new index whenever the slider moves. */
+    onChange?: (index: number) => void;
+}
+export interface HookSelectorOptions {
+    tui?: TUI;
+    timeout?: number;
+    onTimeout?: () => void;
+    initialIndex?: number;
+    outline?: boolean;
+    maxVisible?: number;
+    onLeft?: () => void;
+    onRight?: () => void;
+    onExternalEditor?: () => void;
+    helpText?: string;
+    slider?: HookSelectorSlider;
+    /** Indices into the original options that cannot be selected: they render
+     *  dimmed, are skipped during navigation, and reject enter/timeout. */
+    disabledIndices?: readonly number[];
+    /** Render a leading radio/checkbox marker before each markable option,
+     *  matching the ask transcript. "radio" fills the marker on the cursor row
+     *  (single-choice); "checkbox" reflects {@link checkedIndices} per row
+     *  (multi-select). Options at or beyond {@link markableCount} keep the plain
+     *  cursor prefix — used for trailing control rows like "Other"/"Done". */
+    selectionMarker?: "radio" | "checkbox";
+    /** For `selectionMarker: "checkbox"`: original-indices currently checked. */
+    checkedIndices?: readonly number[];
+    /** Number of leading options (original order) that receive a selection
+     *  marker. Defaults to every option when {@link selectionMarker} is set. */
+    markableCount?: number;
+}
+export interface HookSelectorOption {
+    label: string;
+    description?: string;
+}
+export type HookSelectorOptionInput = string | HookSelectorOption;
+export declare class HookSelectorComponent extends Container {
+    #private;
+    constructor(title: string, options: HookSelectorOptionInput[], onSelect: (option: string) => void, onCancel: () => void, opts?: HookSelectorOptions);
+    handleInput(keyData: string): void;
+    render(width: number): readonly string[];
+    dispose(): void;
+}

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

@@ -0,0 +1,38 @@
+export * from "./advisor-config";
+export * from "./assistant-message";
+export * from "./bash-execution";
+export * from "./bordered-loader";
+export * from "./compaction-summary-message";
+export * from "./countdown-timer";
+export * from "./custom-editor";
+export * from "./custom-message";
+export * from "./diff";
+export * from "./dynamic-border";
+export * from "./footer";
+export * from "./hook-editor";
+export * from "./hook-input";
+export * from "./hook-message";
+export * from "./hook-selector";
+export * from "./keybinding-hints";
+export * from "./login-dialog";
+export * from "./logout-account-selector";
+export * from "./model-selector";
+export * from "./oauth-selector";
+export * from "./queue-mode-selector";
+export * from "./read-tool-group";
+export * from "./segment-track";
+export * from "./session-selector";
+export * from "./settings-selector";
+export * from "./show-images-selector";
+export * from "./status-line";
+export * from "./theme-selector";
+export * from "./thinking-selector";
+export * from "./tiny-title-download-progress";
+export * from "./todo-reminder";
+export * from "./tool-execution";
+export * from "./tree-selector";
+export * from "./ttsr-notification";
+export * from "./user-message";
+export * from "./user-message-selector";
+export * from "./visual-truncate";
+export * from "./welcome";

package/dist/types/modes/components/keybinding-hints.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Utilities for formatting keybinding hints in the UI.
+ */
+import { type Keybinding } from "jeopi-tui";
+import type { AppKeybinding, KeybindingsManager } from "../../config/keybindings";
+/**
+ * Get display string for an editor action.
+ */
+export declare function editorKey(action: Keybinding): string;
+/**
+ * Get display string for an app action.
+ */
+export declare function appKey(keybindings: KeybindingsManager, action: AppKeybinding): string;
+/**
+ * Format a keybinding hint with consistent styling: dim key, muted description.
+ * Looks up the key from editor keybindings automatically.
+ *
+ * @param action - Keybinding action name (e.g., "tui.select.confirm", "app.tools.expand")
+ * @param description - Description text (e.g., "to expand", "cancel")
+ * @returns Formatted string with dim key and muted description
+ */
+export declare function keyHint(action: Keybinding, description: string): string;
+/**
+ * Format a keybinding hint for app-level actions.
+ * Requires the KeybindingsManager instance.
+ *
+ * @param keybindings - KeybindingsManager instance
+ * @param action - App keybinding name (e.g., "app.interrupt", "app.editor.external")
+ * @param description - Description text
+ * @returns Formatted string with dim key and muted description
+ */
+export declare function appKeyHint(keybindings: KeybindingsManager, action: AppKeybinding, description: string): string;
+/**
+ * Format a raw key string with description (for non-configurable keys like ↑↓).
+ *
+ * @param key - Raw key string
+ * @param description - Description text
+ * @returns Formatted string with dim key and muted description
+ */
+export declare function rawKeyHint(key: string, description: string): string;

package/dist/types/modes/components/late-diagnostics-message.d.ts

@@ -0,0 +1,20 @@
+import { Container } from "jeopi-tui";
+/** One file's worth of late LSP diagnostics, as carried on the transcript message. */
+export interface LateDiagnosticsFile {
+    path?: string;
+    summary?: string;
+    errored?: boolean;
+    messages?: string[];
+}
+/**
+ * Renders late LSP diagnostics (arrived after edit/write returned) in the
+ * transcript, reusing the same tree renderer the edit/write tools use so the
+ * styling stays consistent. Supports the global tool-output expand toggle.
+ */
+export declare class LateDiagnosticsMessageComponent extends Container {
+    #private;
+    private readonly files;
+    constructor(files: LateDiagnosticsFile[]);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+}

package/dist/types/modes/components/login-dialog.d.ts

@@ -0,0 +1,32 @@
+import { Container, type TUI } from "jeopi-tui";
+/**
+ * Login dialog component - replaces editor during OAuth login flow
+ */
+export declare class LoginDialogComponent extends Container {
+    #private;
+    private onComplete;
+    constructor(tui: TUI, providerId: string, onComplete: (success: boolean, message?: string) => void);
+    get signal(): AbortSignal;
+    /**
+     * Called by onAuth callback - show URL and optional instructions
+     */
+    showAuth(url: string, instructions?: string): void;
+    /**
+     * Show input for manual code/URL entry (for callback server providers)
+     */
+    showManualInput(prompt: string): Promise<string>;
+    /**
+     * Called by onPrompt callback - show prompt and wait for input
+     * Note: Does NOT clear content, appends to existing (preserves URL from showAuth)
+     */
+    showPrompt(message: string, placeholder?: string): Promise<string>;
+    /**
+     * Show waiting message (for polling flows like GitHub Copilot)
+     */
+    showWaiting(message: string): void;
+    /**
+     * Called by onProgress callback
+     */
+    showProgress(message: string): void;
+    handleInput(data: string): void;
+}

package/dist/types/modes/components/logout-account-selector.d.ts

@@ -0,0 +1,8 @@
+import { Container } from "jeopi-tui";
+import type { LogoutAccount } from "../../slash-commands/helpers/logout";
+/** Account picker for `/logout` after the provider has been selected. */
+export declare class LogoutAccountSelectorComponent extends Container {
+    #private;
+    constructor(providerName: string, accounts: LogoutAccount[], onSelect: (account: LogoutAccount) => void, onCancel: () => void);
+    handleInput(keyData: string): void;
+}

package/dist/types/modes/components/mcp-add-wizard.d.ts

@@ -0,0 +1,38 @@
+/**
+ * MCP Add Wizard Component
+ *
+ * Interactive multi-step wizard for adding MCP servers.
+ */
+import { Container } from "jeopi-tui";
+import type { MCPServerConfig } from "../../mcp/types";
+type Scope = "user" | "project";
+/**
+ * Result of the wizard's OAuth callback. `credentialId` is mandatory;
+ * `clientId` is populated when the OAuth provider performed dynamic client
+ * registration (or when the caller pre-supplied it) so the wizard can fold it
+ * into the final `mcp.json` entry. Refresh material (including any DCR client
+ * secret) is embedded in the stored credential, never written to config files.
+ */
+export interface MCPAddWizardOAuthResult {
+    credentialId: string;
+    clientId?: string;
+    resource?: string;
+}
+interface MCPAddWizardOAuthOptions {
+    serverUrl?: string;
+    resource?: string;
+    /**
+     * External cancellation source. Aborting it tears down the in-flight OAuth
+     * flow and surfaces a neutral cancellation error. The wizard wires its own
+     * controller here so Esc cancels the OAuth wait instead of stepping back
+     * through the form (the wizard is focused, so the editor's Esc hook does
+     * not fire).
+     */
+    abortSignal?: AbortSignal;
+}
+export declare class MCPAddWizard extends Container {
+    #private;
+    constructor(onComplete: (name: string, config: MCPServerConfig, scope: Scope) => void, onCancel: () => void, onOAuth?: (authUrl: string, tokenUrl: string, clientId: string, clientSecret: string, scopes: string, options?: MCPAddWizardOAuthOptions) => Promise<MCPAddWizardOAuthResult>, onTestConnection?: (config: MCPServerConfig) => Promise<void>, onRender?: () => void, initialName?: string);
+    handleInput(keyData: string): void;
+}
+export {};

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

@@ -0,0 +1,44 @@
+/**
+ * Shared rendering for extension/hook custom message frames.
+ *
+ * Both `CustomMessageComponent` and `HookMessageComponent` wrap a
+ * `Spacer(1) + Box` layout, try a user-supplied renderer first, and fall
+ * back to a label + markdown body when the renderer returns nothing or
+ * throws. The only meaningful difference is that hook messages collapse to
+ * the first N lines when not expanded; extension messages render in full.
+ */
+import type { TextContent } from "jeopi-ai";
+import type { Box, Component } from "jeopi-tui";
+import { type Theme } from "../../modes/theme/theme";
+/** Message shape consumed by the shared frame. */
+export interface FramedMessage {
+    customType: string;
+    content: string | (TextContent | {
+        type: string;
+    })[];
+}
+/**
+ * Callable signature shared by `MessageRenderer` (extensions) and
+ * `HookMessageRenderer` (hooks). Both narrow `message` to their own type;
+ * this signature is the structural intersection callers can hand off here.
+ */
+export type FramedRenderer<M extends FramedMessage> = (message: M, options: {
+    expanded: boolean;
+}, theme: Theme) => Component | undefined;
+export interface RebuildFrameOptions<M extends FramedMessage> {
+    message: M;
+    box: Box;
+    expanded: boolean;
+    /** Icon glyph shown before the customType in the default header (e.g. a hook/extension icon). */
+    icon?: string;
+    /** Collapse the markdown body to this many lines when `expanded` is false. Omit to never collapse. */
+    collapseAfterLines?: number;
+    customRenderer?: FramedRenderer<M>;
+}
+/**
+ * Attempt the custom renderer; on failure or undefined return, populate `box`
+ * with the default outlined card — an `icon customType` header + markdown body —
+ * and return undefined. When the custom renderer succeeds, return its Component
+ * so the caller can mount it and skip the default box.
+ */
+export declare function renderFramedMessage<M extends FramedMessage>(opts: RebuildFrameOptions<M>): Component | undefined;

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

@@ -0,0 +1,36 @@
+import type { Model } from "jeopi-ai";
+import { Container, Input, type SgrMouseEvent, type TUI } from "jeopi-tui";
+import type { ModelRegistry } from "../../config/model-registry";
+import type { Settings } from "../../config/settings";
+import { type ConfiguredThinkingLevel } from "../../thinking";
+interface ScopedModelItem {
+    model: Model;
+    thinkingLevel?: string;
+}
+type RoleSelectCallback = (model: Model, role: string | null, thinkingLevel?: ConfiguredThinkingLevel, selector?: string) => void;
+/**
+ * Component that renders a model selector with provider tabs and context menu.
+ * - Tab/Arrow Left/Right: Switch between provider tabs
+ * - Arrow Up/Down: Navigate model list
+ * - Enter: Open context menu to select action
+ * - Escape: Close menu or selector
+ */
+export declare class ModelSelectorComponent extends Container {
+    #private;
+    constructor(tui: TUI, _currentModel: Model | undefined, settings: Settings, modelRegistry: ModelRegistry, scopedModels: ReadonlyArray<ScopedModelItem>, onSelect: RoleSelectCallback, onCancel: () => void, options?: {
+        temporaryOnly?: boolean;
+        directSelect?: boolean;
+        pickerHint?: string;
+        initialSearchInput?: string;
+        currentContextTokens?: number;
+    });
+    /**
+     * Concatenate children like Container.render, recording where the model list
+     * lands so routed mouse events can be hit-tested against it.
+     */
+    render(width: number): readonly string[];
+    routeMouse(event: SgrMouseEvent, line: number, _col: number): void;
+    handleInput(keyData: string): void;
+    getSearchInput(): Input;
+}
+export {};

package/dist/types/modes/components/move-overlay.d.ts

@@ -0,0 +1,23 @@
+import { type Component, type Focusable } from "jeopi-tui";
+export interface MoveOverlayResult {
+    directory: string;
+}
+/** Resolve a user-typed path (`~`, absolute, or relative to `cwd`) to an absolute path. */
+export declare function resolveMovePath(input: string, cwd: string): string;
+/** If `input` resolves to an existing directory, return it; otherwise `null`. */
+export declare function resolveExistingDirectory(input: string, cwd: string): string | null;
+/**
+ * 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);
+    get focused(): boolean;
+    set focused(value: boolean);
+    handleInput(data: string): void;
+    render(_width: number): readonly string[];
+    invalidate(): void;
+}

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

@@ -0,0 +1,23 @@
+import { Container, type SgrMouseEvent } from "jeopi-tui";
+import type { AuthStorage } from "../../session/auth-storage";
+/**
+ * Component that renders an OAuth provider selector.
+ */
+export declare class OAuthSelectorComponent extends Container {
+    #private;
+    constructor(mode: "login" | "logout", authStorage: AuthStorage, onSelect: (providerId: string) => void, onCancel: () => void, options?: {
+        validateAuth?: (providerId: string) => Promise<boolean>;
+        requestRender?: () => void;
+    });
+    stopValidation(): 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/modes/components/omfg-panel.d.ts

@@ -0,0 +1,19 @@
+import { Container, type TUI } from "jeopi-tui";
+export type OmfgPanelState = "generating" | "validating" | "confirming" | "saving" | "saved" | "rejected" | "aborted" | "error";
+interface OmfgPanelComponentOptions {
+    complaint: string;
+    tui: TUI;
+}
+export declare class OmfgPanelComponent extends Container {
+    #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 {};