jeopi-cli 16.2.14 → 16.2.15

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

@@ -0,0 +1,17 @@
+/** Pad or truncate a (possibly ANSI-styled) string to exactly `width` columns. */
+export declare function fit(text: string, width: number): string;
+/** Top border with an optional accent-colored title inset into the rule. */
+export declare function topBorder(width: number, title: string): string;
+/** A horizontal rule with left/right tees, splitting overlay sections. */
+export declare function divider(width: number): string;
+export declare function bottomBorder(width: number): string;
+/** Wrap pre-styled content in vertical borders with single-column insets. */
+export declare function row(content: string, width: number): string;
+/** Body content width for a two-column overlay of total `width`. */
+export declare function splitBodyWidth(width: number, sidebarWidth: number): number;
+/** Top border carrying the title, split by a `┬` over the column divider. */
+export declare function topBorderSplit(width: number, title: string, sidebarWidth: number): string;
+/** Section rule that closes the sidebar column with a `┴` over the divider. */
+export declare function dividerSplit(width: number, sidebarWidth: number): string;
+/** A two-column content row: `│ sidebar │ body │`, each inset by one column. */
+export declare function splitRow(sidebar: string, body: string, width: number, sidebarWidth: number): string;

package/dist/types/modes/components/plan-review-overlay.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 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 "jeopi-tui";
+import type { HookSelectorSlider } from "./hook-selector";
+export interface PlanReviewOverlayCallbacks {
+    /** Invoked with the chosen option label (never a disabled one). */
+    onPick: (label: string) => void;
+    /** Invoked on Esc / cancel. */
+    onCancel: () => 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;
+}
+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;
+}
+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/modes/components/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/modes/components/plugin-selector.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Interactive marketplace plugin selector.
+ *
+ * Shows available plugins from all configured marketplaces in a SelectList.
+ * Selecting a plugin triggers installation. Esc cancels.
+ */
+import { Container, SelectList, type SgrMouseEvent } from "jeopi-tui";
+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 Container {
+    #private;
+    constructor(marketplaceCount: number, plugins: PluginItem[], installedIds: Set<string>, callbacks: PluginSelectorCallbacks);
+    getSelectList(): SelectList;
+    routeMouse(event: SgrMouseEvent, line: number, col: number): void;
+}

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

@@ -0,0 +1,103 @@
+/**
+ * Plugin settings UI components.
+ *
+ * Provides a hierarchical settings interface:
+ * - Plugin list (npm plugins + marketplace plugins)
+ *   - npm plugin detail (enable/disable, features, config)
+ *   - Marketplace plugin detail (enable/disable + read-only metadata)
+ *     - Feature toggles
+ *     - Config value editor
+ */
+import { Container } from "jeopi-tui";
+import { PluginManager } from "../../extensibility/plugins/manager";
+import type { InstalledPluginSummary } from "../../extensibility/plugins/marketplace";
+import type { InstalledPlugin } from "../../extensibility/plugins/types";
+/**
+ * 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 Container {
+    #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;
+    onBack: () => void;
+}
+/**
+ * Shows detail settings for a single plugin:
+ * - Enable/disable toggle
+ * - Feature toggles
+ * - Config settings
+ */
+export declare class PluginDetailComponent extends Container {
+    #private;
+    private plugin;
+    private readonly manager;
+    private readonly callbacks;
+    constructor(plugin: InstalledPlugin, manager: PluginManager, callbacks: PluginDetailCallbacks);
+    handleInput(data: string): void;
+}
+export interface MarketplacePluginDetailCallbacks {
+    onEnabledChange: (enabled: boolean) => void;
+    onBack: () => void;
+}
+/**
+ * Detail view for a marketplace plugin. Marketplace plugins do not declare
+ * features or settings, so the panel exposes a single enable/disable toggle
+ * plus the read-only metadata from the installed-plugins registry.
+ */
+export declare class MarketplacePluginDetailComponent extends Container {
+    #private;
+    private plugin;
+    private readonly callbacks;
+    constructor(plugin: InstalledPluginSummary, callbacks: MarketplacePluginDetailCallbacks);
+    handleInput(data: string): void;
+}
+export interface PluginSettingsCallbacks {
+    onClose: () => void;
+    onPluginChanged: () => void | Promise<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(cwd: string, callbacks: PluginSettingsCallbacks);
+    handleInput(data: string): void;
+}

package/dist/types/modes/components/queue-mode-selector.d.ts

@@ -0,0 +1,10 @@
+import { Container, SelectList, type SgrMouseEvent } from "jeopi-tui";
+/**
+ * Component that renders a queue mode selector with borders
+ */
+export declare class QueueModeSelectorComponent extends Container {
+    #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/modes/components/read-tool-group.d.ts

@@ -0,0 +1,38 @@
+import type { Component } from "jeopi-tui";
+import { Container } from "jeopi-tui";
+import type { ToolExecutionHandle } from "./tool-execution";
+export declare function readArgsHaveTarget(args: unknown): boolean;
+export declare function readArgsTargetInternalUrl(args: unknown): boolean;
+type ReadRenderArgs = {
+    path?: string;
+    file_path?: string;
+    sel?: string;
+};
+type ReadToolGroupOptions = {
+    showContentPreview?: boolean;
+};
+export declare class ReadToolGroupComponent extends Container implements ToolExecutionHandle {
+    #private;
+    constructor(options?: ReadToolGroupOptions);
+    isTranscriptBlockFinalized(): boolean;
+    finalize(): void;
+    /**
+     * Force the group terminal even if an entry never received its result (the
+     * turn aborted or ended). Lets it freeze and stop pinning the transcript live
+     * region instead of lingering on a pending preview until the next thaw.
+     */
+    seal(): void;
+    updateArgs(args: ReadRenderArgs, toolCallId?: string): void;
+    updateResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: unknown;
+        isError?: boolean;
+    }, isPartial?: boolean, toolCallId?: string): void;
+    setArgsComplete(_toolCallId?: string): void;
+    setExpanded(expanded: boolean): void;
+    getComponent(): Component;
+}
+export {};

package/dist/types/modes/components/reset-usage-selector.d.ts

@@ -0,0 +1,12 @@
+import { Container } from "jeopi-tui";
+import type { ResetUsageAccount } from "../../slash-commands/helpers/reset-usage";
+/**
+ * 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 Container {
+    #private;
+    constructor(accounts: ResetUsageAccount[], onSelect: (account: ResetUsageAccount) => void, onCancel: () => void);
+    handleInput(keyData: string): void;
+}

package/dist/types/modes/components/segment-track.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared renderer for a horizontal row of colored "segments" styled after the
+ * status line: each segment is colored by its track position from the theme's
+ * own palette, the active one is filled as a powerline chip (its color as the
+ * background, a luminance-matched label, flanked by triangle caps) and the
+ * rest are plain colored labels joined by a thin separator.
+ *
+ * Used by the plan-mode model-tier slider ({@link HookSelectorComponent}) and
+ * the ctrl+p role-cycle status so both surfaces read identically.
+ */
+import { type ThemeColor } from "../theme/theme";
+export interface TrackSegment {
+    label: string;
+}
+/**
+ * Resolve up to `count` theme colors that render distinctly under the active
+ * theme, in candidate preference order. May return fewer than `count` when the
+ * theme has fewer distinct hues (e.g. monochrome themes) — callers wrap with
+ * modulo. Never returns an empty array: `accent` always resolves.
+ */
+export declare function resolveSegmentPalette(count: number): ThemeColor[];
+/**
+ * Render `segments` as a colored chip track with `activeIndex` filled. Returns
+ * a single line of styled text with no surrounding caption or arrows — callers
+ * frame it as they need.
+ */
+export declare function renderSegmentTrack(segments: TrackSegment[], activeIndex: number): string;

package/dist/types/modes/components/select-list-mouse-routing.d.ts

@@ -0,0 +1,2 @@
+import type { SelectList, SgrMouseEvent } from "jeopi-tui";
+export declare function routeSelectListMouseWithTopBorder(selectList: SelectList, event: SgrMouseEvent, line: number, col: number): void;

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

@@ -0,0 +1,53 @@
+/**
+ * Render `rows` through a {@link ScrollView} with the shared list theme (muted
+ * track / accent thumb) and an "auto" scrollbar, positioned at `scrollOffset`.
+ * Returns the rendered lines for the caller to append to its output.
+ */
+export declare function renderScrollableList(rows: readonly string[], options: {
+    width: number;
+    totalRows: number;
+    scrollOffset: number;
+}): readonly string[];
+/**
+ * Center a viewport window of `maxVisible` rows on `selectedIndex` within a
+ * list of `total` rows, clamped to valid bounds. Used by the selection-centered
+ * list panes (history search, tree selector).
+ */
+export declare function centeredWindow(selectedIndex: number, total: number, maxVisible: number): {
+    startIndex: number;
+    endIndex: number;
+};
+/**
+ * Width available for row content, reserving the rightmost column for the
+ * scrollbar when the list overflows its visible window.
+ */
+export declare function contentRowWidth(width: number, total: number, maxVisible: number): number;
+/**
+ * Clamp `selectedIndex` into `[0, total)` and nudge `scrollOffset` so the
+ * selection stays within the visible window of `maxVisible` rows. Returns the
+ * adjusted pair; on an empty list both reset to 0.
+ */
+export declare function clampSelection(selectedIndex: number, scrollOffset: number, total: number, maxVisible: number): {
+    selectedIndex: number;
+    scrollOffset: number;
+};
+/**
+ * Classify a key event for search-query text entry. Returns the single
+ * printable character to append to the query, or `null` when the key is not a
+ * searchable character: non-printable, multi-byte, or a reserved `j`/`k`
+ * navigation key.
+ */
+export declare function searchableChar(data: string): string | null;
+/**
+ * Handle the shared tab-cycling keys: Tab/Right advance to the next tab,
+ * Shift+Tab/Left to the previous. Invokes `switchTab` with the direction and
+ * returns true when the key was consumed.
+ */
+export declare function handleTabSwitchKey(data: string, switchTab: (direction: 1 | -1) => void): boolean;
+/**
+ * Pad `lines` with blank rows up to `rows` so a full-screen overlay covers the
+ * viewport instead of letting the transcript peek through below it. Copies
+ * before padding — the source array may be component-owned and must not be
+ * mutated.
+ */
+export declare function padLinesToHeight(lines: readonly string[], rows: number): readonly string[];

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

@@ -0,0 +1,94 @@
+import { type Component, Container } from "jeopi-tui";
+import type { SessionInfo } from "../../session/session-listing";
+/** Returns the IDs of sessions whose recorded prompts match a query, best first. */
+export type SessionHistoryMatcher = (query: string) => string[];
+/**
+ * Filter and rank session picker search results.
+ *
+ * Resume search narrows a recency-sorted list: once every query token appears
+ * as a literal substring, newer sessions should beat a slightly better fuzzy
+ * position match. Pure fuzzy/acronym matches still sort by fuzzy score after
+ * literal matches, but weak pure fuzzy tokens are dropped as noise.
+ */
+export declare function rankSessionSearchMatches(allSessions: SessionInfo[], query: string): SessionInfo[];
+/**
+ * Combine metadata matches with prompt-history matches for ranking, using both
+ * signals rather than replacing one with the other.
+ *
+ * - `fuzzy` is the ordered metadata/session-text result.
+ * - `historyIds` are session IDs whose recorded prompts matched the query,
+ *   ordered by prompt-history rank (typically newest matching prompt first); duplicates are tolerated.
+ *
+ * Ranking: prompt-history matches lead in history order, then remaining
+ * metadata matches keep their existing order. A metadata match is never dropped,
+ * and history matches not present in `allSessions` (e.g. deleted or out-of-scope
+ * sessions) are ignored since they cannot be resumed from here.
+ */
+export declare function mergeSessionRanking(allSessions: SessionInfo[], fuzzy: SessionInfo[], historyIds: string[]): SessionInfo[];
+/**
+ * Custom session list component with multi-line items and search
+ */
+declare class SessionList implements Component {
+    #private;
+    onSelect?: (session: SessionInfo) => void;
+    onCancel?: () => void;
+    onExit: () => void;
+    onToggleScope?: () => void;
+    onDeleteRequest?: (session: SessionInfo) => void;
+    constructor(sessions: SessionInfo[], showCwd?: boolean, historyMatcher?: SessionHistoryMatcher, getTerminalRows?: () => number);
+    /** Replace the visible dataset, e.g. when toggling folder/all-projects scope. */
+    setSessions(sessions: SessionInfo[], showCwd: boolean): void;
+    removeSession(sessionPath: string): void;
+    /** Resolve a list-local rendered-line index to a filtered-session index. */
+    hitTestSession(line: number): number | undefined;
+    /** Wheel notch: move the selection one step (clamped, no wrap). */
+    handleWheel(delta: -1 | 1): void;
+    /** Mouse click: select the session under the pointer and resume it. */
+    selectAndConfirm(index: number): void;
+    invalidate(): void;
+    render(width: number): readonly string[];
+    handleInput(keyData: string): void;
+}
+export interface SessionSelectorOptions {
+    onDelete?: (session: SessionInfo) => Promise<boolean>;
+    historyMatcher?: SessionHistoryMatcher;
+    /** Loads sessions across all projects for the all-projects scope toggle (Tab). */
+    loadAllSessions?: () => Promise<SessionInfo[]>;
+    /** Preloaded all-projects list; cached so the first Tab toggle is instant. */
+    allSessions?: SessionInfo[];
+    /**
+     * Reads the live terminal height so the visible window fits the viewport.
+     * Omitted only in tests; defaults to a conservative 24 rows.
+     */
+    getTerminalRows?: () => number;
+    /**
+     * Fill the whole viewport and pin the footer (hint + bottom border) to the
+     * last rows, so the footer stops drifting as the list window changes height.
+     * Set by the standalone `--resume` picker (fullscreen alternate screen); the
+     * in-editor selector leaves it off and renders compactly.
+     */
+    fillHeight?: boolean;
+}
+/**
+ * Component that renders a session selector with optional confirmation dialog
+ */
+export declare class SessionSelectorComponent extends Container {
+    #private;
+    constructor(sessions: SessionInfo[], onSelect: (session: SessionInfo) => void, onCancel: () => void, onExit: () => void, options?: SessionSelectorOptions);
+    setOnRequestRender(callback: () => void): void;
+    /**
+     * Concatenate the children's renders (like {@link Container}) while recording
+     * the line where the session list begins, so the fullscreen picker can hit-
+     * test mouse rows against the live list window. SessionList rebuilds its lines
+     * every frame, so Container's reference-memoization never applied here.
+     *
+     * In fill-height mode the body is padded (or, on a cramped terminal, trimmed)
+     * to leave exactly enough room for the footer at the screen bottom, so the
+     * footer is always visible and never drifts as the list window resizes. The
+     * in-editor selector just appends the footer directly.
+     */
+    render(width: number): readonly string[];
+    handleInput(keyData: string): void;
+    getSessionList(): SessionList;
+}
+export {};

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

@@ -0,0 +1,60 @@
+/**
+ * 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 carrying `tab` and `group` (the group must be listed
+ * in `TAB_GROUPS[tab]`). 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;
+    /** Section within the tab; items are ordered by TAB_GROUPS[tab] and rendered under a heading row. */
+    group?: string;
+    /**
+     * Optional visibility predicate. When supplied and returning false, the
+     * setting is hidden from the UI. Applies to every variant — booleans,
+     * enums, submenus, and text inputs.
+     */
+    condition?: () => boolean;
+}
+export interface BooleanSettingDef extends BaseSettingDef {
+    type: "boolean";
+}
+export interface EnumSettingDef extends BaseSettingDef {
+    type: "enum";
+    values: readonly string[];
+}
+type OptionList = ReadonlyArray<SubmenuOption>;
+export interface SubmenuSettingDef extends BaseSettingDef {
+    type: "submenu";
+    options: OptionList;
+    onPreview?: (value: string) => void;
+    onPreviewCancel?: (originalValue: string) => void;
+}
+export interface TextInputSettingDef extends BaseSettingDef {
+    type: "text";
+}
+export interface ProviderLimitsSettingDef extends BaseSettingDef {
+    type: "providerLimits";
+}
+export type SettingDef = BooleanSettingDef | EnumSettingDef | SubmenuSettingDef | TextInputSettingDef | ProviderLimitsSettingDef;
+/** Get all setting definitions with UI */
+export declare function getAllSettingDefs(): SettingDef[];
+/**
+ * Get settings for a specific tab, ordered by the tab's group layout
+ * (TAB_GROUPS). Ungrouped settings sort first; within a group, schema
+ * declaration order is preserved.
+ */
+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,70 @@
+import type { ThinkingLevel } from "jeopi-agent-core";
+import type { Effort } from "jeopi-ai";
+import type { ShapeTarget } from "jeopi-snapcompact";
+import { type Component, type ImageBudget } from "jeopi-tui";
+import { type SettingPath } from "../../config/settings";
+import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../config/settings-schema";
+/**
+ * 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[];
+    /** Provider/source ids shown in /model. */
+    providers: string[];
+    /** Working directory for plugins tab */
+    cwd: string;
+    /** Active model (api + id); resolves what the snapcompact `auto` shape maps to. */
+    model?: ShapeTarget;
+    /** Shared TUI image budget (graphics ids + transmit-once) for image previews. */
+    imageBudget?: ImageBudget;
+    /** Schedules a re-render after async preview work completes. */
+    requestRender?: () => void;
+}
+/** Status line settings subset for preview */
+export interface StatusLinePreviewSettings {
+    preset?: StatusLinePreset;
+    leftSegments?: StatusLineSegmentId[];
+    rightSegments?: StatusLineSegmentId[];
+    separator?: StatusLineSeparatorStyle;
+    sessionAccent?: boolean;
+    transparent?: boolean;
+    compactThinkingLevel?: 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 | Promise<void>;
+    /** Called when settings panel is closed */
+    onCancel: () => void;
+}
+/**
+ * Main tabbed settings selector component.
+ * Uses declarative settings definitions from settings-defs.ts.
+ */
+export declare class SettingsSelectorComponent implements Component {
+    #private;
+    private readonly context;
+    private readonly callbacks;
+    constructor(context: SettingsRuntimeContext, callbacks: SettingsCallbacks);
+    invalidate(): void;
+    /**
+     * Fullscreen frame: title border, tab row, divider, optional search banner,
+     * the active content sized to fill the terminal, the appearance preview,
+     * then a footer hint pinned above the bottom border.
+     */
+    render(width: number): readonly string[];
+    handleInput(data: string): void;
+}

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

@@ -0,0 +1,10 @@
+import { Container, SelectList, type SgrMouseEvent } from "jeopi-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;
+    routeMouse(event: SgrMouseEvent, line: number, col: number): void;
+}

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

@@ -0,0 +1,9 @@
+import { Container } from "jeopi-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;
+}