jeopi-cli 16.2.14 → 16.2.15

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

@@ -0,0 +1,17 @@
+import { Container } from "jeopi-tui";
+import type { Rule } from "../../capability/rule";
+/**
+ * Component that renders a TTSR (Time Traveling Stream Rules) notification.
+ * Shows when a rule violation is detected and the stream is being rewound.
+ * One block can carry several rules: a single event may match multiple rules,
+ * and consecutive notifications merge into the previous block via
+ * {@link addRules} while it is still the live transcript tail.
+ */
+export declare class TtsrNotificationComponent extends Container {
+    #private;
+    constructor(rules: Rule[]);
+    /** Merge additional rules into this block (deduped by rule name). */
+    addRules(rules: Rule[]): void;
+    setExpanded(expanded: boolean): void;
+    isExpanded(): boolean;
+}

package/dist/types/modes/components/usage-row.d.ts

@@ -0,0 +1,3 @@
+import type { Usage } from "jeopi-ai";
+import { Container } from "jeopi-tui";
+export declare function createUsageRowBlock(usage: Usage, durationMs?: number, ttftMs?: number): Container;

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

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

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

@@ -0,0 +1,9 @@
+import { Container } from "jeopi-tui";
+/**
+ * Component that renders a user message
+ */
+export declare class UserMessageComponent extends Container {
+    #private;
+    constructor(text: string, synthetic?: boolean, imageLinks?: readonly (string | undefined)[]);
+    render(width: number): readonly string[];
+}

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

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

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

@@ -0,0 +1,76 @@
+import { type Component } from "jeopi-tui";
+/**
+ * Fixed number of session rows in the welcome box so its height stays stable
+ * across recent-session updates.
+ */
+export declare const WELCOME_SESSION_SLOTS = 4;
+/**
+ * Fixed number of LSP-server rows, for the same reason. Overflow is sliced so
+ * the box height is constant regardless of how many servers a project has.
+ */
+export declare const WELCOME_LSP_SLOTS = 4;
+export declare function renderWelcomeTip(tip: string, boxWidth: number, phase?: number): string[];
+export interface RecentSession {
+    name: string;
+    timeAgo: string;
+}
+export interface LspServerInfo {
+    name: string;
+    status: "ready" | "error" | "connecting" | "available";
+    fileTypes: string[];
+}
+/**
+ * Premium welcome screen with the block-glyph jeopi wordmark and two-column layout.
+ */
+export declare class WelcomeComponent implements Component {
+    #private;
+    private readonly version;
+    private modelName;
+    private providerName;
+    private recentSessions;
+    private lspServers;
+    constructor(version: string, modelName: string, providerName: string, recentSessions?: RecentSession[], lspServers?: LspServerInfo[]);
+    get tip(): string | undefined;
+    invalidate(): void;
+    /**
+     * Play a one-shot intro that sweeps the gradient through every phase
+     * before settling on the resting frame. Safe to call multiple times —
+     * subsequent calls reset and replay.
+     */
+    playIntro(requestRender: () => void): void;
+    setModel(modelName: string, providerName: string): void;
+    setRecentSessions(sessions: RecentSession[]): void;
+    setLspServers(servers: LspServerInfo[]): void;
+    render(termWidth: number): readonly string[];
+}
+/**
+ * "jeopi" block-glyph wordmark — typography only (per brand: ASCII surfaces
+ * carry the wordmark as pure type, no mascot art). 6 rows: r0 dots, r1–r4
+ * x-height, r5 descenders (j hook, p stem). Rendered through {@link gradientLogo}
+ * so the terminal mark carries the same neon blue→violet→pink synthwave sweep
+ * as the webp wordmark on the OAuth callback page (jeo-code mascot palette).
+ */
+export declare const JEOPI_LOGO: string[];
+/** Persona tagline (jeo-code identity), split to fit the welcome left column. */
+export declare const TAGLINE_LINE_1 = "Encode intention.";
+export declare const TAGLINE_LINE_2 = "Decode software.";
+export interface ShineConfig {
+    /** Overall opacity of the shine overlay, in [0, 1]. */
+    strength: number;
+    /** Center of the shine band along the diagonal, in [0, 1]. */
+    pos: number;
+}
+/**
+ * Resolve the gradient SGR foreground escape for a normalized position `t`
+ * (0..1) along the diagonal, compositing the optional sliding shine highlight.
+ * Shared by {@link gradientLogo} and the setup splash so both stay
+ * color-identical (truecolor when available, 256-color ramp otherwise).
+ */
+export declare function gradientEscape(t: number, shine?: ShineConfig): string;
+/**
+ * Apply a multi-stop diagonal gradient (bottom-left → top-right) plus an
+ * optional sliding shine band across multi-line art. `phase` (0..1) shifts the
+ * gradient along the diagonal, wrapping at 1. When `shine` is provided, a soft
+ * white highlight is composited on top, centered at `shine.pos`.
+ */
+export declare function gradientLogo(lines: readonly string[], phase?: number, shine?: ShineConfig): string[];

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

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

package/dist/types/modes/controllers/command-controller-shared.d.ts

@@ -0,0 +1,47 @@
+import type { SourceMeta } from "../../capability/types";
+import type { InteractiveModeContext } from "../types";
+export type ScopeValue = "project" | "user";
+export type ScopeFlagResult = {
+    ok: true;
+    scope: ScopeValue;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Validate the value following a `--scope` flag.
+ */
+export declare function readScopeFlag(value: string | undefined): ScopeFlagResult;
+export type RemoveArgs = {
+    name: string | undefined;
+    scope: ScopeValue;
+};
+export type ParseRemoveResult = {
+    ok: true;
+    value: RemoveArgs;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Parse the argument tail of `/<cmd> remove <name> [--scope project|user]`.
+ *
+ * `rest` is the text after the subcommand keyword. The caller is responsible
+ * for emitting the command-specific "<entity> name required" usage hint when
+ * `value.name` is undefined.
+ */
+export declare function parseRemoveArgs(rest: string): ParseRemoveResult;
+/**
+ * Group capability-loaded items by their source provider+path, yielding each
+ * group with a display-ready `shortPath`.
+ */
+export declare function groupBySource<T>(items: Iterable<T>, getSource: (item: T) => SourceMeta): Iterable<{
+    providerName: string;
+    shortPath: string;
+    items: T[];
+}>;
+/**
+ * Render a message block (DynamicBorder / Text / DynamicBorder) into the chat
+ * container and request a render.
+ */
+export declare function showCommandMessage(ctx: InteractiveModeContext, text: string): void;

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

@@ -0,0 +1,55 @@
+import { type CompactionOutcome } from "jeopi-agent-core/compaction";
+import { type ProviderDetails, type UsageReport } from "jeopi-ai";
+import type { CompactOptions } from "../../extensibility/extensions/types";
+import { theme } from "../../modes/theme/theme";
+import type { InteractiveModeContext } from "../../modes/types";
+import type { OAuthAccountIdentity } from "../../session/auth-storage";
+import type { CompactMode } from "../../session/compact-modes";
+import { type ShakeMode } from "../../session/shake-types";
+export declare class CommandController {
+    #private;
+    private readonly ctx;
+    constructor(ctx: InteractiveModeContext);
+    openInBrowser(urlOrPath: string): void;
+    handleExportCommand(text: string): Promise<void>;
+    handleDumpCommand(): Promise<void>;
+    handleAdvisorDumpCommand(isRaw?: boolean): void;
+    handleDebugTranscriptCommand(): Promise<void>;
+    handleShareCommand(): Promise<void>;
+    handleSessionCommand(): Promise<void>;
+    handleAdvisorStatusCommand(): Promise<void>;
+    handleJobsCommand(): Promise<void>;
+    handleUsageCommand(reports?: UsageReport[] | null): Promise<void>;
+    handleChangelogCommand(showFull?: boolean): Promise<void>;
+    handleHotkeysCommand(): void;
+    handleToolsCommand(): void;
+    handleContextCommand(): void;
+    handleMemoryCommand(text: string): Promise<void>;
+    handleClearCommand(): Promise<void>;
+    handleFreshCommand(): Promise<void>;
+    handleDropCommand(): Promise<void>;
+    handleForkCommand(): Promise<void>;
+    /**
+     * `/move` — relocate the current session to a different directory.
+     *
+     * With no `targetPath` (TUI only), opens an autocomplete overlay so the user
+     * can pick or type a directory. With a `targetPath`, resolves it directly.
+     * If the target directory does not exist, the user is asked whether to create
+     * it. The active session file and artifacts are moved into the target
+     * directory's session bucket so `/resume` from that directory can find it.
+     */
+    handleMoveCommand(targetPath?: string): Promise<void>;
+    handleRenameCommand(title: string): Promise<void>;
+    handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
+    handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;
+    handleCompactCommand(customInstructions?: string, mode?: CompactMode, beforeFlush?: (outcome: CompactionOutcome) => void | Promise<void>): Promise<CompactionOutcome>;
+    /**
+     * TUI handler for `/shake`. `elide` drops heavy structural content and
+     * `images` strips image blocks. Rebuilds the chat and reports counts.
+     */
+    handleShakeCommand(mode: ShakeMode): Promise<void>;
+    executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto?: boolean, beforeFlush?: (outcome: CompactionOutcome) => void | Promise<void>, mode?: CompactMode): Promise<CompactionOutcome>;
+    handleHandoffCommand(customInstructions?: string): Promise<void>;
+}
+export declare function renderProviderSection(details: ProviderDetails, uiTheme: Pick<typeof theme, "fg">): string;
+export declare function renderUsageReports(reports: UsageReport[], uiTheme: typeof theme, nowMs: number, availableWidth: number, resolveActiveAccount?: (provider: string) => OAuthAccountIdentity | undefined): string;

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

@@ -0,0 +1,28 @@
+import { ToolExecutionComponent } from "../../modes/components/tool-execution";
+import type { InteractiveModeContext } from "../../modes/types";
+import type { AgentSessionEvent } from "../../session/agent-session";
+export declare class EventController {
+    #private;
+    private ctx;
+    constructor(ctx: InteractiveModeContext);
+    dispose(): void;
+    subscribeToAgent(): void;
+    /**
+     * Clear every transcript-anchored/turn-scoped piece of state. Used by the
+     * session focus proxy when re-pointing the transcript at another session:
+     * components, timers, and stream-reveal state all reference the previous
+     * session's transcript and must not bleed into the new one.
+     */
+    resetTranscriptAnchors(): void;
+    handleEvent(event: AgentSessionEvent): Promise<void>;
+    /**
+     * Adopt a rebuilt-tail todo snapshot as the controller's tracked live
+     * snapshot. Used by rebuild paths (settings/extensions overlay close, focus
+     * attach, /resume) to preserve displacement continuity when a turn is still
+     * active — without this, the next same-turn `todo` update would stack
+     * another panel because the controller's tracker was reset before rebuild.
+     * Drops the candidate when it is no longer a displaceable todo.
+     */
+    inheritDisplaceableTodo(component: ToolExecutionComponent | null | undefined): void;
+    sendCompletionNotification(): void;
+}

package/dist/types/modes/controllers/extension-ui-controller.d.ts

@@ -0,0 +1,88 @@
+import type { Component, TUI } from "jeopi-tui";
+import { KeybindingsManager } from "../../config/keybindings";
+import type { ExtensionUIContext, ExtensionUIDialogOptions, ExtensionUISelectItem, ExtensionWidgetContent, ExtensionWidgetOptions, TerminalInputHandler } from "../../extensibility/extensions";
+import { type HookSelectorSlider } from "../../modes/components/hook-selector";
+import { type Theme } from "../../modes/theme/theme";
+import type { InteractiveModeContext, InteractiveSelectorDialogOptions } from "../../modes/types";
+export declare class ExtensionUiController {
+    #private;
+    private ctx;
+    constructor(ctx: InteractiveModeContext);
+    /**
+     * Initialize the hook system with TUI-based UI context.
+     */
+    initHooksAndCustomTools(): Promise<void>;
+    setHookWidget(key: string, content: ExtensionWidgetContent, options?: ExtensionWidgetOptions): void;
+    initializeHookRunner(uiContext: ExtensionUIContext, _hasUI: boolean): void;
+    /**
+     * Emit session event to all extension tools.
+     */
+    emitCustomToolSessionEvent(reason: "start" | "switch" | "branch" | "tree" | "shutdown", previousSessionFile?: string): Promise<void>;
+    /**
+     * Show a tool error in the chat.
+     */
+    showToolError(toolName: string, error: string): void;
+    /**
+     * Set hook status text in the footer.
+     */
+    setHookStatus(key: string, text: string | undefined): void;
+    showCollabAwareSelector(title: string, options: ExtensionUISelectItem[], dialogOptions?: InteractiveSelectorDialogOptions, extra?: {
+        slider?: HookSelectorSlider;
+    }): Promise<string | undefined>;
+    showCollabAwareEditor(title: string, prefill?: string, dialogOptions?: ExtensionUIDialogOptions, editorOptions?: {
+        promptStyle?: boolean;
+    }): Promise<string | undefined>;
+    /**
+     * Show a selector for hooks.
+     */
+    showHookSelector(title: string, options: ExtensionUISelectItem[], dialogOptions?: InteractiveSelectorDialogOptions, extra?: {
+        slider?: HookSelectorSlider;
+    }): Promise<string | undefined>;
+    /**
+     * Hide the hook selector.
+     */
+    hideHookSelector(): void;
+    /**
+     * Show a confirmation dialog for hooks.
+     */
+    showHookConfirm(title: string, message: string): Promise<boolean>;
+    /**
+     * Show a text input for hooks.
+     */
+    showHookInput(title: string, placeholder?: string, dialogOptions?: ExtensionUIDialogOptions): Promise<string | undefined>;
+    /**
+     * Hide the hook input.
+     */
+    hideHookInput(): void;
+    /**
+     * Show a multi-line editor for hooks (with Ctrl+G support).
+     */
+    showHookEditor(title: string, prefill?: string, dialogOptions?: ExtensionUIDialogOptions, editorOptions?: {
+        promptStyle?: boolean;
+    }): Promise<string | undefined>;
+    /**
+     * Hide the hook editor.
+     */
+    hideHookEditor(): void;
+    /**
+     * Show a notification for hooks.
+     */
+    showHookNotify(message: string, type?: "info" | "warning" | "error"): void;
+    /**
+     * Show a custom component with keyboard focus.
+     */
+    showHookCustom<T>(factory: (tui: TUI, theme: Theme, keybindings: KeybindingsManager, done: (result: T) => void) => (Component & {
+        dispose?(): void;
+    }) | Promise<Component & {
+        dispose?(): void;
+    }>, options?: {
+        overlay?: boolean;
+    }): Promise<T>;
+    /**
+     * Show an extension error in the UI.
+     */
+    addExtensionTerminalInputListener(handler: TerminalInputHandler): () => void;
+    clearHookWidgets(): void;
+    clearExtensionTerminalInputListeners(): void;
+    showExtensionError(extensionPath: string, error: string): void;
+}

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

@@ -0,0 +1,71 @@
+import { type AutocompleteProvider, type SlashCommand } from "jeopi-tui";
+import type { InteractiveModeContext } from "../../modes/types";
+import { readImageFromClipboard, readMacFileUrlsFromClipboard, readTextFromClipboard } from "../../utils/clipboard";
+/**
+ * Slash commands that may carry secrets in their arguments should never be
+ * persisted to history.
+ *
+ * - /login accepts three callback forms (redirect URL, query string, raw auth
+ *   code) — all can contain OAuth code=/state= params.
+ * - /join <link> carries a 32-byte room key and optional write token.
+ * - /mcp add --token <token> carries a bearer token.
+ *
+ * The command name is extracted the same way as parseSlashCommand() — splitting
+ * on the earliest whitespace or colon — so /login:?code=... is correctly matched.
+ */
+export declare function shouldSkipHistory(slashText: string): boolean;
+export declare class InputController {
+    #private;
+    private ctx;
+    /** Injectable clipboard reads so tests can drive paste flows without a real clipboard. */
+    private clipboard;
+    constructor(ctx: InteractiveModeContext, 
+    /** Injectable clipboard reads so tests can drive paste flows without a real clipboard. */
+    clipboard?: {
+        readImage: typeof readImageFromClipboard;
+        readText: typeof readTextFromClipboard;
+        readMacFileUrls?: typeof readMacFileUrlsFromClipboard;
+    });
+    setupKeyHandlers(): void;
+    setupEditorSubmitHandler(): void;
+    handleCtrlC(): void;
+    handleCtrlD(): void;
+    handleCtrlZ(): void;
+    handleDequeue(): void;
+    handleRetry(): Promise<void>;
+    /** Send editor text as a follow-up message (queued behind current stream). */
+    handleFollowUp(): Promise<void>;
+    restoreQueuedMessagesToEditor(options?: {
+        abort?: boolean;
+        currentText?: string;
+    }): number;
+    handleImagePathPaste(path: string): Promise<void>;
+    handleImagePaste(): Promise<boolean>;
+    handleClipboardTextRawPaste(): Promise<void>;
+    /**
+     * Editor `onLargePaste` hook: gate a marker-sized paste behind the large-paste menu. Returns
+     * `true` to intercept (the editor skips its default `[Paste]` marker) once the paste reaches the
+     * configured `paste.largeMenuThreshold` line count; otherwise `false` for default collapse-to-marker
+     * behavior. The async menu is fired and forgotten — the editor only needs the synchronous verdict.
+     */
+    handleLargePaste(text: string, lineCount: number): boolean;
+    /**
+     * Present the large-paste menu and apply the chosen action: wrap in `<attachment>` tags (collapsed
+     * to a `[Paste]` marker that expands on submit), save the text to a file and reference its path so
+     * the agent can `read` it on demand, or paste inline. Cancelling (Esc) falls back to the default
+     * inline paste marker, so the pasted content is never lost.
+     */
+    presentLargePasteMenu(text: string, lineCount: number): Promise<void>;
+    createAutocompleteProvider(commands: SlashCommand[], basePath: string): AutocompleteProvider;
+    /** Copy the current editor line to the system clipboard. */
+    handleCopyCurrentLine(): void;
+    /** Copy current prompt text to system clipboard. */
+    handleCopyPrompt(): void;
+    cycleThinkingLevel(): void;
+    cycleRoleModel(direction?: "forward" | "backward"): Promise<void>;
+    toggleToolOutputExpansion(): void;
+    setToolsExpanded(expanded: boolean): void;
+    toggleThinkingBlockVisibility(): void;
+    openExternalEditor(): Promise<void>;
+    registerExtensionShortcuts(): void;
+}

package/dist/types/modes/controllers/mcp-command-controller.d.ts

@@ -0,0 +1,27 @@
+import { type Component } from "jeopi-tui";
+import type { InteractiveModeContext } from "../types";
+/** Renders the MCP OAuth fallback URL without hard-wrapping the copy target. */
+export declare class MCPAuthorizationLinkPrompt implements Component {
+    #private;
+    constructor(url: string);
+    invalidate(): void;
+    render(_width: number): readonly string[];
+}
+/**
+ * Thrown by {@link MCPCommandController}'s OAuth handler when the user (or a
+ * caller-supplied {@link AbortSignal}) cancels the in-flight flow. Distinct
+ * from network/timeout failures so callers can surface a neutral
+ * "cancelled" status instead of an error banner.
+ */
+export declare class MCPOAuthCancelledError extends Error {
+    constructor(message?: string);
+}
+export declare class MCPCommandController {
+    #private;
+    private ctx;
+    constructor(ctx: InteractiveModeContext);
+    /**
+     * Handle /mcp command and route to subcommands
+     */
+    handle(text: string): Promise<void>;
+}

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

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

package/dist/types/modes/controllers/omfg-rule.d.ts

@@ -0,0 +1,26 @@
+import type { AgentMessage } from "jeopi-agent-core";
+import type { Rule } from "../../capability/rule";
+export interface ParsedGeneratedRule {
+    rule: Rule;
+    fileContent: string;
+}
+export type GeneratedRuleParseResult = ParsedGeneratedRule | {
+    error: string;
+};
+export interface RuleHistoryValidation {
+    matched: boolean;
+    feedback?: string;
+}
+export interface ParsedRuleHistoryValidation {
+    candidate: ParsedGeneratedRule;
+    validation: RuleHistoryValidation;
+    repairedCondition: boolean;
+}
+export type OmfgRuleSourceLevel = "project" | "user";
+export declare function extractGeneratedRuleJson(text: string): string | null;
+export declare function sanitizeRuleName(rawName: string): string;
+export declare function buildOmfgRuleForPath(ruleName: string, fileContent: string, filePath: string, level: OmfgRuleSourceLevel): Rule;
+export declare function parseGeneratedRule(text: string): GeneratedRuleParseResult;
+export declare function validateRuleAgainstAssistantHistory(rule: Rule, messages: readonly AgentMessage[]): RuleHistoryValidation;
+export declare function validateParsedRuleAgainstAssistantHistory(candidate: ParsedGeneratedRule, messages: readonly AgentMessage[]): ParsedRuleHistoryValidation;
+export declare function ruleMatchesAssistantHistory(rule: Rule, messages: readonly AgentMessage[]): boolean;

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

@@ -0,0 +1,61 @@
+import type { Component } from "jeopi-tui";
+import type { InteractiveModeContext } from "../../modes/types";
+import type { SessionObserverRegistry } from "../session-observer-registry";
+export declare class SelectorController {
+    #private;
+    private ctx;
+    constructor(ctx: InteractiveModeContext);
+    /**
+     * Restore keyboard focus to whatever currently owns the editor slot. The
+     * slot can hold the editor itself or a hook selector/input/editor pushed
+     * in by `ExtensionUiController` — e.g. an approval prompt that fired while
+     * a fullscreen overlay was up. `overlayHandle.hide()` restores focus to
+     * the component focused when the overlay opened, which is stale in that
+     * case (the editor was swapped out): keys land on a hidden editor and the
+     * visible prompt receives nothing (issue #3349). Call this after the
+     * overlay hides to re-target focus at the visible slot owner.
+     */
+    focusActiveEditorArea(): void;
+    /**
+     * Shows a selector component in place of the editor.
+     * @param create Factory that receives a `done` callback and returns the component and focus target
+     */
+    showSelector(create: (done: () => void) => {
+        component: Component;
+        focus: Component;
+    }): void;
+    showSettingsSelector(): void;
+    showAdvisorConfigure(): void;
+    showHistorySearch(): void;
+    /**
+     * Show the Extension Control Center dashboard.
+     * Replaces /status with a unified view of all providers and extensions.
+     */
+    showExtensionsDashboard(): Promise<void>;
+    /**
+     * Show the Agent Control Center dashboard.
+     */
+    showAgentsDashboard(): Promise<void>;
+    /**
+     * Handle setting changes from the settings selector.
+     * Most settings are saved directly via SettingsManager in the definitions.
+     * This handles side effects and session-specific settings.
+     */
+    handleSettingChange(id: string, value: unknown): void;
+    showModelSelector(options?: {
+        temporaryOnly?: boolean;
+    }): void;
+    showPluginSelector(mode?: "install" | "uninstall"): Promise<void>;
+    showUserMessageSelector(): void;
+    showCopySelector(): void;
+    showTreeSelector(): void;
+    showSessionSelector(): Promise<void>;
+    handleResumeSession(sessionPath: string): Promise<void>;
+    handleSessionDeleteCommand(): Promise<void>;
+    showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
+    showResetUsageSelector(): Promise<void>;
+    showDebugSelector(): Promise<void>;
+    showAgentHub(observers: SessionObserverRegistry, options?: {
+        requireContent?: boolean;
+    }): void;
+}

package/dist/types/modes/controllers/session-focus-controller.d.ts

@@ -0,0 +1,31 @@
+/**
+ * SessionFocusController - Weak retargeting primitive between the rendering/
+ * input layer and the AgentSession it displays.
+ *
+ * Focusing re-points the transcript, streaming event subscription, status
+ * line, and editor prompt/interrupt at a subagent's live AgentSession (from
+ * AgentRegistry) without touching the main session underneath; unfocusing
+ * re-attaches the main session and rebuilds the transcript from its
+ * authoritative state.
+ */
+import { AgentLifecycleManager } from "../../registry/agent-lifecycle";
+import { AgentRegistry } from "../../registry/agent-registry";
+import type { AgentSession } from "../../session/agent-session";
+import type { InteractiveModeContext } from "../types";
+export declare class SessionFocusController {
+    #private;
+    private ctx;
+    private registry;
+    private lifecycle;
+    constructor(ctx: InteractiveModeContext, registry?: AgentRegistry, lifecycle?: () => AgentLifecycleManager);
+    get focusedAgentId(): string | undefined;
+    /** Focused live session, undefined when unfocused. */
+    get target(): AgentSession | undefined;
+    /** Focus the main view on an agent's live session. Throws an Error with a user-displayable message. */
+    focusAgent(id: string): Promise<void>;
+    /** Focus the focused agent's parent agent, falling back to the main session. No-op when unfocused. */
+    focusParent(): Promise<void>;
+    /** Return to the main session. No-op when unfocused. */
+    unfocus(): Promise<void>;
+    dispose(): void;
+}

package/dist/types/modes/controllers/ssh-command-controller.d.ts

@@ -0,0 +1,10 @@
+import type { InteractiveModeContext } from "../types";
+export declare class SSHCommandController {
+    #private;
+    private ctx;
+    constructor(ctx: InteractiveModeContext);
+    /**
+     * Handle /ssh command and route to subcommands
+     */
+    handle(text: string): Promise<void>;
+}