@ai-agent-forge/agent-forge 0.85.0

package/dist/modes/interactive/interactive-mode.d.ts

@@ -0,0 +1,640 @@
+/**
+ * Interactive mode for the coding agent.
+ * Handles TUI rendering and user interaction, delegating business logic to AgentSession.
+ */
+import type { ThinkingLevel } from "@agent-forge/agent-core";
+import { type AuthEvent, type AuthPrompt } from "@agent-forge/ai";
+import type { Api, ImageContent, Model } from "@agent-forge/ai/compat";
+import type { AutocompleteProvider, EditorComponent, Terminal } from "@agent-forge/tui";
+import { type Component, Container, type TUI, TuiAltScreen, TuiMainScreen } from "@agent-forge/tui";
+import { type AgentSessionRuntime } from "../../core/agent-session-runtime.ts";
+import type { AgentSessionRuntimeDiagnostic } from "../../core/agent-session-services.ts";
+import type { InteractionDialogOptions, InteractionHostV1 } from "../../core/extensions/index.ts";
+import type { ModelAuthRuntime } from "../../core/facade/coding-agent-facade.ts";
+import { type CodingAgentFacadeV1, type CodingAgentRuntimeFacadeV1 } from "../../core/facade/index.ts";
+import { FooterDataProvider } from "../../core/footer-data-provider.ts";
+import { KeybindingsManager } from "../../core/keybindings.ts";
+import type { ThemeMetaV1 } from "../../core/resource-loader.ts";
+import type { FullscreenExitOutput, SettingsManager, TuiMode } from "../../core/settings-manager.ts";
+import type { SourceInfo } from "../../core/source-info.ts";
+import type { MetricsSnapshotV1, ObservabilityMetricsOptions } from "../../plugins/observability-types.ts";
+import { type LatestRelease } from "../../utils/version-check.ts";
+import { CustomEditor } from "./components/custom-editor.ts";
+import type { DialogEditorComponent } from "./components/dialog-editor.ts";
+import type { DialogInputComponent } from "./components/dialog-input.ts";
+import type { DialogSelectorComponent } from "./components/dialog-selector.ts";
+import { FooterComponent } from "./components/footer.ts";
+import type { LoginDialogComponent } from "./components/login-dialog.ts";
+import type { AuthSelectorProvider } from "./components/oauth-selector.ts";
+import { type WorkingIndicatorOptions } from "./components/status-indicator.ts";
+import * as authFlow from "./interactive-auth.ts";
+import { type DialogUiHost } from "./interactive-dialog-ui.ts";
+import * as selectorsFlow from "./interactive-selectors.ts";
+import { type ModelCatalogRuntime } from "./model-catalog-refresh.ts";
+import { Theme } from "./theme/theme.ts";
+export { mapLegacyDialogResultToOutcome } from "./interactive-dialog-ui.ts";
+/**
+ * Rebuilds real Theme instances from the resource loader's ThemeMetaV1
+ * projection for the theme registry (B-S2b v1). Registration points
+ * (constructor, runtime session start, reload) need loadable instances —
+ * setRegisteredThemes stores what it is given and getThemeByName returns the
+ * registered instance first — while the loader surface now projects only
+ * metadata. Re-loading is synchronous and deterministic per sourcePath;
+ * theme names come from the same JSON the loader parsed, so meta.name ===
+ * Theme.name and the registry keeps its own name-filter/dedupe semantics.
+ *
+ * Contract: a meta without a sourcePath (or one whose file no longer parses)
+ * throws — themesOverride host inputs must always carry a loadable
+ * sourcePath. This adds one extra parse per theme at registration time
+ * (constructor / session start / reload, not per turn).
+ */
+export declare function buildRegisteredThemes(themes: readonly ThemeMetaV1[]): Theme[];
+/**
+ * Session read view consumed by formatResumeCommand: the subset of
+ * session-manager reads the command needs. Satisfied by the runtime facade
+ * (structural) and by real SessionManager instances.
+ */
+interface ResumeCommandSessionReads {
+    isPersisted(): boolean;
+    getSessionFile(): string | undefined;
+    usesDefaultSessionDir(): boolean;
+    getSessionDir(): string;
+    getSessionId(): string;
+}
+export declare function formatResumeCommand(session: ResumeCommandSessionReads): string | undefined;
+/**
+ * Options for InteractiveMode initialization.
+ */
+export interface InteractiveModeOptions {
+    /** Providers that were migrated to auth.json (shows warning) */
+    migratedProviders?: string[];
+    /** Diagnostics collected before the interactive TUI was initialized. */
+    startupDiagnostics?: AgentSessionRuntimeDiagnostic[];
+    /** Warning message if session model couldn't be restored */
+    modelFallbackMessage?: string;
+    /** Initial message to send on startup (can include @file content) */
+    initialMessage?: string;
+    /** Images to attach to the initial message */
+    initialImages?: ImageContent[];
+    /** Additional messages to send after the initial message */
+    initialMessages?: string[];
+    /** Force verbose startup (overrides quietStartup setting) */
+    verbose?: boolean;
+    /** TUI layout mode. */
+    tuiMode?: TuiMode;
+    /** Initial interactive theme setting for this invocation. */
+    initialThemeSetting?: string;
+    /**
+     * Unresolved suite id at startup (设计 §9): the requested `--suite`/env/
+     * settings id could not be resolved before the TUI opened. Interactive mode
+     * shows a suite selector first; the selected id is written to project
+     * settings and a new session is assembled with it. print/RPC keep the
+     * structured exit-1 in main.ts. The placeholder session for the failed id
+     * is fully created (plugin session_start hooks fire once) and then
+     * discarded by the newSession() rebuild after the choice.
+     */
+    pendingSuiteSelector?: {
+        requestedId: string;
+        available: readonly string[];
+    };
+    /**
+     * Observability metrics source for the `/metrics` command, wired from the
+     * session's mounted observability plugin (`plugin.getMetrics`). Resolved
+     * lazily at command time — the plugin's factory runs at mount, which can
+     * happen after host construction, so a host must pass a closure reading the
+     * shared ref rather than capture `ref.current` eagerly. Omitted, or
+     * returning undefined, when the plugin is not mounted; `/metrics` then
+     * shows a warning.
+     */
+    getMetrics?: (options?: ObservabilityMetricsOptions) => MetricsSnapshotV1 | undefined;
+    /**
+     * Settings manager for this invocation, injected by the host (D-047: the
+     * host already holds the same instance it passes to AgentSessionConfig).
+     * The TUI no longer reads settings from AgentSession.
+     */
+    settingsManager: SettingsManager;
+}
+interface InteractiveTuiOptions {
+    tuiMode: TuiMode;
+    showHardwareCursor: boolean;
+    logDirectory: string;
+    terminal?: Terminal;
+    onRightClickPaste?: () => void;
+    fullscreenCopyOnSelect?: boolean;
+}
+/** Composition root for selecting the interactive terminal renderer. */
+export declare function createInteractiveTui(options: InteractiveTuiOptions): TuiMainScreen | TuiAltScreen;
+/** Stable reference for components while InteractiveMode replaces the active renderer. */
+export declare function createInteractiveTuiReference(getTui: () => TUI): TUI;
+export declare class InteractiveMode implements DialogUiHost, authFlow.AuthUiHost, selectorsFlow.SelectorsHost {
+    private runtimeHost;
+    private renderer;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    ui: TUI;
+    private mainScreenRenderState;
+    private loadedResourcesContainer;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    chatContainer: Container;
+    private documentContainer;
+    private transcriptScrollView;
+    private fullscreenLayoutRoot;
+    private pendingMessagesContainer;
+    private statusContainer;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    defaultEditor: CustomEditor;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    editor: EditorComponent;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    autocompleteProvider: AutocompleteProvider | undefined;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    private fdPath;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    editorContainer: Container;
+    private activeSelectorToken?;
+    private activeSelectorDispose?;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    footer: FooterComponent;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    footerContainer: Container;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    footerDataProvider: FooterDataProvider;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    keybindings: KeybindingsManager;
+    private version;
+    private isInitialized;
+    private onInputCallback?;
+    private pendingUserInputs;
+    private activeStatusIndicator;
+    private readonly idleStatus;
+    private workingMessage;
+    private workingVisible;
+    private workingIndicatorOptions;
+    private readonly defaultWorkingMessage;
+    private readonly defaultHiddenThinkingLabel;
+    private hiddenThinkingLabel;
+    private lastSigintTime;
+    private lastEscapeTime;
+    private changelogMarkdown;
+    private startupNoticesShown;
+    private anthropicSubscriptionWarningShown;
+    private lastStatusSpacer;
+    private lastStatusText;
+    private managedToolStatusStarted;
+    private streamingComponent;
+    private streamingMessage;
+    private pendingTools;
+    /** Host-visible for ./interactive-dialog-ui.ts (S5 slice 2). */
+    toolOutputExpanded: boolean;
+    private hideThinkingBlock;
+    private outputPad;
+    private readonly mermaidMarkdownTransformer;
+    private skillCommands;
+    private unsubscribe?;
+    private signalCleanupHandlers;
+    private isBashMode;
+    private bashComponent;
+    private pendingBashComponents;
+    private autoCompactionEscapeHandler?;
+    private retryEscapeHandler?;
+    private compactionQueuedMessages;
+    private shutdownRequested;
+    dialogSelector: DialogSelectorComponent | undefined;
+    dialogInput: DialogInputComponent | undefined;
+    dialogSelectorReplaced: (() => void) | undefined;
+    dialogInputReplaced: (() => void) | undefined;
+    dialogEditor: DialogEditorComponent | undefined;
+    widgetContainerAbove: Container;
+    widgetContainerBelow: Container;
+    headerContainer: Container;
+    builtInHeader: Component | undefined;
+    private options;
+    private readonly onRightClickPaste;
+    private themeController;
+    private get session();
+    private get agent();
+    /**
+     * Constructor-injected settings (D-047): the TUI reads settings from the
+     * host-provided manager, never from AgentSession. Internal collaboration
+     * surface; exposed for ./interactive-selectors.ts (S5 slice 5).
+     */
+    get settingsManager(): SettingsManager;
+    /** Internal collaboration surface; exposed for ./interactive-selectors.ts (S5 slice 5). */
+    get facade(): CodingAgentFacadeV1;
+    /** Internal collaboration surface; exposed for ./interactive-selectors.ts (S5 slice 5). */
+    get runtimeFacade(): CodingAgentRuntimeFacadeV1;
+    constructor(runtimeHost: AgentSessionRuntime, options: InteractiveModeOptions);
+    private getAutocompleteSourceTag;
+    private prefixAutocompleteDescription;
+    private createBaseAutocompleteProvider;
+    setupAutocompleteProvider(): void;
+    private showStartupNoticesIfNeeded;
+    private mountInteractiveTui;
+    private stopInteractiveTui;
+    private switchTuiMode;
+    init(): Promise<void>;
+    /**
+     * Update terminal title with session name and cwd.
+     */
+    private updateTerminalTitle;
+    /**
+     * Run the interactive mode. This is the main entry point.
+     * Initializes the UI, shows warnings, processes initial messages, and starts the interactive loop.
+     */
+    run(): Promise<void>;
+    private promptWithEmptyReplyRetry;
+    private checkForPackageUpdates;
+    private checkTmuxKeyboardSetup;
+    /**
+     * Get changelog entries to display on startup.
+     * Only shows new entries since last seen version, skips for resumed sessions.
+     */
+    private getChangelogForDisplay;
+    private getMarkdownThemeWithSettings;
+    private formatDisplayPath;
+    private formatContextPath;
+    private getStartupExpansionState;
+    /**
+     * Get a short path relative to the package root for display.
+     */
+    private getShortPath;
+    private getCompactPathLabel;
+    getCompactPackageSourceLabel(sourceInfo?: SourceInfo): string;
+    getDisplaySourceInfo(sourceInfo?: SourceInfo): {
+        label: string;
+        scopeLabel?: string;
+        color: "accent" | "muted";
+    };
+    getScopeGroup(sourceInfo?: SourceInfo): "user" | "project" | "path";
+    isPackageSource(sourceInfo?: SourceInfo): boolean;
+    private buildScopeGroups;
+    private formatScopeGroups;
+    findSourceInfoForPath(p: string, sourceInfos: Map<string, SourceInfo>): SourceInfo | undefined;
+    formatPathWithSource(p: string, sourceInfo?: SourceInfo): string;
+    private formatDiagnostics;
+    private showLoadedResources;
+    private bindCurrentSessionExtensions;
+    private applyFullscreenScrollbarSetting;
+    private applyRuntimeSettings;
+    private rebindCurrentSession;
+    private handleFatalRuntimeError;
+    private renderCurrentSessionState;
+    /**
+     * Get a registered tool definition by name (for custom rendering).
+     */
+    private getRegisteredToolDefinition;
+    private getMarkdownTransformers;
+    private showStatusIndicator;
+    private clearStatusIndicator;
+    private showWorkingStatusIndicator;
+    setWorkingVisible(visible: boolean): void;
+    setWorkingIndicator(options?: WorkingIndicatorOptions): void;
+    setHiddenThinkingLabel(label?: string): void;
+    /**
+     * Set the working/loading message shown during streaming. Host entry wired
+     * through ./interactive-dialog-ui.ts; restores the default when undefined.
+     */
+    setWorkingMessage(message: string | undefined): void;
+    private resetDialogUI;
+    /**
+     * Apply a theme request from the extension UI host (implemented by
+     * ./interactive-dialog-ui.ts), keeping the theme controller and settings
+     * persistence on the mode.
+     */
+    applyExtensionTheme(themeOrName: string | Theme): {
+        success: boolean;
+        error?: string;
+    };
+    /**
+     * Interaction host for the versioned capability surface (1A.8): maps the
+     * frozen InteractionHostV1 contract onto the legacy TUI dialogs. Cancellation
+     * rides the existing dialog signal support; notify reuses the notify channel.
+     */
+    createInteractionHostV1(): InteractionHostV1;
+    /**
+     * Show a selector for extensions.
+     */
+    showDialogSelector(title: string, options: string[], opts?: InteractionDialogOptions): Promise<string | undefined>;
+    /**
+     * Hide the extension selector.
+     */
+    hideDialogSelector(): void;
+    /**
+     * Show a confirmation dialog for extensions.
+     */
+    showDialogConfirm(title: string, message: string, opts?: InteractionDialogOptions): Promise<boolean>;
+    private promptForMissingSessionCwd;
+    /**
+     * Show a text input for extensions.
+     */
+    showDialogInput(title: string, placeholder?: string, opts?: InteractionDialogOptions): Promise<string | undefined>;
+    /**
+     * Hide the extension input.
+     */
+    hideDialogInput(): void;
+    /**
+     * Show a multi-line editor for extensions (with Ctrl+G support).
+     */
+    showDialogEditor(title: string, prefill?: string): Promise<string | undefined>;
+    /**
+     * External editor command for extension editors. Host entry for
+     * ./interactive-dialog-ui.ts, keeping settings access on the mode.
+     */
+    getExternalEditorCommand(): string;
+    /**
+     * Hide the extension editor.
+     */
+    hideDialogEditor(): void;
+    /**
+     * Show a notification for extensions.
+     */
+    showDialogNotify(message: string, type?: "info" | "warning" | "error"): void;
+    private setupKeyHandlers;
+    private handleRightClickPaste;
+    private handleClipboardPaste;
+    private handleStartupSubmit;
+    private setupEditorSubmitHandler;
+    /**
+     * Run a /command through COMMAND_DISPATCH_ENTRIES. Returns undefined when
+     * text is not a registered command; otherwise the command has been fully
+     * dispatched (handler invoked, editor cleared in the original order) and
+     * pending carries the async completion, if any.
+     */
+    private dispatchEditorCommand;
+    setEditorText(text: string): void;
+    private subscribeToAgent;
+    private handleEvent;
+    /** Extract text content from a user message */
+    private getUserMessageText;
+    /** Show a managed-tool status update in the chat. */
+    private showManagedToolStatus;
+    /**
+     * Show a status message in the chat.
+     *
+     * If multiple status messages are emitted back-to-back (without anything else being added to the chat),
+     * we update the previous status line instead of appending new ones to avoid log spam.
+     */
+    showStatus(message: string): void;
+    private addMessageToChat;
+    private renderSessionItems;
+    /**
+     * Render session entries to chat. Used for initial load and rebuild after compaction.
+     * @param entries Compaction-aware session entries to render
+     * @param options.updateFooter Update footer state
+     * @param options.populateHistory Add user messages to editor history
+     */
+    private renderSessionEntries;
+    /**
+     * Render billing usage for a compaction or branch summary. The notice is derived
+     * from persisted summary usage and is not stored as a separate session entry.
+     */
+    private addCompactionCostNotice;
+    private maybeShowAssistantDiagnostics;
+    /**
+     * Show a transcript notice when a completed assistant message paid for a
+     * significant cache miss. Only states observable facts: the miss itself,
+     * a model switch, or an idle gap past the cache TTL.
+     */
+    private maybeShowCacheMissNotice;
+    private addCacheMissNotice;
+    renderInitialMessages(): void;
+    getUserInput(): Promise<string>;
+    private rebuildChatFromMessages;
+    private handleCtrlC;
+    private handleCtrlD;
+    /**
+     * Gracefully shutdown the agent.
+     * Stops the TUI before emitting shutdown events so extension UI cleanup cannot
+     * repaint the final frame while the process is exiting.
+     */
+    private isShuttingDown;
+    shutdown(options?: {
+        fromSignal?: boolean;
+    }): Promise<void>;
+    private emergencyTerminalExit;
+    /**
+     * Last-resort handler for uncaught exceptions. The TUI puts stdin into raw
+     * mode and hides the cursor; without this handler, an uncaught throw from
+     * anywhere (e.g. an extension's async `ChildProcess.on("exit")` callback)
+     * tears down the process while leaving the terminal in raw mode with no
+     * cursor, requiring `stty sane && reset` to recover.
+     *
+     * Unlike emergencyTerminalExit, the terminal is still alive here, so we
+     * call ui.stop() to restore cooked mode, the cursor, and disable bracketed
+     * paste / Kitty / modifyOtherKeys sequences.
+     */
+    private uncaughtCrash;
+    private checkShutdownRequested;
+    private registerSignalHandlers;
+    private unregisterSignalHandlers;
+    private handleCtrlZ;
+    private handleFollowUp;
+    private handleDequeue;
+    /** Host-visible for ./interactive-auth.ts (S5 slice 3). */
+    updateEditorBorderColor(): void;
+    private cycleThinkingLevel;
+    private cycleModel;
+    toggleToolOutputExpansion(): void;
+    setToolsExpanded(expanded: boolean): void;
+    /** Update rendered assistant messages without rebuilding live tool components. */
+    private updateThinkingBlockVisibility;
+    private toggleThinkingBlockVisibility;
+    private handleOpenExternalEditor;
+    clearEditor(): void;
+    showError(errorMessage: string): void;
+    showWarning(warningMessage: string): void;
+    showNewVersionNotification(release: LatestRelease): void;
+    showPackageUpdateNotification(packages: string[]): void;
+    /**
+     * Get all queued messages (read-only).
+     * Combines session queue and compaction queue.
+     */
+    private getAllQueuedMessages;
+    /**
+     * Clear all queued messages and return their contents.
+     * Clears both session queue and compaction queue.
+     */
+    private clearAllQueues;
+    private updatePendingMessagesDisplay;
+    private restoreQueuedMessagesToEditor;
+    private queueCompactionMessage;
+    private flushCompactionQueue;
+    /** Move pending bash components from pending area to chat */
+    private flushPendingBashComponents;
+    disposeActiveSelector(): 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;
+        dispose?: () => void;
+    }): void;
+    showSettingsSelector(): void;
+    /** /thinking command entry; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    handleThinkingCommand(searchTerm?: string): void;
+    /** Thinking level apply; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    private selectThinkingLevel;
+    /** Thinking level picker; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    private showThinkingSelector;
+    /**
+     * Current session's suite id, read from the session custom entry recorded at
+     * creation (设计 §10.1). Never inferred from settings or env; undefined when
+     * the session carries no suite entry (e.g. resumed legacy sessions).
+     * Internal collaboration surface; exposed for ./interactive-selectors.ts
+     * (S5 slice 5) while the read stays on the mode (session-boundary carve-out).
+     */
+    getCurrentSessionSuiteId(): string | undefined;
+    private sessionSuiteIdCache;
+    /** Host-visible for ./interactive-selectors.ts (S5 slice 5): narrow session read. */
+    getAvailableThinkingLevels(): ThinkingLevel[];
+    /** Host-visible for ./interactive-selectors.ts (S5 slice 5): narrow session read. */
+    getUserMessagesForForking(): Array<{
+        entryId: string;
+        text: string;
+    }>;
+    /**
+     * Bound suite id of a listed session (设计 §10.1), read from the session
+     * file's binding entry and cached per path — the selector refilters the
+     * list on every keystroke.
+     */
+    private readSessionSuiteId;
+    /** /suite command entry; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    handleSuiteCommand(suiteId?: string): void;
+    /** Suite list overlay; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    private showSuiteSelector;
+    /**
+     * Shared suite list overlay (设计 §9); implementation in
+     * ./interactive-selectors.ts (S5 slice 5).
+     */
+    private openSuiteListSelector;
+    private showStartupSuiteSelector;
+    /** /model command entry; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    handleModelCommand(searchTerm?: string): Promise<void>;
+    private findExactModelMatch;
+    /**
+     * Update the footer's available provider count from the current snapshot without
+     * refreshing catalogs. Host-visible for ./interactive-auth.ts (S5 slice 3).
+     */
+    updateAvailableProviderCount(): void;
+    /** Host-visible for ./interactive-auth.ts (S5 slice 3). */
+    maybeWarnAboutAnthropicSubscriptionAuth(model?: Model<Api> | undefined): Promise<void>;
+    /** Model picker; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    private showModelSelector;
+    /** Scoped-models picker; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    showModelsSelector(): void;
+    /** Fork picker; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    showUserMessageSelector(): void;
+    /** /clone command entry; implementation in ./interactive-selectors.ts (S5 slice 5). */
+    handleCloneCommand(): Promise<void>;
+    showTreeSelector(initialSelectedId?: string): void;
+    showSessionSelector(): void;
+    private handleResumeSession;
+    /**
+     * Cross-suite resume detection (设计 §10.1 最小可用版): compare the loaded
+     * session's original suite binding with the suite resolved from the current
+     * settings/env — the id the resumed session was actually reassembled with
+     * (assembly happens at session creation, so reassembly is the existing
+     * behavior). On a mismatch, record the fact for later debugging: an info
+     * status line plus a `suite_mismatch` custom entry on the session. No
+     * context serialization or conversion is attempted.
+     */
+    private detectCrossSuiteResume;
+    /**
+     * Host-visible for ./interactive-auth.ts (D-048): narrow credential/provider
+     * auth projection of the session's ModelRuntime through the stable facade.
+     * The full runtime never crosses the host boundary (D-047 裁决 3's
+     * credential-management semantics stay open).
+     */
+    getModelAuthRuntime(): ModelAuthRuntime;
+    /** Host-visible for ./interactive-auth.ts (D-048): available model snapshot. */
+    getAvailableModels(): readonly Model<Api>[];
+    /** Host-visible for ./interactive-selectors.ts (D-048): narrow catalog-refresh projection. */
+    getModelCatalog(): ModelCatalogRuntime;
+    /** Host-visible for ./interactive-auth.ts (S5 slice 3): opaque session identity. */
+    getSessionIdentity(): unknown;
+    /** Host-visible for ./interactive-auth.ts (S5 slice 3). */
+    isSameSessionIdentity(identity: unknown): boolean;
+    /** Host-visible for ./interactive-auth.ts (S5 slice 3): stable facade read. */
+    getSelectedModel(): Model<Api> | undefined;
+    /** Host-visible for ./interactive-auth.ts (S5 slice 3): stable facade write. */
+    setSelectedModel(model: Model<Api>): Promise<void>;
+    /** Host-visible for ./interactive-auth.ts (S5 slice 3). */
+    invalidateFooter(): void;
+    /** Host-visible for ./interactive-auth.ts (S5 slice 3); delegates to the selector area. */
+    showAuthSelector(create: (done: () => void) => {
+        component: Component;
+        focus: Component;
+        dispose?: () => void;
+    }): void;
+    /** Login provider options; implementation in ./interactive-auth.ts (S5 slice 3). */
+    getLoginProviderOptions(authType?: "oauth" | "api_key"): AuthSelectorProvider[];
+    /** Logout provider options; implementation in ./interactive-auth.ts (S5 slice 3). */
+    getLogoutProviderOptions(): Promise<AuthSelectorProvider[]>;
+    /** Login provider lookup; implementation in ./interactive-auth.ts (S5 slice 3). */
+    findLoginProviderOptions(providerRef: string): AuthSelectorProvider[];
+    /** /login command entry; implementation in ./interactive-auth.ts (S5 slice 3). */
+    handleLoginCommand(providerRef?: string): Promise<void>;
+    /** Login branch by auth type; implementation in ./interactive-auth.ts (S5 slice 3). */
+    startProviderLogin(providerOption: AuthSelectorProvider): Promise<void>;
+    /** Auth type selector; implementation in ./interactive-auth.ts (S5 slice 3). */
+    showLoginAuthTypeSelector(providerOptions?: AuthSelectorProvider[]): void;
+    /** Login provider selector; implementation in ./interactive-auth.ts (S5 slice 3). */
+    showLoginProviderSelector(authType?: AuthSelectorProvider["authType"], initialSearchInput?: string): void;
+    /** Login/logout selector entry; implementation in ./interactive-auth.ts (S5 slice 3). */
+    showOAuthSelector(mode: "login" | "logout"): Promise<void>;
+    /** Post-login completion; implementation in ./interactive-auth.ts (S5 slice 3). */
+    completeProviderAuthentication(providerId: string, providerName: string, authType: "oauth" | "api_key", previousModel: Model<Api> | undefined): Promise<void>;
+    /** Ambient auth notice; implementation in ./interactive-auth.ts (S5 slice 3). */
+    showAmbientAuthDialog(providerOption: AuthSelectorProvider): void;
+    /** API key login dialog; implementation in ./interactive-auth.ts (S5 slice 3). */
+    showApiKeyLoginDialog(providerId: string, providerName: string): Promise<void>;
+    /** Auth select prompt; implementation in ./interactive-auth.ts (S5 slice 3). */
+    showAuthSelect(dialog: LoginDialogComponent, prompt: Extract<AuthPrompt, {
+        type: "select";
+    }>): Promise<string>;
+    /** Auth prompt plumbing; implementation in ./interactive-auth.ts (S5 slice 3). */
+    showAuthPrompt(dialog: LoginDialogComponent, prompt: AuthPrompt): Promise<string>;
+    /** Auth event rendering; implementation in ./interactive-auth.ts (S5 slice 3). */
+    notifyAuthDialog(dialog: LoginDialogComponent, event: AuthEvent): void;
+    /** Provider login call; implementation in ./interactive-auth.ts (S5 slice 3). */
+    loginProvider(dialog: LoginDialogComponent, providerId: string, method: "api_key" | "oauth"): Promise<void>;
+    /** OAuth login dialog; implementation in ./interactive-auth.ts (S5 slice 3). */
+    showLoginDialog(providerId: string, providerName: string): Promise<void>;
+    handleReloadCommand(): Promise<void>;
+    handleExportCommand(text: string): Promise<void>;
+    private getPathCommandArgument;
+    handleImportCommand(text: string): Promise<void>;
+    handleCopyCommand(options?: {
+        flashConfirmation?: boolean;
+        preferSelection?: boolean;
+    }): Promise<void>;
+    handleNameCommand(text: string): void;
+    handleSessionCommand(): void;
+    handleMetricsCommand(turnsArg: string | undefined): void;
+    handleChangelogCommand(): void;
+    /**
+     * Get capitalized display string for an app keybinding action.
+     */
+    private getAppKeyDisplay;
+    /**
+     * Get capitalized display string for an editor keybinding action.
+     */
+    private getEditorKeyDisplay;
+    handleHelpCommand(): void;
+    handleHotkeysCommand(): void;
+    handleClearCommand(): Promise<void>;
+    handleDebugCommand(): void;
+    handleArminSaysHi(): void;
+    private handleDaxnuts;
+    /** Host-visible for ./interactive-auth.ts (S5 slice 3). */
+    checkDaxnutsEasterEgg(model: {
+        provider: string;
+        id: string;
+    }): void;
+    private handleBashCommand;
+    handleCompactCommand(customInstructions?: string): Promise<void>;
+    stop(fullscreenExitOutput?: FullscreenExitOutput): void;
+}
+//# sourceMappingURL=interactive-mode.d.ts.map