@aria-cli/cli 1.0.14

package/dist/ui/display-policy.d.ts

@@ -0,0 +1,3 @@
+import type { RenderItem } from "./render-item.js";
+import type { DisplayMode } from "./display-mode.js";
+export declare function applyDisplayPolicy(items: RenderItem[], mode: DisplayMode): RenderItem[];

package/dist/ui/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export { useKeyboardShortcuts } from "./useKeyboardShortcuts.js";
+export { useDoublePress } from "./useDoublePress.js";
+export { useCommandAutocomplete, type CommandDefinition, type Suggestion, } from "./useCommandAutocomplete.js";
+export { useTerminalSize } from "./useTerminalSize.js";

package/dist/ui/hooks/useCommandAutocomplete.d.ts

@@ -0,0 +1,28 @@
+export interface CommandDefinition {
+    name: string;
+    args: string[];
+    description: string;
+    requiresArgs: boolean;
+}
+export interface Suggestion {
+    command: string;
+    args: string[];
+    description: string;
+    score: number;
+}
+interface UseCommandAutocompleteOptions {
+    commands: CommandDefinition[];
+    maxSuggestions?: number;
+    isActive?: boolean;
+}
+interface UseCommandAutocompleteResult {
+    suggestions: Suggestion[];
+    selectedIndex: number;
+    isOpen: boolean;
+    selectNext: () => void;
+    selectPrev: () => void;
+    complete: () => string | null;
+    close: () => void;
+}
+export declare function useCommandAutocomplete(input: string, { commands, maxSuggestions, isActive }: UseCommandAutocompleteOptions): UseCommandAutocompleteResult;
+export {};

package/dist/ui/hooks/useDoublePress.d.ts

@@ -0,0 +1,13 @@
+interface DoublePressOptions {
+    /** Time window for double press in ms */
+    timeout?: number;
+    /** Callback for first press */
+    onFirstPress?: () => void;
+    /** Callback for second press (within timeout) */
+    onDoublePress: () => void;
+}
+/**
+ * Hook to detect double key presses (e.g., Ctrl+C twice to exit)
+ */
+export declare function useDoublePress({ timeout, onFirstPress, onDoublePress, }: DoublePressOptions): () => void;
+export {};

package/dist/ui/hooks/useIndicatorState.d.ts

@@ -0,0 +1,3 @@
+import type { ObservabilityContext } from "@aria-cli/aria/runner/observability-context.js";
+import { type IndicatorState } from "../indicator-state.js";
+export declare function useIndicatorState(obsCtx: ObservabilityContext | null, isStreaming: boolean): IndicatorState;

package/dist/ui/hooks/useInterval.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A custom hook that runs a callback at a specified interval.
+ * The interval is cleared when the component unmounts.
+ * The interval is also cleared and restarted if the delay changes.
+ */
+export declare function useInterval(callback: () => void, delay: number): void;

package/dist/ui/hooks/useKeyboardShortcuts.d.ts

@@ -0,0 +1,17 @@
+import { Cursor } from '../utils/cursor.js';
+interface KeyboardShortcutsConfig {
+    cursor: Cursor;
+    setCursor: (cursor: Cursor) => void;
+    history?: {
+        items: string[];
+        index: number;
+        setIndex: (index: number) => void;
+    };
+    onExit?: () => void;
+    isActive?: boolean;
+}
+/**
+ * Hook providing Emacs-style keyboard shortcuts
+ */
+export declare function useKeyboardShortcuts({ cursor, setCursor, history, onExit, isActive, }: KeyboardShortcutsConfig): void;
+export {};

package/dist/ui/hooks/usePeerMessages.d.ts

@@ -0,0 +1,26 @@
+/**
+ * React hook that subscribes to incoming peer messages from two sources:
+ *
+ * 1. Daemon watchInbox — WireGuard peer messages via streaming socket
+ * 2. .comms/inbox/ file watcher — agent fleet messages via filesystem
+ *
+ * Both sources merge into a single PeerMessageItem[] for the Static zone.
+ */
+import type { PeerMessageItem } from "../render-item.js";
+interface WatchInboxOptions {
+    runtimeSocket: string | null;
+    commsInboxDir?: string | null;
+    clientId?: string | null;
+    clientAuthToken?: string | null;
+    /**
+     * Callback to resolve fresh credentials when existing ones are stale.
+     * Called on initial connect and after each stale-lease rejection.
+     * Returns null if credentials cannot be refreshed (session expired).
+     */
+    resolveCredentials?: () => Promise<{
+        clientId: string;
+        clientAuthToken: string;
+    } | null>;
+}
+export declare function usePeerMessages(options: WatchInboxOptions): PeerMessageItem[];
+export {};

package/dist/ui/hooks/useTerminalSize.d.ts

@@ -0,0 +1,6 @@
+type TerminalSize = {
+    columns: number;
+    rows: number;
+};
+export declare function useTerminalSize(): TerminalSize;
+export {};

package/dist/ui/hooks/useUnifiedMessages.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Unified message state — single array + streaming cursor.
+ *
+ * Replaces the dual messages/previewMessages state machine that caused
+ * preview-committed race conditions (text cutoff, ghost preview, abort freeze).
+ *
+ * Invariant: `isStreaming === (streamCursor !== null)` — derived, never separate state.
+ *
+ * Generic over item type T (defaults to RenderItem for rendering, but can be
+ * used with ConversationMessage for state management in ink-repl).
+ */
+import { type SetStateAction } from "react";
+import type { RenderItem } from "../render-item.js";
+export interface TurnState<T = RenderItem> {
+    /** Single flat array of ALL items (history + streaming). */
+    items: T[];
+    /**
+     * Index of the first streaming item. `null` = idle (all items committed).
+     * - items[0..streamCursor-1] → committed (Static zone / terminal scrollback)
+     * - items[streamCursor..] → streaming (Live zone / cursor position)
+     */
+    streamCursor: number | null;
+}
+/** Begin a new streaming turn. Sets cursor to end of current items. */
+interface StartTurnAction {
+    type: "START_TURN";
+}
+/** Replace streaming zone with fresh snapshot (progressive render). */
+interface UpdateStreamAction<T> {
+    type: "UPDATE_STREAM";
+    snapshot: T[];
+}
+/** Commit flushed items and advance cursor past them (turn boundary). */
+interface CommitTurnAction<T> {
+    type: "COMMIT_TURN";
+    flushed: T[];
+}
+/** End streaming — all items become committed. */
+interface EndTurnAction {
+    type: "END_TURN";
+}
+/** Append committed items (user message, error, peer message — non-streaming). */
+interface AppendCommittedAction<T> {
+    type: "APPEND_COMMITTED";
+    items: T[];
+}
+/** Reset all state (session change, clear). */
+interface ResetAction<T> {
+    type: "RESET";
+    items?: T[];
+}
+/** Discard streaming items and end streaming (abort/error/cancel). */
+interface DiscardStreamingAction {
+    type: "DISCARD_STREAMING";
+}
+/** Apply a functional update to committed items (compat with setState updater). */
+interface FunctionalUpdateAction<T> {
+    type: "FUNCTIONAL_UPDATE";
+    updater: (committed: T[]) => T[];
+}
+/** Atomically commit flushed items AND end streaming (single dispatch, no race). */
+interface CommitAndEndAction<T> {
+    type: "COMMIT_AND_END";
+    flushed: T[];
+}
+export type TurnAction<T = RenderItem> = StartTurnAction | UpdateStreamAction<T> | CommitTurnAction<T> | EndTurnAction | AppendCommittedAction<T> | ResetAction<T> | DiscardStreamingAction | FunctionalUpdateAction<T> | CommitAndEndAction<T>;
+export declare function turnReducer<T = RenderItem>(state: TurnState<T>, action: TurnAction<T>): TurnState<T>;
+export interface UnifiedMessageState<T = RenderItem> {
+    /** All items (committed + streaming). */
+    items: T[];
+    /** Committed items for Ink's Static zone. */
+    committedItems: T[];
+    /** Streaming items for the Live zone. */
+    streamingItems: T[];
+    /** Whether a streaming turn is active. Derived from streamCursor. */
+    isStreaming: boolean;
+    /** Dispatch an action to update state. */
+    dispatch: React.Dispatch<TurnAction<T>>;
+    /** Drop-in replacement for useState setter — routes through the reducer. */
+    setItems: (action: SetStateAction<T[]>) => void;
+}
+export declare function useUnifiedMessages<T = RenderItem>(initialItems?: T[]): UnifiedMessageState<T>;
+export {};

package/dist/ui/indicator-state.d.ts

@@ -0,0 +1,46 @@
+import type { VerbPair } from "./verb-pairs.js";
+export type { VerbPair };
+export type IndicatorState = {
+    kind: "idle";
+} | {
+    kind: "thinking";
+    verb: VerbPair;
+    startedAt: number;
+} | {
+    kind: "composing";
+    verb: VerbPair;
+    thoughtForSeconds?: number;
+} | {
+    kind: "tool_running";
+    tools: Map<string, string>;
+};
+export type IndicatorEvent = {
+    type: "STREAM_START";
+    verb: VerbPair;
+} | {
+    type: "STREAM_END";
+} | {
+    type: "THINKING_START";
+    verb: VerbPair;
+    startedAt: number;
+} | {
+    type: "THINKING_END";
+    verb: VerbPair;
+    durationSeconds: number;
+} | {
+    type: "TOOL_START";
+    callId: string;
+    displayName: string;
+} | {
+    type: "TOOL_END";
+    callId: string;
+    verb: VerbPair;
+};
+export declare const initialState: IndicatorState;
+/**
+ * Pure state machine transition function.
+ * All randomness (verb selection, timestamps) must be computed by the caller
+ * and passed in the event payload. This keeps the reducer deterministic and
+ * safe for React StrictMode double-invocation.
+ */
+export declare function transition(state: IndicatorState, event: IndicatorEvent): IndicatorState;

package/dist/ui/markdown/highlight.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Highlight code with syntax coloring
+ */
+export declare function highlightCode(code: string, language: string): string;
+/**
+ * Check if a language is supported for highlighting
+ */
+export declare function isLanguageSupported(language: string): boolean;

package/dist/ui/markdown/index.d.ts

@@ -0,0 +1,16 @@
+type MathRendererMode = "fast" | "katex";
+type ColorWordMode = "auto" | "always" | "never";
+type RenderMode = "final" | "streaming";
+export interface RenderOptions {
+    width?: number;
+    listDepth?: number;
+    mathRenderer?: MathRendererMode;
+    colorWordMode?: ColorWordMode;
+    mode?: RenderMode;
+}
+/**
+ * Render markdown string to terminal-formatted string
+ */
+export declare function applyMarkdown(markdown: string, options?: RenderOptions): string;
+export { tokenize } from "./tokenizer.js";
+export { highlightCode, isLanguageSupported } from "./highlight.js";

package/dist/ui/markdown/tokenizer.d.ts

@@ -0,0 +1,17 @@
+import { type Token, type Tokens } from 'marked';
+export type MarkdownToken = Token;
+export type { Tokens };
+/**
+ * Tokenize markdown string into AST tokens
+ */
+export declare function tokenize(markdown: string): MarkdownToken[];
+/**
+ * Check if token is a specific type
+ */
+export declare function isTokenType<T extends Token['type']>(token: Token, type: T): token is Extract<Token, {
+    type: T;
+}>;
+/**
+ * Get inline tokens from a token (for nested parsing)
+ */
+export declare function getInlineTokens(token: Token): Token[];

package/dist/ui/render-item.d.ts

@@ -0,0 +1,70 @@
+/** Flat render model for the ARIA CLI rendering pipeline.
+ *  Replaces the nested DisplayMessage + ContentBlock[] model.
+ *  Each item has `committed` for Static/Live split. */
+export interface UserMessageItem {
+    kind: "user-message";
+    id: string;
+    text: string;
+    userName: string;
+    committed: boolean;
+}
+export interface UserImageItem {
+    kind: "user-image";
+    id: string;
+    dataUri: string;
+    userName: string;
+    committed: boolean;
+}
+export interface AssistantTextItem {
+    kind: "assistant-text";
+    id: string;
+    text: string;
+    arion?: {
+        name: string;
+        emoji: string;
+        color: string;
+    };
+    committed: boolean;
+}
+export interface ThinkingItem {
+    kind: "thinking";
+    id: string;
+    content: string;
+    durationSec?: number;
+    arion?: {
+        name: string;
+        emoji: string;
+        color: string;
+    };
+    committed: boolean;
+}
+export interface ToolExecutionItem {
+    kind: "tool-execution";
+    id: string;
+    toolName: string;
+    input: unknown;
+    output: unknown;
+    status: "pending" | "running" | "complete" | "error";
+    error?: string;
+    durationMs?: number;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    committed: boolean;
+}
+export interface ErrorItem {
+    kind: "error";
+    id: string;
+    message: string;
+    suggestion?: string;
+    committed: boolean;
+}
+export interface HandoffItem {
+    kind: "handoff";
+    id: string;
+    target: string;
+    direction: "incoming" | "outgoing";
+    committed: boolean;
+}
+export type RenderItem = UserMessageItem | UserImageItem | AssistantTextItem | ThinkingItem | ToolExecutionItem | ErrorItem | HandoffItem;

package/dist/ui/screens/REPL.d.ts

@@ -0,0 +1,288 @@
+/**
+ * REPL screen — top-level orchestrator for the ARIA terminal UI.
+ *
+ * This module bridges ARIA's runner-event-driven architecture with
+ * rendering components. It delegates to the
+ * existing App component for layout and message rendering, while
+ * adding the forked permission UI for tool approval flows.
+ *
+ * Architecture:
+ *   ink-repl.tsx (runner integration, session mgmt, config)
+ *     → REPL.tsx (this file — permission UI bridge)
+ *       → App.tsx (layout, overlays, hotkeys, message rendering)
+ *         → toRenderItems → applyDisplayPolicy → RenderItemView → ToolExecution
+ *           → per-tool renderers (tools/tool-renderer.ts defines the interface)
+ *
+ * Per-tool renderers (tools/registry.ts) provide display name, args, and result rendering.
+ * tool-renderer.ts defines the canonical ToolRenderer interface.
+ */
+import React from "react";
+import { type ArionSelectorMode } from "../App.js";
+import type { ArionSession } from "../../session.js";
+import type { ObservabilityContext, PipelineTimingReport } from "@aria-cli/aria";
+import type { DisplayMode, DisplayConfig } from "../display-mode.js";
+import type { ArionOption, BrowsableMemory, CopilotSourcePickerOption, MemoryBrowserMode, ModelOption, StatusBarMetrics, ThemeSelection, PairRequestInfo } from "../components/index.js";
+import type { ProviderOption } from "../components/ProviderPicker.js";
+import type { ProviderMethodOption } from "../components/ProviderMethodPicker.js";
+import type { ConversationMessage, SessionSummary } from "../../history/index.js";
+import type { TraceWaterfallSpan } from "../components/TraceWaterfall.js";
+import type { EffortLevel } from "@aria-cli/types";
+import type { SelectableClient } from "../../selectable-client.js";
+import type { SelectablePeer } from "../../selectable-peer.js";
+export { TOOL_RENDERERS, type ToolRenderer } from "../tools/registry.js";
+type AnthropicMethodOption = ProviderMethodOption & {
+    description: string;
+    method: "subscription" | "console" | "bedrock" | "claude-cli" | "setup-token" | "api-key" | "env-key";
+};
+type OpenAIMethodOption = ProviderMethodOption & {
+    description: string;
+    method: "env-key" | "profile" | "codex-import" | "api-key";
+};
+type GoogleMethodOption = ProviderMethodOption & {
+    description: string;
+    method: "env-key" | "profile" | "gemini-import" | "api-key" | "oauth";
+};
+export interface REPLProps {
+    session: ArionSession;
+    model: string;
+    /** Max context window tokens for the current model */
+    maxContextTokens?: number;
+    banner: React.ReactNode;
+    messages: ConversationMessage[];
+    previewMessages: ConversationMessage[];
+    isStreaming: boolean;
+    queuedMessage?: string | null;
+    onCancelQueuedMessage?: () => void;
+    responseTime?: number;
+    commands: Array<{
+        name: string;
+        description: string;
+    }>;
+    arions: ArionOption[];
+    models: ModelOption[];
+    memories: BrowsableMemory[];
+    memoryBrowserMode: MemoryBrowserMode;
+    isLoadingMemories: boolean;
+    userName: string | null;
+    memoryCount: number;
+    metrics: StatusBarMetrics;
+    displayMode: DisplayMode;
+    displayConfig: DisplayConfig;
+    showThinking: boolean;
+    showCosts: boolean;
+    showTraces: boolean;
+    pipelineTiming?: PipelineTimingReport;
+    spans: TraceWaterfallSpan[];
+    activeArion?: string;
+    sessions: SessionSummary[];
+    inputHistory: string[];
+    obsCtx: ObservabilityContext | null;
+    approvalRequest: {
+        id: number;
+        toolName: string;
+        input: unknown;
+        riskLevel: "low" | "moderate" | "high";
+        issues?: string[];
+        resolve: (approved: boolean) => void;
+    } | null;
+    effortLevel?: EffortLevel;
+    showAutonomySelector: boolean;
+    autonomyLevel: "minimal" | "balanced" | "high" | "full";
+    onSubmit: (input: string) => void | Promise<void>;
+    onCommand: (cmd: string, args?: string) => Promise<void>;
+    onSelectArion: (name: string, mode: ArionSelectorMode) => Promise<void>;
+    onSelectModel: (name: string, effort: EffortLevel) => Promise<void>;
+    onSelectMemory: (memory: BrowsableMemory) => Promise<void>;
+    onOpenMemoryBrowser: (mode: MemoryBrowserMode) => Promise<void>;
+    onSelectSession: (sessionId: string) => Promise<void>;
+    onLoadSessions: () => void;
+    onSearchSessions: (query: string) => void;
+    onLoadMoreSessions: (direction: "next" | "prev") => void;
+    /** Bumps to force remount of App's <Static> transcript renderer */
+    staticRenderEpoch?: number;
+    openSessionOverlaySignal?: number;
+    openThemeOverlaySignal?: number;
+    inviteShare?: {
+        inviteToken: string;
+        inviteLabel?: string;
+        expiresAt?: string | null;
+    } | null;
+    onInviteShareClose?: () => void;
+    openJoinInviteOverlaySignal?: number;
+    onJoinInviteSubmit?: (inviteToken: string) => Promise<void> | void;
+    onJoinInviteCancel?: () => void;
+    joinInviteError?: string | null;
+    onSelectTheme?: (theme: ThemeSelection) => void;
+    onToggleThinking: () => void;
+    onToggleCosts: () => void;
+    onToggleTraces: () => void;
+    onCycleDisplayMode: () => void;
+    onSaveInput?: (input: string) => void;
+    onCancel: () => void;
+    onApprovalChoice: (approved: boolean) => void;
+    onAutonomySelect: (level: "minimal" | "balanced" | "high" | "full") => void;
+    onAutonomyCancel: () => void;
+    /** Callback to cycle autonomy level (Shift+Tab) */
+    onCycleAutonomy: () => void;
+    /** Callback to cycle effort level (Ctrl+E) */
+    onCycleEffort?: () => void;
+    /** Provider list for the login picker (null = hidden) */
+    loginPickerProviders: ProviderOption[] | null;
+    /** Callback when user selects a provider in the login picker */
+    onLoginProviderSelect: (provider: ProviderOption) => void;
+    /** Callback when user cancels the login picker */
+    onLoginPickerCancel: () => void;
+    /** Copilot source options picker (null = hidden) */
+    copilotSourceOptions: CopilotSourcePickerOption[] | null;
+    /** Callback when user selects a Copilot source */
+    onCopilotSourceSelect: (option: CopilotSourcePickerOption) => void;
+    /** Callback when user cancels Copilot source picker */
+    onCopilotSourceCancel: () => void;
+    /** Provider ID for the active OAuth login flow (null = hidden) */
+    oauthProvider: string | null;
+    /** Prebuilt authorize URL for kernel-driven OAuth login */
+    oauthAuthorizeUrl?: string | null;
+    /** Expected callback state for localhost OAuth callback flows */
+    oauthExpectedState?: string | null;
+    /** Callback when OAuth login flow completes (success or failure) */
+    onOAuthComplete: (result: {
+        success: boolean;
+        message: string;
+    }) => void;
+    /** Callback when kernel-driven OAuth login captures an authorization code */
+    onOAuthCodeSubmit?: (code: string) => Promise<void> | void;
+    /** Callback when user cancels the OAuth login flow */
+    onOAuthCancel: () => void;
+    /** Provider ID for active GitHub Copilot device flow (null = hidden) */
+    copilotDeviceProvider: string | null;
+    /** Optional profile label for active GitHub Copilot device flow */
+    copilotDeviceProfileLabel: string | null;
+    /** Verification URL for a kernel-driven GitHub Copilot device flow */
+    copilotDeviceVerificationUri?: string | null;
+    /** User code for a kernel-driven GitHub Copilot device flow */
+    copilotDeviceUserCode?: string | null;
+    /** Callback when GitHub Copilot device flow completes */
+    onCopilotDeviceComplete: (result: {
+        success: boolean;
+        message: string;
+    }) => void;
+    /** Callback when the user confirms a kernel-driven GitHub Copilot device flow */
+    onCopilotDeviceApprove?: () => Promise<void> | void;
+    /** Callback when user cancels GitHub Copilot device flow */
+    onCopilotDeviceCancel: () => void;
+    /** Anthropic method picker options (null = hidden) */
+    anthropicMethodOptions: AnthropicMethodOption[] | null;
+    /** Callback when user selects an Anthropic method */
+    onAnthropicMethodSelect: (option: AnthropicMethodOption) => void;
+    /** Callback when user cancels Anthropic method picker */
+    onAnthropicMethodCancel: () => void;
+    /** Show API key text input overlay */
+    anthropicKeyInputVisible: boolean;
+    /** Callback when user submits an API key */
+    onAnthropicKeySubmit: (apiKey: string) => void;
+    /** Callback when user cancels API key input */
+    onAnthropicKeyCancel: () => void;
+    /** Show setup-token text input overlay */
+    anthropicSetupTokenVisible: boolean;
+    /** Callback when user submits a setup token */
+    onAnthropicSetupTokenSubmit: (token: string) => void;
+    /** Callback when user cancels setup token input */
+    onAnthropicSetupTokenCancel: () => void;
+    /** OpenAI method picker options (null = hidden) */
+    openaiMethodOptions: OpenAIMethodOption[] | null;
+    /** Callback when user selects an OpenAI method */
+    onOpenAIMethodSelect: (option: OpenAIMethodOption) => void;
+    /** Callback when user cancels OpenAI method picker */
+    onOpenAIMethodCancel: () => void;
+    /** Show OpenAI API key text input overlay */
+    openaiKeyInputVisible: boolean;
+    /** Callback when user submits an OpenAI API key */
+    onOpenAIKeySubmit: (apiKey: string) => void;
+    /** Callback when user cancels OpenAI key input */
+    onOpenAIKeyCancel: () => void;
+    /** Google method picker options (null = hidden) */
+    googleMethodOptions: GoogleMethodOption[] | null;
+    /** Callback when user selects a Google method */
+    onGoogleMethodSelect: (option: GoogleMethodOption) => void;
+    /** Callback when user cancels Google method picker */
+    onGoogleMethodCancel: () => void;
+    /** Show Google API key text input overlay */
+    googleKeyInputVisible: boolean;
+    /** Callback when user submits a Google API key */
+    onGoogleKeySubmit: (apiKey: string) => void;
+    /** Callback when user cancels Google key input */
+    onGoogleKeyCancel: () => void;
+    /** Generic auth selection overlay options */
+    authInteractionOptions: ProviderMethodOption[] | null;
+    /** Generic auth selection overlay title */
+    authInteractionTitle: string | null;
+    /** Callback when user selects a generic auth option */
+    onAuthInteractionSelect: (optionId: string) => void;
+    /** Callback when user cancels the generic auth selection */
+    onAuthInteractionCancel: () => void;
+    /** Generic auth input overlay */
+    authInteractionInput: {
+        title: string;
+        hint?: string;
+    } | null;
+    /** Callback when user submits a generic auth value */
+    onAuthInteractionInputSubmit: (value: string) => void;
+    /** Callback when user cancels the generic auth input */
+    onAuthInteractionInputCancel: () => void;
+    /** Nearby peers discovered via mDNS */
+    nearbyPeers?: SelectablePeer[];
+    /** Same-home attached clients discovered from the runtime */
+    localClients?: SelectableClient[];
+    /** Callback when user selects a peer to connect to */
+    onSelectPeer?: (peer: SelectablePeer) => void;
+    /** Callback when user selects a same-home client */
+    onSelectClient?: (client: SelectableClient) => void;
+    /** Callback when user cancels peer selection */
+    onPeerCancel?: () => void;
+    /** Callback when user cancels client selection */
+    onClientsCancel?: () => void;
+    /** Incrementing signal to request opening peers overlay */
+    openPeersOverlaySignal?: number;
+    /** Incrementing signal to request opening clients overlay */
+    openClientsOverlaySignal?: number;
+    /** Incoming pair request from another peer */
+    incomingPairRequest?: PairRequestInfo | null;
+    /** Callback when user accepts a pair request */
+    onAcceptPairRequest?: () => void;
+    /** Callback when user rejects a pair request */
+    onRejectPairRequest?: () => void;
+    /** Callback to cancel in-flight pairing long-poll */
+    onCancelPairing?: () => void;
+    /** Signal to open the message-edit overlay (increment to trigger) */
+    openMessageEditOverlaySignal?: number;
+    /** All messages from the current session for the message-edit overlay */
+    editableMessages?: import("../components/overlays/MessageSelector.js").MessageSelectorEntry[];
+    /** Called when user selects a message to edit (messageIndex, messageText) */
+    onEditMessage?: (messageIndex: number, messageText: string) => void;
+    /** Prefill text to load into the input box (e.g., after edit-message selection) */
+    prefillInput?: string;
+    /** Called after the prefill has been consumed */
+    onPrefillConsumed?: () => void;
+    /** Number of unread mesh messages (0 = hidden) */
+    meshMessageCount?: number;
+    /** Path to daemon's runtime socket for real-time message subscription */
+    runtimeSocket?: string | null;
+    /** Attached client ID for subscribeDirectClientInbox */
+    clientId?: string | null;
+    /** Attached client auth token for subscribeDirectClientInbox */
+    clientAuthToken?: string | null;
+    /** Resolve fresh credentials when existing ones are stale (daemon restarted) */
+    resolveCredentials?: () => Promise<{
+        clientId: string;
+        clientAuthToken: string;
+    } | null>;
+}
+/**
+ * REPL — the top-level screen component.
+ *
+ * Wraps App with the forked permission UI. When a tool approval
+ * request arrives (from ink-repl's onApprovalNeeded callback), this
+ * component renders the PermissionRequest overlay
+ * instead of ARIA's basic PermissionPrompt.
+ */
+export declare function REPL(props: REPLProps): React.ReactNode;