1  import { feature } from 'bun:bundle';
   2  import chalk from 'chalk';
   3  import * as path from 'path';
   4  import * as React from 'react';
   5  import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';
   6  import { useNotifications } from 'src/context/notifications.js';
   7  import { useCommandQueue } from 'src/hooks/useCommandQueue.js';
   8  import { type IDEAtMentioned, useIdeAtMentioned } from 'src/hooks/useIdeAtMentioned.js';
   9  import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from 'src/services/analytics/index.js';
  10  import { type AppState, useAppState, useAppStateStore, useSetAppState } from 'src/state/AppState.js';
  11  import type { FooterItem } from 'src/state/AppStateStore.js';
  12  import { getCwd } from 'src/utils/cwd.js';
  13  import { isQueuedCommandEditable, popAllEditable } from 'src/utils/messageQueueManager.js';
  14  import stripAnsi from 'strip-ansi';
  15  import { companionReservedColumns } from '../../buddy/CompanionSprite.js';
  16  import { findBuddyTriggerPositions, useBuddyNotification } from '../../buddy/useBuddyNotification.js';
  17  import { FastModePicker } from '../../commands/fast/fast.js';
  18  import { isUltrareviewEnabled } from '../../commands/review/ultrareviewEnabled.js';
  19  import { getNativeCSIuTerminalDisplayName } from '../../commands/terminalSetup/terminalSetup.js';
  20  import { type Command, hasCommand } from '../../commands.js';
  21  import { useIsModalOverlayActive } from '../../context/overlayContext.js';
  22  import { useSetPromptOverlayDialog } from '../../context/promptOverlayContext.js';
  23  import { formatImageRef, formatPastedTextRef, getPastedTextRefNumLines, parseReferences } from '../../history.js';
  24  import type { VerificationStatus } from '../../hooks/useApiKeyVerification.js';
  25  import { type HistoryMode, useArrowKeyHistory } from '../../hooks/useArrowKeyHistory.js';
  26  import { useDoublePress } from '../../hooks/useDoublePress.js';
  27  import { useHistorySearch } from '../../hooks/useHistorySearch.js';
  28  import type { IDESelection } from '../../hooks/useIdeSelection.js';
  29  import { useInputBuffer } from '../../hooks/useInputBuffer.js';
  30  import { useMainLoopModel } from '../../hooks/useMainLoopModel.js';
  31  import { usePromptSuggestion } from '../../hooks/usePromptSuggestion.js';
  32  import { useTerminalSize } from '../../hooks/useTerminalSize.js';
  33  import { useTypeahead } from '../../hooks/useTypeahead.js';
  34  import type { BorderTextOptions } from '../../ink/render-border.js';
  35  import { stringWidth } from '../../ink/stringWidth.js';
  36  import { Box, type ClickEvent, type Key, Text, useInput } from '../../ink.js';
  37  import { useOptionalKeybindingContext } from '../../keybindings/KeybindingContext.js';
  38  import { getShortcutDisplay } from '../../keybindings/shortcutFormat.js';
  39  import { useKeybinding, useKeybindings } from '../../keybindings/useKeybinding.js';
  40  import type { MCPServerConnection } from '../../services/mcp/types.js';
  41  import { abortPromptSuggestion, logSuggestionSuppressed } from '../../services/PromptSuggestion/promptSuggestion.js';
  42  import { type ActiveSpeculationState, abortSpeculation } from '../../services/PromptSuggestion/speculation.js';
  43  import { getActiveAgentForInput, getViewedTeammateTask } from '../../state/selectors.js';
  44  import { enterTeammateView, exitTeammateView, stopOrDismissAgent } from '../../state/teammateViewHelpers.js';
  45  import type { ToolPermissionContext } from '../../Tool.js';
  46  import { getRunningTeammatesSorted } from '../../tasks/InProcessTeammateTask/InProcessTeammateTask.js';
  47  import type { InProcessTeammateTaskState } from '../../tasks/InProcessTeammateTask/types.js';
  48  import { isPanelAgentTask, type LocalAgentTaskState } from '../../tasks/LocalAgentTask/LocalAgentTask.js';
  49  import { isBackgroundTask } from '../../tasks/types.js';
  50  import { AGENT_COLOR_TO_THEME_COLOR, AGENT_COLORS, type AgentColorName } from '../../tools/AgentTool/agentColorManager.js';
  51  import type { AgentDefinition } from '../../tools/AgentTool/loadAgentsDir.js';
  52  import type { Message } from '../../types/message.js';
  53  import type { PermissionMode } from '../../types/permissions.js';
  54  import type { BaseTextInputProps, PromptInputMode, VimMode } from '../../types/textInputTypes.js';
  55  import { isAgentSwarmsEnabled } from '../../utils/agentSwarmsEnabled.js';
  56  import { count } from '../../utils/array.js';
  57  import type { AutoUpdaterResult } from '../../utils/autoUpdater.js';
  58  import { Cursor } from '../../utils/Cursor.js';
  59  import { getGlobalConfig, type PastedContent, saveGlobalConfig } from '../../utils/config.js';
  60  import { logForDebugging } from '../../utils/debug.js';
  61  import { parseDirectMemberMessage, sendDirectMemberMessage } from '../../utils/directMemberMessage.js';
  62  import type { EffortLevel } from '../../utils/effort.js';
  63  import { env } from '../../utils/env.js';
  64  import { errorMessage } from '../../utils/errors.js';
  65  import { isBilledAsExtraUsage } from '../../utils/extraUsage.js';
  66  import { getFastModeUnavailableReason, isFastModeAvailable, isFastModeCooldown, isFastModeEnabled, isFastModeSupportedByModel } from '../../utils/fastMode.js';
  67  import { isFullscreenEnvEnabled } from '../../utils/fullscreen.js';
  68  import type { PromptInputHelpers } from '../../utils/handlePromptSubmit.js';
  69  import { getImageFromClipboard, PASTE_THRESHOLD } from '../../utils/imagePaste.js';
  70  import type { ImageDimensions } from '../../utils/imageResizer.js';
  71  import { cacheImagePath, storeImage } from '../../utils/imageStore.js';
  72  import { isMacosOptionChar, MACOS_OPTION_SPECIAL_CHARS } from '../../utils/keyboardShortcuts.js';
  73  import { logError } from '../../utils/log.js';
  74  import { isOpus1mMergeEnabled, modelDisplayString } from '../../utils/model/model.js';
  75  import { setAutoModeActive } from '../../utils/permissions/autoModeState.js';
  76  import { cyclePermissionMode, getNextPermissionMode } from '../../utils/permissions/getNextPermissionMode.js';
  77  import { transitionPermissionMode } from '../../utils/permissions/permissionSetup.js';
  78  import { getPlatform } from '../../utils/platform.js';
  79  import type { ProcessUserInputContext } from '../../utils/processUserInput/processUserInput.js';
  80  import { editPromptInEditor } from '../../utils/promptEditor.js';
  81  import { hasAutoModeOptIn } from '../../utils/settings/settings.js';
  82  import { findBtwTriggerPositions } from '../../utils/sideQuestion.js';
  83  import { findSlashCommandPositions } from '../../utils/suggestions/commandSuggestions.js';
  84  import { findSlackChannelPositions, getKnownChannelsVersion, hasSlackMcpServer, subscribeKnownChannels } from '../../utils/suggestions/slackChannelSuggestions.js';
  85  import { isInProcessEnabled } from '../../utils/swarm/backends/registry.js';
  86  import { syncTeammateMode } from '../../utils/swarm/teamHelpers.js';
  87  import type { TeamSummary } from '../../utils/teamDiscovery.js';
  88  import { getTeammateColor } from '../../utils/teammate.js';
  89  import { isInProcessTeammate } from '../../utils/teammateContext.js';
  90  import { writeToMailbox } from '../../utils/teammateMailbox.js';
  91  import type { TextHighlight } from '../../utils/textHighlighting.js';
  92  import type { Theme } from '../../utils/theme.js';
  93  import { findThinkingTriggerPositions, getRainbowColor, isUltrathinkEnabled } from '../../utils/thinking.js';
  94  import { findTokenBudgetPositions } from '../../utils/tokenBudget.js';
  95  import { findUltraplanTriggerPositions, findUltrareviewTriggerPositions } from '../../utils/ultraplan/keyword.js';
  96  import { AutoModeOptInDialog } from '../AutoModeOptInDialog.js';
  97  import { BridgeDialog } from '../BridgeDialog.js';
  98  import { ConfigurableShortcutHint } from '../ConfigurableShortcutHint.js';
  99  import { getVisibleAgentTasks, useCoordinatorTaskCount } from '../CoordinatorAgentStatus.js';
 100  import { getEffortNotificationText } from '../EffortIndicator.js';
 101  import { getFastIconString } from '../FastIcon.js';
 102  import { GlobalSearchDialog } from '../GlobalSearchDialog.js';
 103  import { HistorySearchDialog } from '../HistorySearchDialog.js';
 104  import { ModelPicker } from '../ModelPicker.js';
 105  import { QuickOpenDialog } from '../QuickOpenDialog.js';
 106  import TextInput from '../TextInput.js';
 107  import { ThinkingToggle } from '../ThinkingToggle.js';
 108  import { BackgroundTasksDialog } from '../tasks/BackgroundTasksDialog.js';
 109  import { shouldHideTasksFooter } from '../tasks/taskStatusUtils.js';
 110  import { TeamsDialog } from '../teams/TeamsDialog.js';
 111  import VimTextInput from '../VimTextInput.js';
 112  import { getModeFromInput, getValueFromInput } from './inputModes.js';
 113  import { FOOTER_TEMPORARY_STATUS_TIMEOUT, Notifications } from './Notifications.js';
 114  import PromptInputFooter from './PromptInputFooter.js';
 115  import type { SuggestionItem } from './PromptInputFooterSuggestions.js';
 116  import { PromptInputModeIndicator } from './PromptInputModeIndicator.js';
 117  import { PromptInputQueuedCommands } from './PromptInputQueuedCommands.js';
 118  import { PromptInputStashNotice } from './PromptInputStashNotice.js';
 119  import { useMaybeTruncateInput } from './useMaybeTruncateInput.js';
 120  import { usePromptInputPlaceholder } from './usePromptInputPlaceholder.js';
 121  import { useShowFastIconHint } from './useShowFastIconHint.js';
 122  import { useSwarmBanner } from './useSwarmBanner.js';
 123  import { isNonSpacePrintable, isVimModeEnabled } from './utils.js';
 124  type Props = {
 125    debug: boolean;
 126    ideSelection: IDESelection | undefined;
 127    toolPermissionContext: ToolPermissionContext;
 128    setToolPermissionContext: (ctx: ToolPermissionContext) => void;
 129    apiKeyStatus: VerificationStatus;
 130    commands: Command[];
 131    agents: AgentDefinition[];
 132    isLoading: boolean;
 133    verbose: boolean;
 134    messages: Message[];
 135    onAutoUpdaterResult: (result: AutoUpdaterResult) => void;
 136    autoUpdaterResult: AutoUpdaterResult | null;
 137    input: string;
 138    onInputChange: (value: string) => void;
 139    mode: PromptInputMode;
 140    onModeChange: (mode: PromptInputMode) => void;
 141    stashedPrompt: {
 142      text: string;
 143      cursorOffset: number;
 144      pastedContents: Record<number, PastedContent>;
 145    } | undefined;
 146    setStashedPrompt: (value: {
 147      text: string;
 148      cursorOffset: number;
 149      pastedContents: Record<number, PastedContent>;
 150    } | undefined) => void;
 151    submitCount: number;
 152    onShowMessageSelector: () => void;
 153    /** Fullscreen message actions: shift+↑ enters cursor. */
 154    onMessageActionsEnter?: () => void;
 155    mcpClients: MCPServerConnection[];
 156    pastedContents: Record<number, PastedContent>;
 157    setPastedContents: React.Dispatch<React.SetStateAction<Record<number, PastedContent>>>;
 158    vimMode: VimMode;
 159    setVimMode: (mode: VimMode) => void;
 160    showBashesDialog: string | boolean;
 161    setShowBashesDialog: (show: string | boolean) => void;
 162    onExit: () => void;
 163    getToolUseContext: (messages: Message[], newMessages: Message[], abortController: AbortController, mainLoopModel: string) => ProcessUserInputContext;
 164    onSubmit: (input: string, helpers: PromptInputHelpers, speculationAccept?: {
 165      state: ActiveSpeculationState;
 166      speculationSessionTimeSavedMs: number;
 167      setAppState: (f: (prev: AppState) => AppState) => void;
 168    }, options?: {
 169      fromKeybinding?: boolean;
 170    }) => Promise<void>;
 171    onAgentSubmit?: (input: string, task: InProcessTeammateTaskState | LocalAgentTaskState, helpers: PromptInputHelpers) => Promise<void>;
 172    isSearchingHistory: boolean;
 173    setIsSearchingHistory: (isSearching: boolean) => void;
 174    onDismissSideQuestion?: () => void;
 175    isSideQuestionVisible?: boolean;
 176    helpOpen: boolean;
 177    setHelpOpen: React.Dispatch<React.SetStateAction<boolean>>;
 178    hasSuppressedDialogs?: boolean;
 179    isLocalJSXCommandActive?: boolean;
 180    insertTextRef?: React.MutableRefObject<{
 181      insert: (text: string) => void;
 182      setInputWithCursor: (value: string, cursor: number) => void;
 183      cursorOffset: number;
 184    } | null>;
 185    voiceInterimRange?: {
 186      start: number;
 187      end: number;
 188    } | null;
 189  };
 190  
 191  // Bottom slot has maxHeight="50%"; reserve lines for footer, border, status.
 192  const PROMPT_FOOTER_LINES = 5;
 193  const MIN_INPUT_VIEWPORT_LINES = 3;
 194  function PromptInput({
 195    debug,
 196    ideSelection,
 197    toolPermissionContext,
 198    setToolPermissionContext,
 199    apiKeyStatus,
 200    commands,
 201    agents,
 202    isLoading,
 203    verbose,
 204    messages,
 205    onAutoUpdaterResult,
 206    autoUpdaterResult,
 207    input,
 208    onInputChange,
 209    mode,
 210    onModeChange,
 211    stashedPrompt,
 212    setStashedPrompt,
 213    submitCount,
 214    onShowMessageSelector,
 215    onMessageActionsEnter,
 216    mcpClients,
 217    pastedContents,
 218    setPastedContents,
 219    vimMode,
 220    setVimMode,
 221    showBashesDialog,
 222    setShowBashesDialog,
 223    onExit,
 224    getToolUseContext,
 225    onSubmit: onSubmitProp,
 226    onAgentSubmit,
 227    isSearchingHistory,
 228    setIsSearchingHistory,
 229    onDismissSideQuestion,
 230    isSideQuestionVisible,
 231    helpOpen,
 232    setHelpOpen,
 233    hasSuppressedDialogs,
 234    isLocalJSXCommandActive = false,
 235    insertTextRef,
 236    voiceInterimRange
 237  }: Props): React.ReactNode {
 238    const mainLoopModel = useMainLoopModel();
 239    // A local-jsx command (e.g., /mcp while agent is running) renders a full-
 240    // screen dialog on top of PromptInput via the immediate-command path with
 241    // shouldHidePromptInput: false. Those dialogs don't register in the overlay
 242    // system, so treat them as a modal overlay here to stop navigation keys from
 243    // leaking into TextInput/footer handlers and stacking a second dialog.
 244    const isModalOverlayActive = useIsModalOverlayActive() || isLocalJSXCommandActive;
 245    const [isAutoUpdating, setIsAutoUpdating] = useState(false);
 246    const [exitMessage, setExitMessage] = useState<{
 247      show: boolean;
 248      key?: string;
 249    }>({
 250      show: false
 251    });
 252    const [cursorOffset, setCursorOffset] = useState<number>(input.length);
 253    // Track the last input value set via internal handlers so we can detect
 254    // external input changes (e.g. speech-to-text injection) and move cursor to end.
 255    const lastInternalInputRef = React.useRef(input);
 256    if (input !== lastInternalInputRef.current) {
 257      // Input changed externally (not through any internal handler) — move cursor to end
 258      setCursorOffset(input.length);
 259      lastInternalInputRef.current = input;
 260    }
 261    // Wrap onInputChange to track internal changes before they trigger re-render
 262    const trackAndSetInput = React.useCallback((value: string) => {
 263      lastInternalInputRef.current = value;
 264      onInputChange(value);
 265    }, [onInputChange]);
 266    // Expose an insertText function so callers (e.g. STT) can splice text at the
 267    // current cursor position instead of replacing the entire input.
 268    if (insertTextRef) {
 269      insertTextRef.current = {
 270        cursorOffset,
 271        insert: (text: string) => {
 272          const needsSpace = cursorOffset === input.length && input.length > 0 && !/\s$/.test(input);
 273          const insertText = needsSpace ? ' ' + text : text;
 274          const newValue = input.slice(0, cursorOffset) + insertText + input.slice(cursorOffset);
 275          lastInternalInputRef.current = newValue;
 276          onInputChange(newValue);
 277          setCursorOffset(cursorOffset + insertText.length);
 278        },
 279        setInputWithCursor: (value: string, cursor: number) => {
 280          lastInternalInputRef.current = value;
 281          onInputChange(value);
 282          setCursorOffset(cursor);
 283        }
 284      };
 285    }
 286    const store = useAppStateStore();
 287    const setAppState = useSetAppState();
 288    const tasks = useAppState(s => s.tasks);
 289    const replBridgeConnected = useAppState(s => s.replBridgeConnected);
 290    const replBridgeExplicit = useAppState(s => s.replBridgeExplicit);
 291    const replBridgeReconnecting = useAppState(s => s.replBridgeReconnecting);
 292    // Must match BridgeStatusIndicator's render condition (PromptInputFooter.tsx) —
 293    // the pill returns null for implicit-and-not-reconnecting, so nav must too,
 294    // otherwise bridge becomes an invisible selection stop.
 295    const bridgeFooterVisible = replBridgeConnected && (replBridgeExplicit || replBridgeReconnecting);
 296    // Tmux pill (ant-only) — visible when there's an active tungsten session
 297    const hasTungstenSession = useAppState(s => "external" === 'ant' && s.tungstenActiveSession !== undefined);
 298    const tmuxFooterVisible = "external" === 'ant' && hasTungstenSession;
 299    // WebBrowser pill — visible when a browser is open
 300    const bagelFooterVisible = useAppState(s => false);
 301    const teamContext = useAppState(s => s.teamContext);
 302    const queuedCommands = useCommandQueue();
 303    const promptSuggestionState = useAppState(s => s.promptSuggestion);
 304    const speculation = useAppState(s => s.speculation);
 305    const speculationSessionTimeSavedMs = useAppState(s => s.speculationSessionTimeSavedMs);
 306    const viewingAgentTaskId = useAppState(s => s.viewingAgentTaskId);
 307    const viewSelectionMode = useAppState(s => s.viewSelectionMode);
 308    const showSpinnerTree = useAppState(s => s.expandedView) === 'teammates';
 309    const {
 310      companion: _companion,
 311      companionMuted
 312    } = feature('BUDDY') ? getGlobalConfig() : {
 313      companion: undefined,
 314      companionMuted: undefined
 315    };
 316    const companionFooterVisible = !!_companion && !companionMuted;
 317    // Brief mode: BriefSpinner/BriefIdleStatus own the 2-row footprint above
 318    // the input. Dropping marginTop here lets the spinner sit flush against
 319    // the input bar. viewingAgentTaskId mirrors the gate on both (Spinner.tsx,
 320    // REPL.tsx) — teammate view falls back to SpinnerWithVerbInner which has
 321    // its own marginTop, so the gap stays even without ours.
 322    const briefOwnsGap = feature('KAIROS') || feature('KAIROS_BRIEF') ?
 323    // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
 324    useAppState(s => s.isBriefOnly) && !viewingAgentTaskId : false;
 325    const mainLoopModel_ = useAppState(s => s.mainLoopModel);
 326    const mainLoopModelForSession = useAppState(s => s.mainLoopModelForSession);
 327    const thinkingEnabled = useAppState(s => s.thinkingEnabled);
 328    const isFastMode = useAppState(s => isFastModeEnabled() ? s.fastMode : false);
 329    const effortValue = useAppState(s => s.effortValue);
 330    const viewedTeammate = getViewedTeammateTask(store.getState());
 331    const viewingAgentName = viewedTeammate?.identity.agentName;
 332    // identity.color is typed as `string | undefined` (not AgentColorName) because
 333    // teammate identity comes from file-based config. Validate before casting to
 334    // ensure we only use valid color names (falls back to cyan if invalid).
 335    const viewingAgentColor = viewedTeammate?.identity.color && AGENT_COLORS.includes(viewedTeammate.identity.color as AgentColorName) ? viewedTeammate.identity.color as AgentColorName : undefined;
 336    // In-process teammates sorted alphabetically for footer team selector
 337    const inProcessTeammates = useMemo(() => getRunningTeammatesSorted(tasks), [tasks]);
 338  
 339    // Team mode: all background tasks are in-process teammates
 340    const isTeammateMode = inProcessTeammates.length > 0 || viewedTeammate !== undefined;
 341  
 342    // When viewing a teammate, show their permission mode in the footer instead of the leader's
 343    const effectiveToolPermissionContext = useMemo((): ToolPermissionContext => {
 344      if (viewedTeammate) {
 345        return {
 346          ...toolPermissionContext,
 347          mode: viewedTeammate.permissionMode
 348        };
 349      }
 350      return toolPermissionContext;
 351    }, [viewedTeammate, toolPermissionContext]);
 352    const {
 353      historyQuery,
 354      setHistoryQuery,
 355      historyMatch,
 356      historyFailedMatch
 357    } = useHistorySearch(entry => {
 358      setPastedContents(entry.pastedContents);
 359      void onSubmit(entry.display);
 360    }, input, trackAndSetInput, setCursorOffset, cursorOffset, onModeChange, mode, isSearchingHistory, setIsSearchingHistory, setPastedContents, pastedContents);
 361    // Counter for paste IDs (shared between images and text).
 362    // Compute initial value once from existing messages (for --continue/--resume).
 363    // useRef(fn()) evaluates fn() on every render and discards the result after
 364    // mount — getInitialPasteId walks all messages + regex-scans text blocks,
 365    // so guard with a lazy-init pattern to run it exactly once.
 366    const nextPasteIdRef = useRef(-1);
 367    if (nextPasteIdRef.current === -1) {
 368      nextPasteIdRef.current = getInitialPasteId(messages);
 369    }
 370    // Armed by onImagePaste; if the very next keystroke is a non-space
 371    // printable, inputFilter prepends a space before it. Any other input
 372    // (arrow, escape, backspace, paste, space) disarms without inserting.
 373    const pendingSpaceAfterPillRef = useRef(false);
 374    const [showTeamsDialog, setShowTeamsDialog] = useState(false);
 375    const [showBridgeDialog, setShowBridgeDialog] = useState(false);
 376    const [teammateFooterIndex, setTeammateFooterIndex] = useState(0);
 377    // -1 sentinel: tasks pill is selected but no specific agent row is selected yet.
 378    // First ↓ selects the pill, second ↓ moves to row 0. Prevents double-select
 379    // of pill + row when both bg tasks (pill) and forked agents (rows) are visible.
 380    const coordinatorTaskIndex = useAppState(s => s.coordinatorTaskIndex);
 381    const setCoordinatorTaskIndex = useCallback((v: number | ((prev: number) => number)) => setAppState(prev => {
 382      const next = typeof v === 'function' ? v(prev.coordinatorTaskIndex) : v;
 383      if (next === prev.coordinatorTaskIndex) return prev;
 384      return {
 385        ...prev,
 386        coordinatorTaskIndex: next
 387      };
 388    }), [setAppState]);
 389    const coordinatorTaskCount = useCoordinatorTaskCount();
 390    // The pill (BackgroundTaskStatus) only renders when non-local_agent bg tasks
 391    // exist. When only local_agent tasks are running (coordinator/fork mode), the
 392    // pill is absent, so the -1 sentinel would leave nothing visually selected.
 393    // In that case, skip -1 and treat 0 as the minimum selectable index.
 394    const hasBgTaskPill = useMemo(() => Object.values(tasks).some(t => isBackgroundTask(t) && !("external" === 'ant' && isPanelAgentTask(t))), [tasks]);
 395    const minCoordinatorIndex = hasBgTaskPill ? -1 : 0;
 396    // Clamp index when tasks complete and the list shrinks beneath the cursor
 397    useEffect(() => {
 398      if (coordinatorTaskIndex >= coordinatorTaskCount) {
 399        setCoordinatorTaskIndex(Math.max(minCoordinatorIndex, coordinatorTaskCount - 1));
 400      } else if (coordinatorTaskIndex < minCoordinatorIndex) {
 401        setCoordinatorTaskIndex(minCoordinatorIndex);
 402      }
 403    }, [coordinatorTaskCount, coordinatorTaskIndex, minCoordinatorIndex]);
 404    const [isPasting, setIsPasting] = useState(false);
 405    const [isExternalEditorActive, setIsExternalEditorActive] = useState(false);
 406    const [showModelPicker, setShowModelPicker] = useState(false);
 407    const [showQuickOpen, setShowQuickOpen] = useState(false);
 408    const [showGlobalSearch, setShowGlobalSearch] = useState(false);
 409    const [showHistoryPicker, setShowHistoryPicker] = useState(false);
 410    const [showFastModePicker, setShowFastModePicker] = useState(false);
 411    const [showThinkingToggle, setShowThinkingToggle] = useState(false);
 412    const [showAutoModeOptIn, setShowAutoModeOptIn] = useState(false);
 413    const [previousModeBeforeAuto, setPreviousModeBeforeAuto] = useState<PermissionMode | null>(null);
 414    const autoModeOptInTimeoutRef = useRef<NodeJS.Timeout | null>(null);
 415  
 416    // Check if cursor is on the first line of input
 417    const isCursorOnFirstLine = useMemo(() => {
 418      const firstNewlineIndex = input.indexOf('\n');
 419      if (firstNewlineIndex === -1) {
 420        return true; // No newlines, cursor is always on first line
 421      }
 422      return cursorOffset <= firstNewlineIndex;
 423    }, [input, cursorOffset]);
 424    const isCursorOnLastLine = useMemo(() => {
 425      const lastNewlineIndex = input.lastIndexOf('\n');
 426      if (lastNewlineIndex === -1) {
 427        return true; // No newlines, cursor is always on last line
 428      }
 429      return cursorOffset > lastNewlineIndex;
 430    }, [input, cursorOffset]);
 431  
 432    // Derive team info from teamContext (no filesystem I/O needed)
 433    // A session can only lead one team at a time
 434    const cachedTeams: TeamSummary[] = useMemo(() => {
 435      if (!isAgentSwarmsEnabled()) return [];
 436      // In-process mode uses Shift+Down/Up navigation instead of footer menu
 437      if (isInProcessEnabled()) return [];
 438      if (!teamContext) {
 439        return [];
 440      }
 441      const teammateCount = count(Object.values(teamContext.teammates), t => t.name !== 'team-lead');
 442      return [{
 443        name: teamContext.teamName,
 444        memberCount: teammateCount,
 445        runningCount: 0,
 446        idleCount: 0
 447      }];
 448    }, [teamContext]);
 449  
 450    // ─── Footer pill navigation ─────────────────────────────────────────────
 451    // Which pills render below the input box. Order here IS the nav order
 452    // (down/right = forward, up/left = back). Selection lives in AppState so
 453    // pills rendered outside PromptInput (CompanionSprite) can read focus.
 454    const runningTaskCount = useMemo(() => count(Object.values(tasks), t => t.status === 'running'), [tasks]);
 455    // Panel shows retained-completed agents too (getVisibleAgentTasks), so the
 456    // pill must stay navigable whenever the panel has rows — not just when
 457    // something is running.
 458    const tasksFooterVisible = (runningTaskCount > 0 || "external" === 'ant' && coordinatorTaskCount > 0) && !shouldHideTasksFooter(tasks, showSpinnerTree);
 459    const teamsFooterVisible = cachedTeams.length > 0;
 460    const footerItems = useMemo(() => [tasksFooterVisible && 'tasks', tmuxFooterVisible && 'tmux', bagelFooterVisible && 'bagel', teamsFooterVisible && 'teams', bridgeFooterVisible && 'bridge', companionFooterVisible && 'companion'].filter(Boolean) as FooterItem[], [tasksFooterVisible, tmuxFooterVisible, bagelFooterVisible, teamsFooterVisible, bridgeFooterVisible, companionFooterVisible]);
 461  
 462    // Effective selection: null if the selected pill stopped rendering (bridge
 463    // disconnected, task finished). The derivation makes the UI correct
 464    // immediately; the useEffect below clears the raw state so it doesn't
 465    // resurrect when the same pill reappears (new task starts → focus stolen).
 466    const rawFooterSelection = useAppState(s => s.footerSelection);
 467    const footerItemSelected = rawFooterSelection && footerItems.includes(rawFooterSelection) ? rawFooterSelection : null;
 468    useEffect(() => {
 469      if (rawFooterSelection && !footerItemSelected) {
 470        setAppState(prev => prev.footerSelection === null ? prev : {
 471          ...prev,
 472          footerSelection: null
 473        });
 474      }
 475    }, [rawFooterSelection, footerItemSelected, setAppState]);
 476    const tasksSelected = footerItemSelected === 'tasks';
 477    const tmuxSelected = footerItemSelected === 'tmux';
 478    const bagelSelected = footerItemSelected === 'bagel';
 479    const teamsSelected = footerItemSelected === 'teams';
 480    const bridgeSelected = footerItemSelected === 'bridge';
 481    function selectFooterItem(item: FooterItem | null): void {
 482      setAppState(prev => prev.footerSelection === item ? prev : {
 483        ...prev,
 484        footerSelection: item
 485      });
 486      if (item === 'tasks') {
 487        setTeammateFooterIndex(0);
 488        setCoordinatorTaskIndex(minCoordinatorIndex);
 489      }
 490    }
 491  
 492    // delta: +1 = down/right, -1 = up/left. Returns true if nav happened
 493    // (including deselecting at the start), false if at a boundary.
 494    function navigateFooter(delta: 1 | -1, exitAtStart = false): boolean {
 495      const idx = footerItemSelected ? footerItems.indexOf(footerItemSelected) : -1;
 496      const next = footerItems[idx + delta];
 497      if (next) {
 498        selectFooterItem(next);
 499        return true;
 500      }
 501      if (delta < 0 && exitAtStart) {
 502        selectFooterItem(null);
 503        return true;
 504      }
 505      return false;
 506    }
 507  
 508    // Prompt suggestion hook - reads suggestions generated by forked agent in query loop
 509    const {
 510      suggestion: promptSuggestion,
 511      markAccepted,
 512      logOutcomeAtSubmission,
 513      markShown
 514    } = usePromptSuggestion({
 515      inputValue: input,
 516      isAssistantResponding: isLoading
 517    });
 518    const displayedValue = useMemo(() => isSearchingHistory && historyMatch ? getValueFromInput(typeof historyMatch === 'string' ? historyMatch : historyMatch.display) : input, [isSearchingHistory, historyMatch, input]);
 519    const thinkTriggers = useMemo(() => findThinkingTriggerPositions(displayedValue), [displayedValue]);
 520    const ultraplanSessionUrl = useAppState(s => s.ultraplanSessionUrl);
 521    const ultraplanLaunching = useAppState(s => s.ultraplanLaunching);
 522    const ultraplanTriggers = useMemo(() => feature('ULTRAPLAN') && !ultraplanSessionUrl && !ultraplanLaunching ? findUltraplanTriggerPositions(displayedValue) : [], [displayedValue, ultraplanSessionUrl, ultraplanLaunching]);
 523    const ultrareviewTriggers = useMemo(() => isUltrareviewEnabled() ? findUltrareviewTriggerPositions(displayedValue) : [], [displayedValue]);
 524    const btwTriggers = useMemo(() => findBtwTriggerPositions(displayedValue), [displayedValue]);
 525    const buddyTriggers = useMemo(() => findBuddyTriggerPositions(displayedValue), [displayedValue]);
 526    const slashCommandTriggers = useMemo(() => {
 527      const positions = findSlashCommandPositions(displayedValue);
 528      // Only highlight valid commands
 529      return positions.filter(pos => {
 530        const commandName = displayedValue.slice(pos.start + 1, pos.end); // +1 to skip "/"
 531        return hasCommand(commandName, commands);
 532      });
 533    }, [displayedValue, commands]);
 534    const tokenBudgetTriggers = useMemo(() => feature('TOKEN_BUDGET') ? findTokenBudgetPositions(displayedValue) : [], [displayedValue]);
 535    const knownChannelsVersion = useSyncExternalStore(subscribeKnownChannels, getKnownChannelsVersion);
 536    const slackChannelTriggers = useMemo(() => hasSlackMcpServer(store.getState().mcp.clients) ? findSlackChannelPositions(displayedValue) : [],
 537    // eslint-disable-next-line react-hooks/exhaustive-deps -- store is a stable ref
 538    [displayedValue, knownChannelsVersion]);
 539  
 540    // Find @name mentions and highlight with team member's color
 541    const memberMentionHighlights = useMemo((): Array<{
 542      start: number;
 543      end: number;
 544      themeColor: keyof Theme;
 545    }> => {
 546      if (!isAgentSwarmsEnabled()) return [];
 547      if (!teamContext?.teammates) return [];
 548      const highlights: Array<{
 549        start: number;
 550        end: number;
 551        themeColor: keyof Theme;
 552      }> = [];
 553      const members = teamContext.teammates;
 554      if (!members) return highlights;
 555  
 556      // Find all @name patterns in the input
 557      const regex = /(^|\s)@([\w-]+)/g;
 558      const memberValues = Object.values(members);
 559      let match;
 560      while ((match = regex.exec(displayedValue)) !== null) {
 561        const leadingSpace = match[1] ?? '';
 562        const nameStart = match.index + leadingSpace.length;
 563        const fullMatch = match[0].trimStart();
 564        const name = match[2];
 565  
 566        // Check if this name matches a team member
 567        const member = memberValues.find(t => t.name === name);
 568        if (member?.color) {
 569          const themeColor = AGENT_COLOR_TO_THEME_COLOR[member.color as AgentColorName];
 570          if (themeColor) {
 571            highlights.push({
 572              start: nameStart,
 573              end: nameStart + fullMatch.length,
 574              themeColor
 575            });
 576          }
 577        }
 578      }
 579      return highlights;
 580    }, [displayedValue, teamContext]);
 581    const imageRefPositions = useMemo(() => parseReferences(displayedValue).filter(r => r.match.startsWith('[Image')).map(r => ({
 582      start: r.index,
 583      end: r.index + r.match.length
 584    })), [displayedValue]);
 585  
 586    // chip.start is the "selected" state: the inverted chip IS the cursor.
 587    // chip.end stays a normal position so you can park the cursor right after
 588    // `]` like any other character.
 589    const cursorAtImageChip = imageRefPositions.some(r => r.start === cursorOffset);
 590  
 591    // up/down movement or a fullscreen click can land the cursor strictly
 592    // inside a chip; snap to the nearer boundary so it's never editable
 593    // char-by-char.
 594    useEffect(() => {
 595      const inside = imageRefPositions.find(r => cursorOffset > r.start && cursorOffset < r.end);
 596      if (inside) {
 597        const mid = (inside.start + inside.end) / 2;
 598        setCursorOffset(cursorOffset < mid ? inside.start : inside.end);
 599      }
 600    }, [cursorOffset, imageRefPositions, setCursorOffset]);
 601    const combinedHighlights = useMemo((): TextHighlight[] => {
 602      const highlights: TextHighlight[] = [];
 603  
 604      // Invert the [Image #N] chip when the cursor is at chip.start (the
 605      // "selected" state) so backspace-to-delete is visually obvious.
 606      for (const ref of imageRefPositions) {
 607        if (cursorOffset === ref.start) {
 608          highlights.push({
 609            start: ref.start,
 610            end: ref.end,
 611            color: undefined,
 612            inverse: true,
 613            priority: 8
 614          });
 615        }
 616      }
 617      if (isSearchingHistory && historyMatch && !historyFailedMatch) {
 618        highlights.push({
 619          start: cursorOffset,
 620          end: cursorOffset + historyQuery.length,
 621          color: 'warning',
 622          priority: 20
 623        });
 624      }
 625  
 626      // Add "btw" highlighting (solid yellow)
 627      for (const trigger of btwTriggers) {
 628        highlights.push({
 629          start: trigger.start,
 630          end: trigger.end,
 631          color: 'warning',
 632          priority: 15
 633        });
 634      }
 635  
 636      // Add /command highlighting (blue)
 637      for (const trigger of slashCommandTriggers) {
 638        highlights.push({
 639          start: trigger.start,
 640          end: trigger.end,
 641          color: 'suggestion',
 642          priority: 5
 643        });
 644      }
 645  
 646      // Add token budget highlighting (blue)
 647      for (const trigger of tokenBudgetTriggers) {
 648        highlights.push({
 649          start: trigger.start,
 650          end: trigger.end,
 651          color: 'suggestion',
 652          priority: 5
 653        });
 654      }
 655      for (const trigger of slackChannelTriggers) {
 656        highlights.push({
 657          start: trigger.start,
 658          end: trigger.end,
 659          color: 'suggestion',
 660          priority: 5
 661        });
 662      }
 663  
 664      // Add @name highlighting with team member's color
 665      for (const mention of memberMentionHighlights) {
 666        highlights.push({
 667          start: mention.start,
 668          end: mention.end,
 669          color: mention.themeColor,
 670          priority: 5
 671        });
 672      }
 673  
 674      // Dim interim voice dictation text
 675      if (voiceInterimRange) {
 676        highlights.push({
 677          start: voiceInterimRange.start,
 678          end: voiceInterimRange.end,
 679          color: undefined,
 680          dimColor: true,
 681          priority: 1
 682        });
 683      }
 684  
 685      // Rainbow highlighting for ultrathink keyword (per-character cycling colors)
 686      if (isUltrathinkEnabled()) {
 687        for (const trigger of thinkTriggers) {
 688          for (let i = trigger.start; i < trigger.end; i++) {
 689            highlights.push({
 690              start: i,
 691              end: i + 1,
 692              color: getRainbowColor(i - trigger.start),
 693              shimmerColor: getRainbowColor(i - trigger.start, true),
 694              priority: 10
 695            });
 696          }
 697        }
 698      }
 699  
 700      // Same rainbow treatment for the ultraplan keyword
 701      if (feature('ULTRAPLAN')) {
 702        for (const trigger of ultraplanTriggers) {
 703          for (let i = trigger.start; i < trigger.end; i++) {
 704            highlights.push({
 705              start: i,
 706              end: i + 1,
 707              color: getRainbowColor(i - trigger.start),
 708              shimmerColor: getRainbowColor(i - trigger.start, true),
 709              priority: 10
 710            });
 711          }
 712        }
 713      }
 714  
 715      // Same rainbow treatment for the ultrareview keyword
 716      for (const trigger of ultrareviewTriggers) {
 717        for (let i = trigger.start; i < trigger.end; i++) {
 718          highlights.push({
 719            start: i,
 720            end: i + 1,
 721            color: getRainbowColor(i - trigger.start),
 722            shimmerColor: getRainbowColor(i - trigger.start, true),
 723            priority: 10
 724          });
 725        }
 726      }
 727  
 728      // Rainbow for /buddy
 729      for (const trigger of buddyTriggers) {
 730        for (let i = trigger.start; i < trigger.end; i++) {
 731          highlights.push({
 732            start: i,
 733            end: i + 1,
 734            color: getRainbowColor(i - trigger.start),
 735            shimmerColor: getRainbowColor(i - trigger.start, true),
 736            priority: 10
 737          });
 738        }
 739      }
 740      return highlights;
 741    }, [isSearchingHistory, historyQuery, historyMatch, historyFailedMatch, cursorOffset, btwTriggers, imageRefPositions, memberMentionHighlights, slashCommandTriggers, tokenBudgetTriggers, slackChannelTriggers, displayedValue, voiceInterimRange, thinkTriggers, ultraplanTriggers, ultrareviewTriggers, buddyTriggers]);
 742    const {
 743      addNotification,
 744      removeNotification
 745    } = useNotifications();
 746  
 747    // Show ultrathink notification
 748    useEffect(() => {
 749      if (thinkTriggers.length && isUltrathinkEnabled()) {
 750        addNotification({
 751          key: 'ultrathink-active',
 752          text: 'Effort set to high for this turn',
 753          priority: 'immediate',
 754          timeoutMs: 5000
 755        });
 756      } else {
 757        removeNotification('ultrathink-active');
 758      }
 759    }, [addNotification, removeNotification, thinkTriggers.length]);
 760    useEffect(() => {
 761      if (feature('ULTRAPLAN') && ultraplanTriggers.length) {
 762        addNotification({
 763          key: 'ultraplan-active',
 764          text: 'This prompt will launch an ultraplan session in Claude Code on the web',
 765          priority: 'immediate',
 766          timeoutMs: 5000
 767        });
 768      } else {
 769        removeNotification('ultraplan-active');
 770      }
 771    }, [addNotification, removeNotification, ultraplanTriggers.length]);
 772    useEffect(() => {
 773      if (isUltrareviewEnabled() && ultrareviewTriggers.length) {
 774        addNotification({
 775          key: 'ultrareview-active',
 776          text: 'Run /ultrareview after Claude finishes to review these changes in the cloud',
 777          priority: 'immediate',
 778          timeoutMs: 5000
 779        });
 780      }
 781    }, [addNotification, ultrareviewTriggers.length]);
 782  
 783    // Track input length for stash hint
 784    const prevInputLengthRef = useRef(input.length);
 785    const peakInputLengthRef = useRef(input.length);
 786  
 787    // Dismiss stash hint when user makes any input change
 788    const dismissStashHint = useCallback(() => {
 789      removeNotification('stash-hint');
 790    }, [removeNotification]);
 791  
 792    // Show stash hint when user gradually clears substantial input
 793    useEffect(() => {
 794      const prevLength = prevInputLengthRef.current;
 795      const peakLength = peakInputLengthRef.current;
 796      const currentLength = input.length;
 797      prevInputLengthRef.current = currentLength;
 798  
 799      // Update peak when input grows
 800      if (currentLength > peakLength) {
 801        peakInputLengthRef.current = currentLength;
 802        return;
 803      }
 804  
 805      // Reset state when input is empty
 806      if (currentLength === 0) {
 807        peakInputLengthRef.current = 0;
 808        return;
 809      }
 810  
 811      // Detect gradual clear: peak was high, current is low, but this wasn't a single big jump
 812      // (rapid clears like esc-esc go from 20+ to 0 in one step)
 813      const clearedSubstantialInput = peakLength >= 20 && currentLength <= 5;
 814      const wasRapidClear = prevLength >= 20 && currentLength <= 5;
 815      if (clearedSubstantialInput && !wasRapidClear) {
 816        const config = getGlobalConfig();
 817        if (!config.hasUsedStash) {
 818          addNotification({
 819            key: 'stash-hint',
 820            jsx: <Text dimColor>
 821                Tip:{' '}
 822                <ConfigurableShortcutHint action="chat:stash" context="Chat" fallback="ctrl+s" description="stash" />
 823              </Text>,
 824            priority: 'immediate',
 825            timeoutMs: FOOTER_TEMPORARY_STATUS_TIMEOUT
 826          });
 827        }
 828        peakInputLengthRef.current = currentLength;
 829      }
 830    }, [input.length, addNotification]);
 831  
 832    // Initialize input buffer for undo functionality
 833    const {
 834      pushToBuffer,
 835      undo,
 836      canUndo,
 837      clearBuffer
 838    } = useInputBuffer({
 839      maxBufferSize: 50,
 840      debounceMs: 1000
 841    });
 842    useMaybeTruncateInput({
 843      input,
 844      pastedContents,
 845      onInputChange: trackAndSetInput,
 846      setCursorOffset,
 847      setPastedContents
 848    });
 849    const defaultPlaceholder = usePromptInputPlaceholder({
 850      input,
 851      submitCount,
 852      viewingAgentName
 853    });
 854    const onChange = useCallback((value: string) => {
 855      if (value === '?') {
 856        logEvent('tengu_help_toggled', {});
 857        setHelpOpen(v => !v);
 858        return;
 859      }
 860      setHelpOpen(false);
 861  
 862      // Dismiss stash hint when user makes any input change
 863      dismissStashHint();
 864  
 865      // Cancel any pending prompt suggestion and speculation when user types
 866      abortPromptSuggestion();
 867      abortSpeculation(setAppState);
 868  
 869      // Check if this is a single character insertion at the start
 870      const isSingleCharInsertion = value.length === input.length + 1;
 871      const insertedAtStart = cursorOffset === 0;
 872      const mode = getModeFromInput(value);
 873      if (insertedAtStart && mode !== 'prompt') {
 874        if (isSingleCharInsertion) {
 875          onModeChange(mode);
 876          return;
 877        }
 878        // Multi-char insertion into empty input (e.g. tab-accepting "! gcloud auth login")
 879        if (input.length === 0) {
 880          onModeChange(mode);
 881          const valueWithoutMode = getValueFromInput(value).replaceAll('\t', '    ');
 882          pushToBuffer(input, cursorOffset, pastedContents);
 883          trackAndSetInput(valueWithoutMode);
 884          setCursorOffset(valueWithoutMode.length);
 885          return;
 886        }
 887      }
 888      const processedValue = value.replaceAll('\t', '    ');
 889  
 890      // Push current state to buffer before making changes
 891      if (input !== processedValue) {
 892        pushToBuffer(input, cursorOffset, pastedContents);
 893      }
 894  
 895      // Deselect footer items when user types
 896      setAppState(prev => prev.footerSelection === null ? prev : {
 897        ...prev,
 898        footerSelection: null
 899      });
 900      trackAndSetInput(processedValue);
 901    }, [trackAndSetInput, onModeChange, input, cursorOffset, pushToBuffer, pastedContents, dismissStashHint, setAppState]);
 902    const {
 903      resetHistory,
 904      onHistoryUp,
 905      onHistoryDown,
 906      dismissSearchHint,
 907      historyIndex
 908    } = useArrowKeyHistory((value: string, historyMode: HistoryMode, pastedContents: Record<number, PastedContent>) => {
 909      onChange(value);
 910      onModeChange(historyMode);
 911      setPastedContents(pastedContents);
 912    }, input, pastedContents, setCursorOffset, mode);
 913  
 914    // Dismiss search hint when user starts searching
 915    useEffect(() => {
 916      if (isSearchingHistory) {
 917        dismissSearchHint();
 918      }
 919    }, [isSearchingHistory, dismissSearchHint]);
 920  
 921    // Only use history navigation when there are 0 or 1 slash command suggestions.
 922    // Footer nav is NOT here — when a pill is selected, TextInput focus=false so
 923    // these never fire. The Footer keybinding context handles ↑/↓ instead.
 924    function handleHistoryUp() {
 925      if (suggestions.length > 1) {
 926        return;
 927      }
 928  
 929      // Only navigate history when cursor is on the first line.
 930      // In multiline inputs, up arrow should move the cursor (handled by TextInput)
 931      // and only trigger history when at the top of the input.
 932      if (!isCursorOnFirstLine) {
 933        return;
 934      }
 935  
 936      // If there's an editable queued command, move it to the input for editing when UP is pressed
 937      const hasEditableCommand = queuedCommands.some(isQueuedCommandEditable);
 938      if (hasEditableCommand) {
 939        void popAllCommandsFromQueue();
 940        return;
 941      }
 942      onHistoryUp();
 943    }
 944    function handleHistoryDown() {
 945      if (suggestions.length > 1) {
 946        return;
 947      }
 948  
 949      // Only navigate history/footer when cursor is on the last line.
 950      // In multiline inputs, down arrow should move the cursor (handled by TextInput)
 951      // and only trigger navigation when at the bottom of the input.
 952      if (!isCursorOnLastLine) {
 953        return;
 954      }
 955  
 956      // At bottom of history → enter footer at first visible pill
 957      if (onHistoryDown() && footerItems.length > 0) {
 958        const first = footerItems[0]!;
 959        selectFooterItem(first);
 960        if (first === 'tasks' && !getGlobalConfig().hasSeenTasksHint) {
 961          saveGlobalConfig(c => c.hasSeenTasksHint ? c : {
 962            ...c,
 963            hasSeenTasksHint: true
 964          });
 965        }
 966      }
 967    }
 968  
 969    // Create a suggestions state directly - we'll sync it with useTypeahead later
 970    const [suggestionsState, setSuggestionsStateRaw] = useState<{
 971      suggestions: SuggestionItem[];
 972      selectedSuggestion: number;
 973      commandArgumentHint?: string;
 974    }>({
 975      suggestions: [],
 976      selectedSuggestion: -1,
 977      commandArgumentHint: undefined
 978    });
 979  
 980    // Setter for suggestions state
 981    const setSuggestionsState = useCallback((updater: typeof suggestionsState | ((prev: typeof suggestionsState) => typeof suggestionsState)) => {
 982      setSuggestionsStateRaw(prev => typeof updater === 'function' ? updater(prev) : updater);
 983    }, []);
 984    const onSubmit = useCallback(async (inputParam: string, isSubmittingSlashCommand = false) => {
 985      inputParam = inputParam.trimEnd();
 986  
 987      // Don't submit if a footer indicator is being opened. Read fresh from
 988      // store — footer:openSelected calls selectFooterItem(null) then onSubmit
 989      // in the same tick, and the closure value hasn't updated yet. Apply the
 990      // same "still visible?" derivation as footerItemSelected so a stale
 991      // selection (pill disappeared) doesn't swallow Enter.
 992      const state = store.getState();
 993      if (state.footerSelection && footerItems.includes(state.footerSelection)) {
 994        return;
 995      }
 996  
 997      // Enter in selection modes confirms selection (useBackgroundTaskNavigation).
 998      // BaseTextInput's useInput registers before that hook (child effects fire first),
 999      // so without this guard Enter would double-fire and auto-submit the suggestion.
1000      if (state.viewSelectionMode === 'selecting-agent') {
1001        return;
1002      }
1003  
1004      // Check for images early - we need this for suggestion logic below
1005      const hasImages = Object.values(pastedContents).some(c => c.type === 'image');
1006  
1007      // If input is empty OR matches the suggestion, submit it
1008      // But if there are images attached, don't auto-accept the suggestion -
1009      // the user wants to submit just the image(s).
1010      // Only in leader view — promptSuggestion is leader-context, not teammate.
1011      const suggestionText = promptSuggestionState.text;
1012      const inputMatchesSuggestion = inputParam.trim() === '' || inputParam === suggestionText;
1013      if (inputMatchesSuggestion && suggestionText && !hasImages && !state.viewingAgentTaskId) {
1014        // If speculation is active, inject messages immediately as they stream
1015        if (speculation.status === 'active') {
1016          markAccepted();
1017          // skipReset: resetSuggestion would abort the speculation before we accept it
1018          logOutcomeAtSubmission(suggestionText, {
1019            skipReset: true
1020          });
1021          void onSubmitProp(suggestionText, {
1022            setCursorOffset,
1023            clearBuffer,
1024            resetHistory
1025          }, {
1026            state: speculation,
1027            speculationSessionTimeSavedMs: speculationSessionTimeSavedMs,
1028            setAppState
1029          });
1030          return; // Skip normal query - speculation handled it
1031        }
1032  
1033        // Regular suggestion acceptance (requires shownAt > 0)
1034        if (promptSuggestionState.shownAt > 0) {
1035          markAccepted();
1036          inputParam = suggestionText;
1037        }
1038      }
1039  
1040      // Handle @name direct message
1041      if (isAgentSwarmsEnabled()) {
1042        const directMessage = parseDirectMemberMessage(inputParam);
1043        if (directMessage) {
1044          const result = await sendDirectMemberMessage(directMessage.recipientName, directMessage.message, teamContext, writeToMailbox);
1045          if (result.success) {
1046            addNotification({
1047              key: 'direct-message-sent',
1048              text: `Sent to @${result.recipientName}`,
1049              priority: 'immediate',
1050              timeoutMs: 3000
1051            });
1052            trackAndSetInput('');
1053            setCursorOffset(0);
1054            clearBuffer();
1055            resetHistory();
1056            return;
1057          } else if (result.error === 'no_team_context') {
1058            // No team context - fall through to normal prompt submission
1059          } else {
1060            // Unknown recipient - fall through to normal prompt submission
1061            // This allows e.g. "@utils explain this code" to be sent as a prompt
1062          }
1063        }
1064      }
1065  
1066      // Allow submission if there are images attached, even without text
1067      if (inputParam.trim() === '' && !hasImages) {
1068        return;
1069      }
1070  
1071      // PromptInput UX: Check if suggestions dropdown is showing
1072      // For directory suggestions, allow submission (Tab is used for completion)
1073      const hasDirectorySuggestions = suggestionsState.suggestions.length > 0 && suggestionsState.suggestions.every(s => s.description === 'directory');
1074      if (suggestionsState.suggestions.length > 0 && !isSubmittingSlashCommand && !hasDirectorySuggestions) {
1075        logForDebugging(`[onSubmit] early return: suggestions showing (count=${suggestionsState.suggestions.length})`);
1076        return; // Don't submit, user needs to clear suggestions first
1077      }
1078  
1079      // Log suggestion outcome if one exists
1080      if (promptSuggestionState.text && promptSuggestionState.shownAt > 0) {
1081        logOutcomeAtSubmission(inputParam);
1082      }
1083  
1084      // Clear stash hint notification on submit
1085      removeNotification('stash-hint');
1086  
1087      // Route input to viewed agent (in-process teammate or named local_agent).
1088      const activeAgent = getActiveAgentForInput(store.getState());
1089      if (activeAgent.type !== 'leader' && onAgentSubmit) {
1090        logEvent('tengu_transcript_input_to_teammate', {});
1091        await onAgentSubmit(inputParam, activeAgent.task, {
1092          setCursorOffset,
1093          clearBuffer,
1094          resetHistory
1095        });
1096        return;
1097      }
1098  
1099      // Normal leader submission
1100      await onSubmitProp(inputParam, {
1101        setCursorOffset,
1102        clearBuffer,
1103        resetHistory
1104      });
1105    }, [promptSuggestionState, speculation, speculationSessionTimeSavedMs, teamContext, store, footerItems, suggestionsState.suggestions, onSubmitProp, onAgentSubmit, clearBuffer, resetHistory, logOutcomeAtSubmission, setAppState, markAccepted, pastedContents, removeNotification]);
1106    const {
1107      suggestions,
1108      selectedSuggestion,
1109      commandArgumentHint,
1110      inlineGhostText,
1111      maxColumnWidth
1112    } = useTypeahead({
1113      commands,
1114      onInputChange: trackAndSetInput,
1115      onSubmit,
1116      setCursorOffset,
1117      input,
1118      cursorOffset,
1119      mode,
1120      agents,
1121      setSuggestionsState,
1122      suggestionsState,
1123      suppressSuggestions: isSearchingHistory || historyIndex > 0,
1124      markAccepted,
1125      onModeChange
1126    });
1127  
1128    // Track if prompt suggestion should be shown (computed later with terminal width).
1129    // Hidden in teammate view — suggestion is leader-context only.
1130    const showPromptSuggestion = mode === 'prompt' && suggestions.length === 0 && promptSuggestion && !viewingAgentTaskId;
1131    if (showPromptSuggestion) {
1132      markShown();
1133    }
1134  
1135    // If suggestion was generated but can't be shown due to timing, log suppression.
1136    // Exclude teammate view: markShown() is gated above, so shownAt stays 0 there —
1137    // but that's not a timing failure, the suggestion is valid when returning to leader.
1138    if (promptSuggestionState.text && !promptSuggestion && promptSuggestionState.shownAt === 0 && !viewingAgentTaskId) {
1139      logSuggestionSuppressed('timing', promptSuggestionState.text);
1140      setAppState(prev => ({
1141        ...prev,
1142        promptSuggestion: {
1143          text: null,
1144          promptId: null,
1145          shownAt: 0,
1146          acceptedAt: 0,
1147          generationRequestId: null
1148        }
1149      }));
1150    }
1151    function onImagePaste(image: string, mediaType?: string, filename?: string, dimensions?: ImageDimensions, sourcePath?: string) {
1152      logEvent('tengu_paste_image', {});
1153      onModeChange('prompt');
1154      const pasteId = nextPasteIdRef.current++;
1155      const newContent: PastedContent = {
1156        id: pasteId,
1157        type: 'image',
1158        content: image,
1159        mediaType: mediaType || 'image/png',
1160        // default to PNG if not provided
1161        filename: filename || 'Pasted image',
1162        dimensions,
1163        sourcePath
1164      };
1165  
1166      // Cache path immediately (fast) so links work on render
1167      cacheImagePath(newContent);
1168  
1169      // Store image to disk in background
1170      void storeImage(newContent);
1171  
1172      // Update UI
1173      setPastedContents(prev => ({
1174        ...prev,
1175        [pasteId]: newContent
1176      }));
1177      // Multi-image paste calls onImagePaste in a loop. If the ref is already
1178      // armed, the previous pill's lazy space fires now (before this pill)
1179      // rather than being lost.
1180      const prefix = pendingSpaceAfterPillRef.current ? ' ' : '';
1181      insertTextAtCursor(prefix + formatImageRef(pasteId));
1182      pendingSpaceAfterPillRef.current = true;
1183    }
1184  
1185    // Prune images whose [Image #N] placeholder is no longer in the input text.
1186    // Covers pill backspace, Ctrl+U, char-by-char deletion — any edit that drops
1187    // the ref. onImagePaste batches setPastedContents + insertTextAtCursor in the
1188    // same event, so this effect sees the placeholder already present.
1189    useEffect(() => {
1190      const referencedIds = new Set(parseReferences(input).map(r => r.id));
1191      setPastedContents(prev => {
1192        const orphaned = Object.values(prev).filter(c => c.type === 'image' && !referencedIds.has(c.id));
1193        if (orphaned.length === 0) return prev;
1194        const next = {
1195          ...prev
1196        };
1197        for (const img of orphaned) delete next[img.id];
1198        return next;
1199      });
1200    }, [input, setPastedContents]);
1201    function onTextPaste(rawText: string) {
1202      pendingSpaceAfterPillRef.current = false;
1203      // Clean up pasted text - strip ANSI escape codes and normalize line endings and tabs
1204      let text = stripAnsi(rawText).replace(/\r/g, '\n').replaceAll('\t', '    ');
1205  
1206      // Match typed/auto-suggest: `!cmd` pasted into empty input enters bash mode.
1207      if (input.length === 0) {
1208        const pastedMode = getModeFromInput(text);
1209        if (pastedMode !== 'prompt') {
1210          onModeChange(pastedMode);
1211          text = getValueFromInput(text);
1212        }
1213      }
1214      const numLines = getPastedTextRefNumLines(text);
1215      // Limit the number of lines to show in the input
1216      // If the overall layout is too high then Ink will repaint
1217      // the entire terminal.
1218      // The actual required height is dependent on the content, this
1219      // is just an estimate.
1220      const maxLines = Math.min(rows - 10, 2);
1221  
1222      // Use special handling for long pasted text (>PASTE_THRESHOLD chars)
1223      // or if it exceeds the number of lines we want to show
1224      if (text.length > PASTE_THRESHOLD || numLines > maxLines) {
1225        const pasteId = nextPasteIdRef.current++;
1226        const newContent: PastedContent = {
1227          id: pasteId,
1228          type: 'text',
1229          content: text
1230        };
1231        setPastedContents(prev => ({
1232          ...prev,
1233          [pasteId]: newContent
1234        }));
1235        insertTextAtCursor(formatPastedTextRef(pasteId, numLines));
1236      } else {
1237        // For shorter pastes, just insert the text normally
1238        insertTextAtCursor(text);
1239      }
1240    }
1241    const lazySpaceInputFilter = useCallback((input: string, key: Key): string => {
1242      if (!pendingSpaceAfterPillRef.current) return input;
1243      pendingSpaceAfterPillRef.current = false;
1244      if (isNonSpacePrintable(input, key)) return ' ' + input;
1245      return input;
1246    }, []);
1247    function insertTextAtCursor(text: string) {
1248      // Push current state to buffer before inserting
1249      pushToBuffer(input, cursorOffset, pastedContents);
1250      const newInput = input.slice(0, cursorOffset) + text + input.slice(cursorOffset);
1251      trackAndSetInput(newInput);
1252      setCursorOffset(cursorOffset + text.length);
1253    }
1254    const doublePressEscFromEmpty = useDoublePress(() => {}, () => onShowMessageSelector());
1255  
1256    // Function to get the queued command for editing. Returns true if commands were popped.
1257    const popAllCommandsFromQueue = useCallback((): boolean => {
1258      const result = popAllEditable(input, cursorOffset);
1259      if (!result) {
1260        return false;
1261      }
1262      trackAndSetInput(result.text);
1263      onModeChange('prompt'); // Always prompt mode for queued commands
1264      setCursorOffset(result.cursorOffset);
1265  
1266      // Restore images from queued commands to pastedContents
1267      if (result.images.length > 0) {
1268        setPastedContents(prev => {
1269          const newContents = {
1270            ...prev
1271          };
1272          for (const image of result.images) {
1273            newContents[image.id] = image;
1274          }
1275          return newContents;
1276        });
1277      }
1278      return true;
1279    }, [trackAndSetInput, onModeChange, input, cursorOffset, setPastedContents]);
1280  
1281    // Insert the at-mentioned reference (the file and, optionally, a line range) when
1282    // we receive an at-mentioned notification the IDE.
1283    const onIdeAtMentioned = function (atMentioned: IDEAtMentioned) {
1284      logEvent('tengu_ext_at_mentioned', {});
1285      let atMentionedText: string;
1286      const relativePath = path.relative(getCwd(), atMentioned.filePath);
1287      if (atMentioned.lineStart && atMentioned.lineEnd) {
1288        atMentionedText = atMentioned.lineStart === atMentioned.lineEnd ? `@${relativePath}#L${atMentioned.lineStart} ` : `@${relativePath}#L${atMentioned.lineStart}-${atMentioned.lineEnd} `;
1289      } else {
1290        atMentionedText = `@${relativePath} `;
1291      }
1292      const cursorChar = input[cursorOffset - 1] ?? ' ';
1293      if (!/\s/.test(cursorChar)) {
1294        atMentionedText = ` ${atMentionedText}`;
1295      }
1296      insertTextAtCursor(atMentionedText);
1297    };
1298    useIdeAtMentioned(mcpClients, onIdeAtMentioned);
1299  
1300    // Handler for chat:undo - undo last edit
1301    const handleUndo = useCallback(() => {
1302      if (canUndo) {
1303        const previousState = undo();
1304        if (previousState) {
1305          trackAndSetInput(previousState.text);
1306          setCursorOffset(previousState.cursorOffset);
1307          setPastedContents(previousState.pastedContents);
1308        }
1309      }
1310    }, [canUndo, undo, trackAndSetInput, setPastedContents]);
1311  
1312    // Handler for chat:newline - insert a newline at the cursor position
1313    const handleNewline = useCallback(() => {
1314      pushToBuffer(input, cursorOffset, pastedContents);
1315      const newInput = input.slice(0, cursorOffset) + '\n' + input.slice(cursorOffset);
1316      trackAndSetInput(newInput);
1317      setCursorOffset(cursorOffset + 1);
1318    }, [input, cursorOffset, trackAndSetInput, setCursorOffset, pushToBuffer, pastedContents]);
1319  
1320    // Handler for chat:externalEditor - edit in $EDITOR
1321    const handleExternalEditor = useCallback(async () => {
1322      logEvent('tengu_external_editor_used', {});
1323      setIsExternalEditorActive(true);
1324      try {
1325        // Pass pastedContents to expand collapsed text references
1326        const result = await editPromptInEditor(input, pastedContents);
1327        if (result.error) {
1328          addNotification({
1329            key: 'external-editor-error',
1330            text: result.error,
1331            color: 'warning',
1332            priority: 'high'
1333          });
1334        }
1335        if (result.content !== null && result.content !== input) {
1336          // Push current state to buffer before making changes
1337          pushToBuffer(input, cursorOffset, pastedContents);
1338          trackAndSetInput(result.content);
1339          setCursorOffset(result.content.length);
1340        }
1341      } catch (err) {
1342        if (err instanceof Error) {
1343          logError(err);
1344        }
1345        addNotification({
1346          key: 'external-editor-error',
1347          text: `External editor failed: ${errorMessage(err)}`,
1348          color: 'warning',
1349          priority: 'high'
1350        });
1351      } finally {
1352        setIsExternalEditorActive(false);
1353      }
1354    }, [input, cursorOffset, pastedContents, pushToBuffer, trackAndSetInput, addNotification]);
1355  
1356    // Handler for chat:stash - stash/unstash prompt
1357    const handleStash = useCallback(() => {
1358      if (input.trim() === '' && stashedPrompt !== undefined) {
1359        // Pop stash when input is empty
1360        trackAndSetInput(stashedPrompt.text);
1361        setCursorOffset(stashedPrompt.cursorOffset);
1362        setPastedContents(stashedPrompt.pastedContents);
1363        setStashedPrompt(undefined);
1364      } else if (input.trim() !== '') {
1365        // Push to stash (save text, cursor position, and pasted contents)
1366        setStashedPrompt({
1367          text: input,
1368          cursorOffset,
1369          pastedContents
1370        });
1371        trackAndSetInput('');
1372        setCursorOffset(0);
1373        setPastedContents({});
1374        // Track usage for /discover and stop showing hint
1375        saveGlobalConfig(c => {
1376          if (c.hasUsedStash) return c;
1377          return {
1378            ...c,
1379            hasUsedStash: true
1380          };
1381        });
1382      }
1383    }, [input, cursorOffset, stashedPrompt, trackAndSetInput, setStashedPrompt, pastedContents, setPastedContents]);
1384  
1385    // Handler for chat:modelPicker - toggle model picker
1386    const handleModelPicker = useCallback(() => {
1387      setShowModelPicker(prev => !prev);
1388      if (helpOpen) {
1389        setHelpOpen(false);
1390      }
1391    }, [helpOpen]);
1392  
1393    // Handler for chat:fastMode - toggle fast mode picker
1394    const handleFastModePicker = useCallback(() => {
1395      setShowFastModePicker(prev => !prev);
1396      if (helpOpen) {
1397        setHelpOpen(false);
1398      }
1399    }, [helpOpen]);
1400  
1401    // Handler for chat:thinkingToggle - toggle thinking mode
1402    const handleThinkingToggle = useCallback(() => {
1403      setShowThinkingToggle(prev => !prev);
1404      if (helpOpen) {
1405        setHelpOpen(false);
1406      }
1407    }, [helpOpen]);
1408  
1409    // Handler for chat:cycleMode - cycle through permission modes
1410    const handleCycleMode = useCallback(() => {
1411      // When viewing a teammate, cycle their mode instead of the leader's
1412      if (isAgentSwarmsEnabled() && viewedTeammate && viewingAgentTaskId) {
1413        const teammateContext: ToolPermissionContext = {
1414          ...toolPermissionContext,
1415          mode: viewedTeammate.permissionMode
1416        };
1417        // Pass undefined for teamContext (unused but kept for API compatibility)
1418        const nextMode = getNextPermissionMode(teammateContext, undefined);
1419        logEvent('tengu_mode_cycle', {
1420          to: nextMode as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
1421        });
1422        const teammateTaskId = viewingAgentTaskId;
1423        setAppState(prev => {
1424          const task = prev.tasks[teammateTaskId];
1425          if (!task || task.type !== 'in_process_teammate') {
1426            return prev;
1427          }
1428          if (task.permissionMode === nextMode) {
1429            return prev;
1430          }
1431          return {
1432            ...prev,
1433            tasks: {
1434              ...prev.tasks,
1435              [teammateTaskId]: {
1436                ...task,
1437                permissionMode: nextMode
1438              }
1439            }
1440          };
1441        });
1442        if (helpOpen) {
1443          setHelpOpen(false);
1444        }
1445        return;
1446      }
1447  
1448      // Compute the next mode without triggering side effects first
1449      logForDebugging(`[auto-mode] handleCycleMode: currentMode=${toolPermissionContext.mode} isAutoModeAvailable=${toolPermissionContext.isAutoModeAvailable} showAutoModeOptIn=${showAutoModeOptIn} timeoutPending=${!!autoModeOptInTimeoutRef.current}`);
1450      const nextMode = getNextPermissionMode(toolPermissionContext, teamContext);
1451  
1452      // Check if user is entering auto mode for the first time. Gated on the
1453      // persistent settings flag (hasAutoModeOptIn) rather than the broader
1454      // hasAutoModeOptInAnySource so that --enable-auto-mode users still see
1455      // the warning dialog once — the CLI flag should grant carousel access,
1456      // not bypass the safety text.
1457      let isEnteringAutoModeFirstTime = false;
1458      if (feature('TRANSCRIPT_CLASSIFIER')) {
1459        isEnteringAutoModeFirstTime = nextMode === 'auto' && toolPermissionContext.mode !== 'auto' && !hasAutoModeOptIn() && !viewingAgentTaskId; // Only show for primary agent, not subagents
1460      }
1461      if (feature('TRANSCRIPT_CLASSIFIER')) {
1462        if (isEnteringAutoModeFirstTime) {
1463          // Store previous mode so we can revert if user declines
1464          setPreviousModeBeforeAuto(toolPermissionContext.mode);
1465  
1466          // Only update the UI mode label — do NOT call transitionPermissionMode
1467          // or cyclePermissionMode yet; we haven't confirmed with the user.
1468          setAppState(prev => ({
1469            ...prev,
1470            toolPermissionContext: {
1471              ...prev.toolPermissionContext,
1472              mode: 'auto'
1473            }
1474          }));
1475          setToolPermissionContext({
1476            ...toolPermissionContext,
1477            mode: 'auto'
1478          });
1479  
1480          // Show opt-in dialog after 400ms debounce
1481          if (autoModeOptInTimeoutRef.current) {
1482            clearTimeout(autoModeOptInTimeoutRef.current);
1483          }
1484          autoModeOptInTimeoutRef.current = setTimeout((setShowAutoModeOptIn, autoModeOptInTimeoutRef) => {
1485            setShowAutoModeOptIn(true);
1486            autoModeOptInTimeoutRef.current = null;
1487          }, 400, setShowAutoModeOptIn, autoModeOptInTimeoutRef);
1488          if (helpOpen) {
1489            setHelpOpen(false);
1490          }
1491          return;
1492        }
1493      }
1494  
1495      // Dismiss auto mode opt-in dialog if showing or pending (user is cycling away).
1496      // Do NOT revert to previousModeBeforeAuto here — shift+tab means "advance the
1497      // carousel", not "decline". Reverting causes a ping-pong loop: auto reverts to
1498      // the prior mode, whose next mode is auto again, forever.
1499      // The dialog's own decline button (handleAutoModeOptInDecline) handles revert.
1500      if (feature('TRANSCRIPT_CLASSIFIER')) {
1501        if (showAutoModeOptIn || autoModeOptInTimeoutRef.current) {
1502          if (showAutoModeOptIn) {
1503            logEvent('tengu_auto_mode_opt_in_dialog_decline', {});
1504          }
1505          setShowAutoModeOptIn(false);
1506          if (autoModeOptInTimeoutRef.current) {
1507            clearTimeout(autoModeOptInTimeoutRef.current);
1508            autoModeOptInTimeoutRef.current = null;
1509          }
1510          setPreviousModeBeforeAuto(null);
1511          // Fall through — mode is 'auto', cyclePermissionMode below goes to 'default'.
1512        }
1513      }
1514  
1515      // Now that we know this is NOT the first-time auto mode path,
1516      // call cyclePermissionMode to apply side effects (e.g. strip
1517      // dangerous permissions, activate classifier)
1518      const {
1519        context: preparedContext
1520      } = cyclePermissionMode(toolPermissionContext, teamContext);
1521      logEvent('tengu_mode_cycle', {
1522        to: nextMode as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
1523      });
1524  
1525      // Track when user enters plan mode
1526      if (nextMode === 'plan') {
1527        saveGlobalConfig(current => ({
1528          ...current,
1529          lastPlanModeUse: Date.now()
1530        }));
1531      }
1532  
1533      // Set the mode via setAppState directly because setToolPermissionContext
1534      // intentionally preserves the existing mode (to prevent coordinator mode
1535      // corruption from workers). Then call setToolPermissionContext to trigger
1536      // recheck of queued permission prompts.
1537      setAppState(prev => ({
1538        ...prev,
1539        toolPermissionContext: {
1540          ...preparedContext,
1541          mode: nextMode
1542        }
1543      }));
1544      setToolPermissionContext({
1545        ...preparedContext,
1546        mode: nextMode
1547      });
1548  
1549      // If this is a teammate, update config.json so team lead sees the change
1550      syncTeammateMode(nextMode, teamContext?.teamName);
1551  
1552      // Close help tips if they're open when mode is cycled
1553      if (helpOpen) {
1554        setHelpOpen(false);
1555      }
1556    }, [toolPermissionContext, teamContext, viewingAgentTaskId, viewedTeammate, setAppState, setToolPermissionContext, helpOpen, showAutoModeOptIn]);
1557  
1558    // Handler for auto mode opt-in dialog acceptance
1559    const handleAutoModeOptInAccept = useCallback(() => {
1560      if (feature('TRANSCRIPT_CLASSIFIER')) {
1561        setShowAutoModeOptIn(false);
1562        setPreviousModeBeforeAuto(null);
1563  
1564        // Now that the user accepted, apply the full transition: activate the
1565        // auto mode backend (classifier, beta headers) and strip dangerous
1566        // permissions (e.g. Bash(*) always-allow rules).
1567        const strippedContext = transitionPermissionMode(previousModeBeforeAuto ?? toolPermissionContext.mode, 'auto', toolPermissionContext);
1568        setAppState(prev => ({
1569          ...prev,
1570          toolPermissionContext: {
1571            ...strippedContext,
1572            mode: 'auto'
1573          }
1574        }));
1575        setToolPermissionContext({
1576          ...strippedContext,
1577          mode: 'auto'
1578        });
1579  
1580        // Close help tips if they're open when auto mode is enabled
1581        if (helpOpen) {
1582          setHelpOpen(false);
1583        }
1584      }
1585    }, [helpOpen, setHelpOpen, previousModeBeforeAuto, toolPermissionContext, setAppState, setToolPermissionContext]);
1586  
1587    // Handler for auto mode opt-in dialog decline
1588    const handleAutoModeOptInDecline = useCallback(() => {
1589      if (feature('TRANSCRIPT_CLASSIFIER')) {
1590        logForDebugging(`[auto-mode] handleAutoModeOptInDecline: reverting to ${previousModeBeforeAuto}, setting isAutoModeAvailable=false`);
1591        setShowAutoModeOptIn(false);
1592        if (autoModeOptInTimeoutRef.current) {
1593          clearTimeout(autoModeOptInTimeoutRef.current);
1594          autoModeOptInTimeoutRef.current = null;
1595        }
1596  
1597        // Revert to previous mode and remove auto from the carousel
1598        // for the rest of this session
1599        if (previousModeBeforeAuto) {
1600          setAutoModeActive(false);
1601          setAppState(prev => ({
1602            ...prev,
1603            toolPermissionContext: {
1604              ...prev.toolPermissionContext,
1605              mode: previousModeBeforeAuto,
1606              isAutoModeAvailable: false
1607            }
1608          }));
1609          setToolPermissionContext({
1610            ...toolPermissionContext,
1611            mode: previousModeBeforeAuto,
1612            isAutoModeAvailable: false
1613          });
1614          setPreviousModeBeforeAuto(null);
1615        }
1616      }
1617    }, [previousModeBeforeAuto, toolPermissionContext, setAppState, setToolPermissionContext]);
1618  
1619    // Handler for chat:imagePaste - paste image from clipboard
1620    const handleImagePaste = useCallback(() => {
1621      void getImageFromClipboard().then(imageData => {
1622        if (imageData) {
1623          onImagePaste(imageData.base64, imageData.mediaType);
1624        } else {
1625          const shortcutDisplay = getShortcutDisplay('chat:imagePaste', 'Chat', 'ctrl+v');
1626          const message = env.isSSH() ? "No image found in clipboard. You're SSH'd; try scp?" : `No image found in clipboard. Use ${shortcutDisplay} to paste images.`;
1627          addNotification({
1628            key: 'no-image-in-clipboard',
1629            text: message,
1630            priority: 'immediate',
1631            timeoutMs: 1000
1632          });
1633        }
1634      });
1635    }, [addNotification, onImagePaste]);
1636  
1637    // Register chat:submit handler directly in the handler registry (not via
1638    // useKeybindings) so that only the ChordInterceptor can invoke it for chord
1639    // completions (e.g., "ctrl+e s"). The default Enter binding for submit is
1640    // handled by TextInput directly (via onSubmit prop) and useTypeahead (for
1641    // autocomplete acceptance). Using useKeybindings would cause
1642    // stopImmediatePropagation on Enter, blocking autocomplete from seeing the key.
1643    const keybindingContext = useOptionalKeybindingContext();
1644    useEffect(() => {
1645      if (!keybindingContext || isModalOverlayActive) return;
1646      return keybindingContext.registerHandler({
1647        action: 'chat:submit',
1648        context: 'Chat',
1649        handler: () => {
1650          void onSubmit(input);
1651        }
1652      });
1653    }, [keybindingContext, isModalOverlayActive, onSubmit, input]);
1654  
1655    // Chat context keybindings for editing shortcuts
1656    // Note: history:previous/history:next are NOT handled here. They are passed as
1657    // onHistoryUp/onHistoryDown props to TextInput, so that useTextInput's
1658    // upOrHistoryUp/downOrHistoryDown can try cursor movement first and only
1659    // fall through to history when the cursor can't move further.
1660    const chatHandlers = useMemo(() => ({
1661      'chat:undo': handleUndo,
1662      'chat:newline': handleNewline,
1663      'chat:externalEditor': handleExternalEditor,
1664      'chat:stash': handleStash,
1665      'chat:modelPicker': handleModelPicker,
1666      'chat:thinkingToggle': handleThinkingToggle,
1667      'chat:cycleMode': handleCycleMode,
1668      'chat:imagePaste': handleImagePaste
1669    }), [handleUndo, handleNewline, handleExternalEditor, handleStash, handleModelPicker, handleThinkingToggle, handleCycleMode, handleImagePaste]);
1670    useKeybindings(chatHandlers, {
1671      context: 'Chat',
1672      isActive: !isModalOverlayActive
1673    });
1674  
1675    // Shift+↑ enters message-actions cursor. Separate isActive so ctrl+r search
1676    // doesn't leave stale isSearchingHistory on cursor-exit remount.
1677    useKeybinding('chat:messageActions', () => onMessageActionsEnter?.(), {
1678      context: 'Chat',
1679      isActive: !isModalOverlayActive && !isSearchingHistory
1680    });
1681  
1682    // Fast mode keybinding is only active when fast mode is enabled and available
1683    useKeybinding('chat:fastMode', handleFastModePicker, {
1684      context: 'Chat',
1685      isActive: !isModalOverlayActive && isFastModeEnabled() && isFastModeAvailable()
1686    });
1687  
1688    // Handle help:dismiss keybinding (ESC closes help menu)
1689    // This is registered separately from Chat context so it has priority over
1690    // CancelRequestHandler when help menu is open
1691    useKeybinding('help:dismiss', () => {
1692      setHelpOpen(false);
1693    }, {
1694      context: 'Help',
1695      isActive: helpOpen
1696    });
1697  
1698    // Quick Open / Global Search. Hook calls are unconditional (Rules of Hooks);
1699    // the handler body is feature()-gated so the setState calls and component
1700    // references get tree-shaken in external builds.
1701    const quickSearchActive = feature('QUICK_SEARCH') ? !isModalOverlayActive : false;
1702    useKeybinding('app:quickOpen', () => {
1703      if (feature('QUICK_SEARCH')) {
1704        setShowQuickOpen(true);
1705        setHelpOpen(false);
1706      }
1707    }, {
1708      context: 'Global',
1709      isActive: quickSearchActive
1710    });
1711    useKeybinding('app:globalSearch', () => {
1712      if (feature('QUICK_SEARCH')) {
1713        setShowGlobalSearch(true);
1714        setHelpOpen(false);
1715      }
1716    }, {
1717      context: 'Global',
1718      isActive: quickSearchActive
1719    });
1720    useKeybinding('history:search', () => {
1721      if (feature('HISTORY_PICKER')) {
1722        setShowHistoryPicker(true);
1723        setHelpOpen(false);
1724      }
1725    }, {
1726      context: 'Global',
1727      isActive: feature('HISTORY_PICKER') ? !isModalOverlayActive : false
1728    });
1729  
1730    // Handle Ctrl+C to abort speculation when idle (not loading)
1731    // CancelRequestHandler only handles Ctrl+C during active tasks
1732    useKeybinding('app:interrupt', () => {
1733      abortSpeculation(setAppState);
1734    }, {
1735      context: 'Global',
1736      isActive: !isLoading && speculation.status === 'active'
1737    });
1738  
1739    // Footer indicator navigation keybindings. ↑/↓ live here (not in
1740    // handleHistoryUp/Down) because TextInput focus=false when a pill is
1741    // selected — its useInput is inactive, so this is the only path.
1742    useKeybindings({
1743      'footer:up': () => {
1744        // ↑ scrolls within the coordinator task list before leaving the pill
1745        if (tasksSelected && "external" === 'ant' && coordinatorTaskCount > 0 && coordinatorTaskIndex > minCoordinatorIndex) {
1746          setCoordinatorTaskIndex(prev => prev - 1);
1747          return;
1748        }
1749        navigateFooter(-1, true);
1750      },
1751      'footer:down': () => {
1752        // ↓ scrolls within the coordinator task list, never leaves the pill
1753        if (tasksSelected && "external" === 'ant' && coordinatorTaskCount > 0) {
1754          if (coordinatorTaskIndex < coordinatorTaskCount - 1) {
1755            setCoordinatorTaskIndex(prev => prev + 1);
1756          }
1757          return;
1758        }
1759        if (tasksSelected && !isTeammateMode) {
1760          setShowBashesDialog(true);
1761          selectFooterItem(null);
1762          return;
1763        }
1764        navigateFooter(1);
1765      },
1766      'footer:next': () => {
1767        // Teammate mode: ←/→ cycles within the team member list
1768        if (tasksSelected && isTeammateMode) {
1769          const totalAgents = 1 + inProcessTeammates.length;
1770          setTeammateFooterIndex(prev => (prev + 1) % totalAgents);
1771          return;
1772        }
1773        navigateFooter(1);
1774      },
1775      'footer:previous': () => {
1776        if (tasksSelected && isTeammateMode) {
1777          const totalAgents = 1 + inProcessTeammates.length;
1778          setTeammateFooterIndex(prev => (prev - 1 + totalAgents) % totalAgents);
1779          return;
1780        }
1781        navigateFooter(-1);
1782      },
1783      'footer:openSelected': () => {
1784        if (viewSelectionMode === 'selecting-agent') {
1785          return;
1786        }
1787        switch (footerItemSelected) {
1788          case 'companion':
1789            if (feature('BUDDY')) {
1790              selectFooterItem(null);
1791              void onSubmit('/buddy');
1792            }
1793            break;
1794          case 'tasks':
1795            if (isTeammateMode) {
1796              // Enter switches to the selected agent's view
1797              if (teammateFooterIndex === 0) {
1798                exitTeammateView(setAppState);
1799              } else {
1800                const teammate = inProcessTeammates[teammateFooterIndex - 1];
1801                if (teammate) enterTeammateView(teammate.id, setAppState);
1802              }
1803            } else if (coordinatorTaskIndex === 0 && coordinatorTaskCount > 0) {
1804              exitTeammateView(setAppState);
1805            } else {
1806              const selectedTaskId = getVisibleAgentTasks(tasks)[coordinatorTaskIndex - 1]?.id;
1807              if (selectedTaskId) {
1808                enterTeammateView(selectedTaskId, setAppState);
1809              } else {
1810                setShowBashesDialog(true);
1811                selectFooterItem(null);
1812              }
1813            }
1814            break;
1815          case 'tmux':
1816            if ("external" === 'ant') {
1817              setAppState(prev => prev.tungstenPanelAutoHidden ? {
1818                ...prev,
1819                tungstenPanelAutoHidden: false
1820              } : {
1821                ...prev,
1822                tungstenPanelVisible: !(prev.tungstenPanelVisible ?? true)
1823              });
1824            }
1825            break;
1826          case 'bagel':
1827            break;
1828          case 'teams':
1829            setShowTeamsDialog(true);
1830            selectFooterItem(null);
1831            break;
1832          case 'bridge':
1833            setShowBridgeDialog(true);
1834            selectFooterItem(null);
1835            break;
1836        }
1837      },
1838      'footer:clearSelection': () => {
1839        selectFooterItem(null);
1840      },
1841      'footer:close': () => {
1842        if (tasksSelected && coordinatorTaskIndex >= 1) {
1843          const task = getVisibleAgentTasks(tasks)[coordinatorTaskIndex - 1];
1844          if (!task) return false;
1845          // When the selected row IS the viewed agent, 'x' types into the
1846          // steering input. Any other row — dismiss it.
1847          if (viewSelectionMode === 'viewing-agent' && task.id === viewingAgentTaskId) {
1848            onChange(input.slice(0, cursorOffset) + 'x' + input.slice(cursorOffset));
1849            setCursorOffset(cursorOffset + 1);
1850            return;
1851          }
1852          stopOrDismissAgent(task.id, setAppState);
1853          if (task.status !== 'running') {
1854            setCoordinatorTaskIndex(i => Math.max(minCoordinatorIndex, i - 1));
1855          }
1856          return;
1857        }
1858        // Not handled — let 'x' fall through to type-to-exit
1859        return false;
1860      }
1861    }, {
1862      context: 'Footer',
1863      isActive: !!footerItemSelected && !isModalOverlayActive
1864    });
1865    useInput((char, key) => {
1866      // Skip all input handling when a full-screen dialog is open. These dialogs
1867      // render via early return, but hooks run unconditionally — so without this
1868      // guard, Escape inside a dialog leaks to the double-press message-selector.
1869      if (showTeamsDialog || showQuickOpen || showGlobalSearch || showHistoryPicker) {
1870        return;
1871      }
1872  
1873      // Detect failed Alt shortcuts on macOS (Option key produces special characters)
1874      if (getPlatform() === 'macos' && isMacosOptionChar(char)) {
1875        const shortcut = MACOS_OPTION_SPECIAL_CHARS[char];
1876        const terminalName = getNativeCSIuTerminalDisplayName();
1877        const jsx = terminalName ? <Text dimColor>
1878            To enable {shortcut}, set <Text bold>Option as Meta</Text> in{' '}
1879            {terminalName} preferences (⌘,)
1880          </Text> : <Text dimColor>To enable {shortcut}, run /terminal-setup</Text>;
1881        addNotification({
1882          key: 'option-meta-hint',
1883          jsx,
1884          priority: 'immediate',
1885          timeoutMs: 5000
1886        });
1887        // Don't return - let the character be typed so user sees the issue
1888      }
1889  
1890      // Footer navigation is handled via useKeybindings above (Footer context)
1891  
1892      // NOTE: ctrl+_, ctrl+g, ctrl+s are handled via Chat context keybindings above
1893  
1894      // Type-to-exit footer: printable chars while a pill is selected refocus
1895      // the input and type the char. Nav keys are captured by useKeybindings
1896      // above, so anything reaching here is genuinely not a footer action.
1897      // onChange clears footerSelection, so no explicit deselect.
1898      if (footerItemSelected && char && !key.ctrl && !key.meta && !key.escape && !key.return) {
1899        onChange(input.slice(0, cursorOffset) + char + input.slice(cursorOffset));
1900        setCursorOffset(cursorOffset + char.length);
1901        return;
1902      }
1903  
1904      // Exit special modes when backspace/escape/delete/ctrl+u is pressed at cursor position 0
1905      if (cursorOffset === 0 && (key.escape || key.backspace || key.delete || key.ctrl && char === 'u')) {
1906        onModeChange('prompt');
1907        setHelpOpen(false);
1908      }
1909  
1910      // Exit help mode when backspace is pressed and input is empty
1911      if (helpOpen && input === '' && (key.backspace || key.delete)) {
1912        setHelpOpen(false);
1913      }
1914  
1915      // esc is a little overloaded:
1916      // - when we're loading a response, it's used to cancel the request
1917      // - otherwise, it's used to show the message selector
1918      // - when double pressed, it's used to clear the input
1919      // - when input is empty, pop from command queue
1920  
1921      // Handle ESC key press
1922      if (key.escape) {
1923        // Abort active speculation
1924        if (speculation.status === 'active') {
1925          abortSpeculation(setAppState);
1926          return;
1927        }
1928  
1929        // Dismiss side question response if visible
1930        if (isSideQuestionVisible && onDismissSideQuestion) {
1931          onDismissSideQuestion();
1932          return;
1933        }
1934  
1935        // Close help menu if open
1936        if (helpOpen) {
1937          setHelpOpen(false);
1938          return;
1939        }
1940  
1941        // Footer selection clearing is now handled via Footer context keybindings
1942        // (footer:clearSelection action bound to escape)
1943        // If a footer item is selected, let the Footer keybinding handle it
1944        if (footerItemSelected) {
1945          return;
1946        }
1947  
1948        // If there's an editable queued command, move it to the input for editing when ESC is pressed
1949        const hasEditableCommand = queuedCommands.some(isQueuedCommandEditable);
1950        if (hasEditableCommand) {
1951          void popAllCommandsFromQueue();
1952          return;
1953        }
1954        if (messages.length > 0 && !input && !isLoading) {
1955          doublePressEscFromEmpty();
1956        }
1957      }
1958      if (key.return && helpOpen) {
1959        setHelpOpen(false);
1960      }
1961    });
1962    const swarmBanner = useSwarmBanner();
1963    const fastModeCooldown = isFastModeEnabled() ? isFastModeCooldown() : false;
1964    const showFastIcon = isFastModeEnabled() ? isFastMode && (isFastModeAvailable() || fastModeCooldown) : false;
1965    const showFastIconHint = useShowFastIconHint(showFastIcon ?? false);
1966  
1967    // Show effort notification on startup and when effort changes.
1968    // Suppressed in brief/assistant mode — the value reflects the local
1969    // client's effort, not the connected agent's.
1970    const effortNotificationText = briefOwnsGap ? undefined : getEffortNotificationText(effortValue, mainLoopModel);
1971    useEffect(() => {
1972      if (!effortNotificationText) {
1973        removeNotification('effort-level');
1974        return;
1975      }
1976      addNotification({
1977        key: 'effort-level',
1978        text: effortNotificationText,
1979        priority: 'high',
1980        timeoutMs: 12_000
1981      });
1982    }, [effortNotificationText, addNotification, removeNotification]);
1983    useBuddyNotification();
1984    const companionSpeaking = feature('BUDDY') ?
1985    // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
1986    useAppState(s => s.companionReaction !== undefined) : false;
1987    const {
1988      columns,
1989      rows
1990    } = useTerminalSize();
1991    const textInputColumns = columns - 3 - companionReservedColumns(columns, companionSpeaking);
1992  
1993    // POC: click-to-position-cursor. Mouse tracking is only enabled inside
1994    // <AlternateScreen>, so this is dormant in the normal main-screen REPL.
1995    // localCol/localRow are relative to the onClick Box's top-left; the Box
1996    // tightly wraps the text input so they map directly to (column, line)
1997    // in the Cursor wrap model. MeasuredText.getOffsetFromPosition handles
1998    // wide chars, wrapped lines, and clamps past-end clicks to line end.
1999    const maxVisibleLines = isFullscreenEnvEnabled() ? Math.max(MIN_INPUT_VIEWPORT_LINES, Math.floor(rows / 2) - PROMPT_FOOTER_LINES) : undefined;
2000    const handleInputClick = useCallback((e: ClickEvent) => {
2001      // During history search the displayed text is historyMatch, not
2002      // input, and showCursor is false anyway — skip rather than
2003      // compute an offset against the wrong string.
2004      if (!input || isSearchingHistory) return;
2005      const c = Cursor.fromText(input, textInputColumns, cursorOffset);
2006      const viewportStart = c.getViewportStartLine(maxVisibleLines);
2007      const offset = c.measuredText.getOffsetFromPosition({
2008        line: e.localRow + viewportStart,
2009        column: e.localCol
2010      });
2011      setCursorOffset(offset);
2012    }, [input, textInputColumns, isSearchingHistory, cursorOffset, maxVisibleLines]);
2013    const handleOpenTasksDialog = useCallback((taskId?: string) => setShowBashesDialog(taskId ?? true), [setShowBashesDialog]);
2014    const placeholder = showPromptSuggestion && promptSuggestion ? promptSuggestion : defaultPlaceholder;
2015  
2016    // Calculate if input has multiple lines
2017    const isInputWrapped = useMemo(() => input.includes('\n'), [input]);
2018  
2019    // Memoized callbacks for model picker to prevent re-renders when unrelated
2020    // state (like notifications) changes. This prevents the inline model picker
2021    // from visually "jumping" when notifications arrive.
2022    const handleModelSelect = useCallback((model: string | null, _effort: EffortLevel | undefined) => {
2023      let wasFastModeDisabled = false;
2024      setAppState(prev => {
2025        wasFastModeDisabled = isFastModeEnabled() && !isFastModeSupportedByModel(model) && !!prev.fastMode;
2026        return {
2027          ...prev,
2028          mainLoopModel: model,
2029          mainLoopModelForSession: null,
2030          // Turn off fast mode if switching to a model that doesn't support it
2031          ...(wasFastModeDisabled && {
2032            fastMode: false
2033          })
2034        };
2035      });
2036      setShowModelPicker(false);
2037      const effectiveFastMode = (isFastMode ?? false) && !wasFastModeDisabled;
2038      let message = `Model set to ${modelDisplayString(model)}`;
2039      if (isBilledAsExtraUsage(model, effectiveFastMode, isOpus1mMergeEnabled())) {
2040        message += ' · Billed as extra usage';
2041      }
2042      if (wasFastModeDisabled) {
2043        message += ' · Fast mode OFF';
2044      }
2045      addNotification({
2046        key: 'model-switched',
2047        jsx: <Text>{message}</Text>,
2048        priority: 'immediate',
2049        timeoutMs: 3000
2050      });
2051      logEvent('tengu_model_picker_hotkey', {
2052        model: model as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
2053      });
2054    }, [setAppState, addNotification, isFastMode]);
2055    const handleModelCancel = useCallback(() => {
2056      setShowModelPicker(false);
2057    }, []);
2058  
2059    // Memoize the model picker element to prevent unnecessary re-renders
2060    // when AppState changes for unrelated reasons (e.g., notifications arriving)
2061    const modelPickerElement = useMemo(() => {
2062      if (!showModelPicker) return null;
2063      return <Box flexDirection="column" marginTop={1}>
2064          <ModelPicker initial={mainLoopModel_} sessionModel={mainLoopModelForSession} onSelect={handleModelSelect} onCancel={handleModelCancel} isStandaloneCommand showFastModeNotice={isFastModeEnabled() && isFastMode && isFastModeSupportedByModel(mainLoopModel_) && isFastModeAvailable()} />
2065        </Box>;
2066    }, [showModelPicker, mainLoopModel_, mainLoopModelForSession, handleModelSelect, handleModelCancel]);
2067    const handleFastModeSelect = useCallback((result?: string) => {
2068      setShowFastModePicker(false);
2069      if (result) {
2070        addNotification({
2071          key: 'fast-mode-toggled',
2072          jsx: <Text>{result}</Text>,
2073          priority: 'immediate',
2074          timeoutMs: 3000
2075        });
2076      }
2077    }, [addNotification]);
2078  
2079    // Memoize the fast mode picker element
2080    const fastModePickerElement = useMemo(() => {
2081      if (!showFastModePicker) return null;
2082      return <Box flexDirection="column" marginTop={1}>
2083          <FastModePicker onDone={handleFastModeSelect} unavailableReason={getFastModeUnavailableReason()} />
2084        </Box>;
2085    }, [showFastModePicker, handleFastModeSelect]);
2086  
2087    // Memoized callbacks for thinking toggle
2088    const handleThinkingSelect = useCallback((enabled: boolean) => {
2089      setAppState(prev => ({
2090        ...prev,
2091        thinkingEnabled: enabled
2092      }));
2093      setShowThinkingToggle(false);
2094      logEvent('tengu_thinking_toggled_hotkey', {
2095        enabled
2096      });
2097      addNotification({
2098        key: 'thinking-toggled-hotkey',
2099        jsx: <Text color={enabled ? 'suggestion' : undefined} dimColor={!enabled}>
2100              Thinking {enabled ? 'on' : 'off'}
2101            </Text>,
2102        priority: 'immediate',
2103        timeoutMs: 3000
2104      });
2105    }, [setAppState, addNotification]);
2106    const handleThinkingCancel = useCallback(() => {
2107      setShowThinkingToggle(false);
2108    }, []);
2109  
2110    // Memoize the thinking toggle element
2111    const thinkingToggleElement = useMemo(() => {
2112      if (!showThinkingToggle) return null;
2113      return <Box flexDirection="column" marginTop={1}>
2114          <ThinkingToggle currentValue={thinkingEnabled ?? true} onSelect={handleThinkingSelect} onCancel={handleThinkingCancel} isMidConversation={messages.some(m => m.type === 'assistant')} />
2115        </Box>;
2116    }, [showThinkingToggle, thinkingEnabled, handleThinkingSelect, handleThinkingCancel, messages.length]);
2117  
2118    // Portal dialog to DialogOverlay in fullscreen so it escapes the bottom
2119    // slot's overflowY:hidden clip (same pattern as SuggestionsOverlay).
2120    // Must be called before early returns below to satisfy rules-of-hooks.
2121    // Memoized so the portal useEffect doesn't churn on every PromptInput render.
2122    const autoModeOptInDialog = useMemo(() => feature('TRANSCRIPT_CLASSIFIER') && showAutoModeOptIn ? <AutoModeOptInDialog onAccept={handleAutoModeOptInAccept} onDecline={handleAutoModeOptInDecline} /> : null, [showAutoModeOptIn, handleAutoModeOptInAccept, handleAutoModeOptInDecline]);
2123    useSetPromptOverlayDialog(isFullscreenEnvEnabled() ? autoModeOptInDialog : null);
2124    if (showBashesDialog) {
2125      return <BackgroundTasksDialog onDone={() => setShowBashesDialog(false)} toolUseContext={getToolUseContext(messages, [], new AbortController(), mainLoopModel)} initialDetailTaskId={typeof showBashesDialog === 'string' ? showBashesDialog : undefined} />;
2126    }
2127    if (isAgentSwarmsEnabled() && showTeamsDialog) {
2128      return <TeamsDialog initialTeams={cachedTeams} onDone={() => {
2129        setShowTeamsDialog(false);
2130      }} />;
2131    }
2132    if (feature('QUICK_SEARCH')) {
2133      const insertWithSpacing = (text: string) => {
2134        const cursorChar = input[cursorOffset - 1] ?? ' ';
2135        insertTextAtCursor(/\s/.test(cursorChar) ? text : ` ${text}`);
2136      };
2137      if (showQuickOpen) {
2138        return <QuickOpenDialog onDone={() => setShowQuickOpen(false)} onInsert={insertWithSpacing} />;
2139      }
2140      if (showGlobalSearch) {
2141        return <GlobalSearchDialog onDone={() => setShowGlobalSearch(false)} onInsert={insertWithSpacing} />;
2142      }
2143    }
2144    if (feature('HISTORY_PICKER') && showHistoryPicker) {
2145      return <HistorySearchDialog initialQuery={input} onSelect={entry => {
2146        const entryMode = getModeFromInput(entry.display);
2147        const value = getValueFromInput(entry.display);
2148        onModeChange(entryMode);
2149        trackAndSetInput(value);
2150        setPastedContents(entry.pastedContents);
2151        setCursorOffset(value.length);
2152        setShowHistoryPicker(false);
2153      }} onCancel={() => setShowHistoryPicker(false)} />;
2154    }
2155  
2156    // Show loop mode menu when requested (ant-only, eliminated from external builds)
2157    if (modelPickerElement) {
2158      return modelPickerElement;
2159    }
2160    if (fastModePickerElement) {
2161      return fastModePickerElement;
2162    }
2163    if (thinkingToggleElement) {
2164      return thinkingToggleElement;
2165    }
2166    if (showBridgeDialog) {
2167      return <BridgeDialog onDone={() => {
2168        setShowBridgeDialog(false);
2169        selectFooterItem(null);
2170      }} />;
2171    }
2172    const baseProps: BaseTextInputProps = {
2173      multiline: true,
2174      onSubmit,
2175      onChange,
2176      value: historyMatch ? getValueFromInput(typeof historyMatch === 'string' ? historyMatch : historyMatch.display) : input,
2177      // History navigation is handled via TextInput props (onHistoryUp/onHistoryDown),
2178      // NOT via useKeybindings. This allows useTextInput's upOrHistoryUp/downOrHistoryDown
2179      // to try cursor movement first and only fall through to history navigation when the
2180      // cursor can't move further (important for wrapped text and multi-line input).
2181      onHistoryUp: handleHistoryUp,
2182      onHistoryDown: handleHistoryDown,
2183      onHistoryReset: resetHistory,
2184      placeholder,
2185      onExit,
2186      onExitMessage: (show, key) => setExitMessage({
2187        show,
2188        key
2189      }),
2190      onImagePaste,
2191      columns: textInputColumns,
2192      maxVisibleLines,
2193      disableCursorMovementForUpDownKeys: suggestions.length > 0 || !!footerItemSelected,
2194      disableEscapeDoublePress: suggestions.length > 0,
2195      cursorOffset,
2196      onChangeCursorOffset: setCursorOffset,
2197      onPaste: onTextPaste,
2198      onIsPastingChange: setIsPasting,
2199      focus: !isSearchingHistory && !isModalOverlayActive && !footerItemSelected,
2200      showCursor: !footerItemSelected && !isSearchingHistory && !cursorAtImageChip,
2201      argumentHint: commandArgumentHint,
2202      onUndo: canUndo ? () => {
2203        const previousState = undo();
2204        if (previousState) {
2205          trackAndSetInput(previousState.text);
2206          setCursorOffset(previousState.cursorOffset);
2207          setPastedContents(previousState.pastedContents);
2208        }
2209      } : undefined,
2210      highlights: combinedHighlights,
2211      inlineGhostText,
2212      inputFilter: lazySpaceInputFilter
2213    };
2214    const getBorderColor = (): keyof Theme => {
2215      const modeColors: Record<string, keyof Theme> = {
2216        bash: 'bashBorder'
2217      };
2218  
2219      // Mode colors take priority, then teammate color, then default
2220      if (modeColors[mode]) {
2221        return modeColors[mode];
2222      }
2223  
2224      // In-process teammates run headless - don't apply teammate colors to leader UI
2225      if (isInProcessTeammate()) {
2226        return 'promptBorder';
2227      }
2228  
2229      // Check for teammate color from environment
2230      const teammateColorName = getTeammateColor();
2231      if (teammateColorName && AGENT_COLORS.includes(teammateColorName as AgentColorName)) {
2232        return AGENT_COLOR_TO_THEME_COLOR[teammateColorName as AgentColorName];
2233      }
2234      return 'promptBorder';
2235    };
2236    if (isExternalEditorActive) {
2237      return <Box flexDirection="row" alignItems="center" justifyContent="center" borderColor={getBorderColor()} borderStyle="round" borderLeft={false} borderRight={false} borderBottom width="100%">
2238          <Text dimColor italic>
2239            Save and close editor to continue...
2240          </Text>
2241        </Box>;
2242    }
2243    const textInputElement = isVimModeEnabled() ? <VimTextInput {...baseProps} initialMode={vimMode} onModeChange={setVimMode} /> : <TextInput {...baseProps} />;
2244    return <Box flexDirection="column" marginTop={briefOwnsGap ? 0 : 1}>
2245        {!isFullscreenEnvEnabled() && <PromptInputQueuedCommands />}
2246        {hasSuppressedDialogs && <Box marginTop={1} marginLeft={2}>
2247            <Text dimColor>Waiting for permission…</Text>
2248          </Box>}
2249        <PromptInputStashNotice hasStash={stashedPrompt !== undefined} />
2250        {swarmBanner ? <>
2251            <Text color={swarmBanner.bgColor}>
2252              {swarmBanner.text ? <>
2253                  {'─'.repeat(Math.max(0, columns - stringWidth(swarmBanner.text) - 4))}
2254                  <Text backgroundColor={swarmBanner.bgColor} color="inverseText">
2255                    {' '}
2256                    {swarmBanner.text}{' '}
2257                  </Text>
2258                  {'──'}
2259                </> : '─'.repeat(columns)}
2260            </Text>
2261            <Box flexDirection="row" width="100%">
2262              <PromptInputModeIndicator mode={mode} isLoading={isLoading} viewingAgentName={viewingAgentName} viewingAgentColor={viewingAgentColor} />
2263              <Box flexGrow={1} flexShrink={1} onClick={handleInputClick}>
2264                {textInputElement}
2265              </Box>
2266            </Box>
2267            <Text color={swarmBanner.bgColor}>{'─'.repeat(columns)}</Text>
2268          </> : <Box flexDirection="row" alignItems="flex-start" justifyContent="flex-start" borderColor={getBorderColor()} borderStyle="round" borderLeft={false} borderRight={false} borderBottom width="100%" borderText={buildBorderText(showFastIcon ?? false, showFastIconHint, fastModeCooldown)}>
2269            <PromptInputModeIndicator mode={mode} isLoading={isLoading} viewingAgentName={viewingAgentName} viewingAgentColor={viewingAgentColor} />
2270            <Box flexGrow={1} flexShrink={1} onClick={handleInputClick}>
2271              {textInputElement}
2272            </Box>
2273          </Box>}
2274        <PromptInputFooter apiKeyStatus={apiKeyStatus} debug={debug} exitMessage={exitMessage} vimMode={isVimModeEnabled() ? vimMode : undefined} mode={mode} autoUpdaterResult={autoUpdaterResult} isAutoUpdating={isAutoUpdating} verbose={verbose} onAutoUpdaterResult={onAutoUpdaterResult} onChangeIsUpdating={setIsAutoUpdating} suggestions={suggestions} selectedSuggestion={selectedSuggestion} maxColumnWidth={maxColumnWidth} toolPermissionContext={effectiveToolPermissionContext} helpOpen={helpOpen} suppressHint={input.length > 0} isLoading={isLoading} tasksSelected={tasksSelected} teamsSelected={teamsSelected} bridgeSelected={bridgeSelected} tmuxSelected={tmuxSelected} teammateFooterIndex={teammateFooterIndex} ideSelection={ideSelection} mcpClients={mcpClients} isPasting={isPasting} isInputWrapped={isInputWrapped} messages={messages} isSearching={isSearchingHistory} historyQuery={historyQuery} setHistoryQuery={setHistoryQuery} historyFailedMatch={historyFailedMatch} onOpenTasksDialog={isFullscreenEnvEnabled() ? handleOpenTasksDialog : undefined} />
2275        {isFullscreenEnvEnabled() ? null : autoModeOptInDialog}
2276        {isFullscreenEnvEnabled() ?
2277      // position=absolute takes zero layout height so the spinner
2278      // doesn't shift when a notification appears/disappears. Yoga
2279      // anchors absolute children at the parent's content-box origin;
2280      // marginTop=-1 pulls it into the marginTop=1 gap row above the
2281      // prompt border. In brief mode there is no such gap (briefOwnsGap
2282      // strips our marginTop) and BriefSpinner sits flush against the
2283      // border — marginTop=-2 skips over the spinner content into
2284      // BriefSpinner's own marginTop=1 blank row. height=1 +
2285      // overflow=hidden clips multi-line notifications to a single row.
2286      // flex-end anchors the bottom line so the visible row is always
2287      // the most recent. Suppressed while the slash overlay or
2288      // auto-mode opt-in dialog is up by height=0 (NOT unmount) — this
2289      // Box renders later in tree order so it would paint over their
2290      // bottom row. Keeping Notifications mounted prevents AutoUpdater's
2291      // initial-check effect from re-firing on every slash-completion
2292      // toggle (PR#22413).
2293      <Box position="absolute" marginTop={briefOwnsGap ? -2 : -1} height={suggestions.length === 0 && !showAutoModeOptIn ? 1 : 0} width="100%" paddingLeft={2} paddingRight={1} flexDirection="column" justifyContent="flex-end" overflow="hidden">
2294            <Notifications apiKeyStatus={apiKeyStatus} autoUpdaterResult={autoUpdaterResult} debug={debug} isAutoUpdating={isAutoUpdating} verbose={verbose} messages={messages} onAutoUpdaterResult={onAutoUpdaterResult} onChangeIsUpdating={setIsAutoUpdating} ideSelection={ideSelection} mcpClients={mcpClients} isInputWrapped={isInputWrapped} />
2295          </Box> : null}
2296      </Box>;
2297  }
2298  
2299  /**
2300   * Compute the initial paste ID by finding the max ID used in existing messages.
2301   * This handles --continue/--resume scenarios where we need to avoid ID collisions.
2302   */
2303  function getInitialPasteId(messages: Message[]): number {
2304    let maxId = 0;
2305    for (const message of messages) {
2306      if (message.type === 'user') {
2307        // Check image paste IDs
2308        if (message.imagePasteIds) {
2309          for (const id of message.imagePasteIds) {
2310            if (id > maxId) maxId = id;
2311          }
2312        }
2313        // Check text paste references in message content
2314        if (Array.isArray(message.message.content)) {
2315          for (const block of message.message.content) {
2316            if (block.type === 'text') {
2317              const refs = parseReferences(block.text);
2318              for (const ref of refs) {
2319                if (ref.id > maxId) maxId = ref.id;
2320              }
2321            }
2322          }
2323        }
2324      }
2325    }
2326    return maxId + 1;
2327  }
2328  function buildBorderText(showFastIcon: boolean, showFastIconHint: boolean, fastModeCooldown: boolean): BorderTextOptions | undefined {
2329    if (!showFastIcon) return undefined;
2330    const fastSeg = showFastIconHint ? `${getFastIconString(true, fastModeCooldown)} ${chalk.dim('/fast')}` : getFastIconString(true, fastModeCooldown);
2331    return {
2332      content: ` ${fastSeg} `,
2333      position: 'top',
2334      align: 'end',
2335      offset: 0
2336    };
2337  }
2338  export default React.memo(PromptInput);
2339  //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","chalk","path","React","useCallback","useEffect","useMemo","useRef","useState","useSyncExternalStore","useNotifications","useCommandQueue","IDEAtMentioned","useIdeAtMentioned","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","AppState","useAppState","useAppStateStore","useSetAppState","FooterItem","getCwd","isQueuedCommandEditable","popAllEditable","stripAnsi","companionReservedColumns","findBuddyTriggerPositions","useBuddyNotification","FastModePicker","isUltrareviewEnabled","getNativeCSIuTerminalDisplayName","Command","hasCommand","useIsModalOverlayActive","useSetPromptOverlayDialog","formatImageRef","formatPastedTextRef","getPastedTextRefNumLines","parseReferences","VerificationStatus","HistoryMode","useArrowKeyHistory","useDoublePress","useHistorySearch","IDESelection","useInputBuffer","useMainLoopModel","usePromptSuggestion","useTerminalSize","useTypeahead","BorderTextOptions","stringWidth","Box","ClickEvent","Key","Text","useInput","useOptionalKeybindingContext","getShortcutDisplay","useKeybinding","useKeybindings","MCPServerConnection","abortPromptSuggestion","logSuggestionSuppressed","ActiveSpeculationState","abortSpeculation","getActiveAgentForInput","getViewedTeammateTask","enterTeammateView","exitTeammateView","stopOrDismissAgent","ToolPermissionContext","getRunningTeammatesSorted","InProcessTeammateTaskState","isPanelAgentTask","LocalAgentTaskState","isBackgroundTask","AGENT_COLOR_TO_THEME_COLOR","AGENT_COLORS","AgentColorName","AgentDefinition","Message","PermissionMode","BaseTextInputProps","PromptInputMode","VimMode","isAgentSwarmsEnabled","count","AutoUpdaterResult","Cursor","getGlobalConfig","PastedContent","saveGlobalConfig","logForDebugging","parseDirectMemberMessage","sendDirectMemberMessage","EffortLevel","env","errorMessage","isBilledAsExtraUsage","getFastModeUnavailableReason","isFastModeAvailable","isFastModeCooldown","isFastModeEnabled","isFastModeSupportedByModel","isFullscreenEnvEnabled","PromptInputHelpers","getImageFromClipboard","PASTE_THRESHOLD","ImageDimensions","cacheImagePath","storeImage","isMacosOptionChar","MACOS_OPTION_SPECIAL_CHARS","logError","isOpus1mMergeEnabled","modelDisplayString","setAutoModeActive","cyclePermissionMode","getNextPermissionMode","transitionPermissionMode","getPlatform","ProcessUserInputContext","editPromptInEditor","hasAutoModeOptIn","findBtwTriggerPositions","findSlashCommandPositions","findSlackChannelPositions","getKnownChannelsVersion","hasSlackMcpServer","subscribeKnownChannels","isInProcessEnabled","syncTeammateMode","TeamSummary","getTeammateColor","isInProcessTeammate","writeToMailbox","TextHighlight","Theme","findThinkingTriggerPositions","getRainbowColor","isUltrathinkEnabled","findTokenBudgetPositions","findUltraplanTriggerPositions","findUltrareviewTriggerPositions","AutoModeOptInDialog","BridgeDialog","ConfigurableShortcutHint","getVisibleAgentTasks","useCoordinatorTaskCount","getEffortNotificationText","getFastIconString","GlobalSearchDialog","HistorySearchDialog","ModelPicker","QuickOpenDialog","TextInput","ThinkingToggle","BackgroundTasksDialog","shouldHideTasksFooter","TeamsDialog","VimTextInput","getModeFromInput","getValueFromInput","FOOTER_TEMPORARY_STATUS_TIMEOUT","Notifications","PromptInputFooter","SuggestionItem","PromptInputModeIndicator","PromptInputQueuedCommands","PromptInputStashNotice","useMaybeTruncateInput","usePromptInputPlaceholder","useShowFastIconHint","useSwarmBanner","isNonSpacePrintable","isVimModeEnabled","Props","debug","ideSelection","toolPermissionContext","setToolPermissionContext","ctx","apiKeyStatus","commands","agents","isLoading","verbose","messages","onAutoUpdaterResult","result","autoUpdaterResult","input","onInputChange","value","mode","onModeChange","stashedPrompt","text","cursorOffset","pastedContents","Record","setStashedPrompt","submitCount","onShowMessageSelector","onMessageActionsEnter","mcpClients","setPastedContents","Dispatch","SetStateAction","vimMode","setVimMode","showBashesDialog","setShowBashesDialog","show","onExit","getToolUseContext","newMessages","abortController","AbortController","mainLoopModel","onSubmit","helpers","speculationAccept","state","speculationSessionTimeSavedMs","setAppState","f","prev","options","fromKeybinding","Promise","onAgentSubmit","task","isSearchingHistory","setIsSearchingHistory","isSearching","onDismissSideQuestion","isSideQuestionVisible","helpOpen","setHelpOpen","hasSuppressedDialogs","isLocalJSXCommandActive","insertTextRef","MutableRefObject","insert","setInputWithCursor","cursor","voiceInterimRange","start","end","PROMPT_FOOTER_LINES","MIN_INPUT_VIEWPORT_LINES","PromptInput","onSubmitProp","ReactNode","isModalOverlayActive","isAutoUpdating","setIsAutoUpdating","exitMessage","setExitMessage","key","setCursorOffset","length","lastInternalInputRef","current","trackAndSetInput","needsSpace","test","insertText","newValue","slice","store","tasks","s","replBridgeConnected","replBridgeExplicit","replBridgeReconnecting","bridgeFooterVisible","hasTungstenSession","tungstenActiveSession","undefined","tmuxFooterVisible","bagelFooterVisible","teamContext","queuedCommands","promptSuggestionState","promptSuggestion","speculation","viewingAgentTaskId","viewSelectionMode","showSpinnerTree","expandedView","companion","_companion","companionMuted","companionFooterVisible","briefOwnsGap","isBriefOnly","mainLoopModel_","mainLoopModelForSession","thinkingEnabled","isFastMode","fastMode","effortValue","viewedTeammate","getState","viewingAgentName","identity","agentName","viewingAgentColor","color","includes","inProcessTeammates","isTeammateMode","effectiveToolPermissionContext","permissionMode","historyQuery","setHistoryQuery","historyMatch","historyFailedMatch","entry","display","nextPasteIdRef","getInitialPasteId","pendingSpaceAfterPillRef","showTeamsDialog","setShowTeamsDialog","showBridgeDialog","setShowBridgeDialog","teammateFooterIndex","setTeammateFooterIndex","coordinatorTaskIndex","setCoordinatorTaskIndex","v","next","coordinatorTaskCount","hasBgTaskPill","Object","values","some","t","minCoordinatorIndex","Math","max","isPasting","setIsPasting","isExternalEditorActive","setIsExternalEditorActive","showModelPicker","setShowModelPicker","showQuickOpen","setShowQuickOpen","showGlobalSearch","setShowGlobalSearch","showHistoryPicker","setShowHistoryPicker","showFastModePicker","setShowFastModePicker","showThinkingToggle","setShowThinkingToggle","showAutoModeOptIn","setShowAutoModeOptIn","previousModeBeforeAuto","setPreviousModeBeforeAuto","autoModeOptInTimeoutRef","NodeJS","Timeout","isCursorOnFirstLine","firstNewlineIndex","indexOf","isCursorOnLastLine","lastNewlineIndex","lastIndexOf","cachedTeams","teammateCount","teammates","name","teamName","memberCount","runningCount","idleCount","runningTaskCount","status","tasksFooterVisible","teamsFooterVisible","footerItems","filter","Boolean","rawFooterSelection","footerSelection","footerItemSelected","tasksSelected","tmuxSelected","bagelSelected","teamsSelected","bridgeSelected","selectFooterItem","item","navigateFooter","delta","exitAtStart","idx","suggestion","markAccepted","logOutcomeAtSubmission","markShown","inputValue","isAssistantResponding","displayedValue","thinkTriggers","ultraplanSessionUrl","ultraplanLaunching","ultraplanTriggers","ultrareviewTriggers","btwTriggers","buddyTriggers","slashCommandTriggers","positions","pos","commandName","tokenBudgetTriggers","knownChannelsVersion","slackChannelTriggers","mcp","clients","memberMentionHighlights","Array","themeColor","highlights","members","regex","memberValues","match","exec","leadingSpace","nameStart","index","fullMatch","trimStart","member","find","push","imageRefPositions","r","startsWith","map","cursorAtImageChip","inside","mid","combinedHighlights","ref","inverse","priority","trigger","mention","dimColor","i","shimmerColor","addNotification","removeNotification","timeoutMs","prevInputLengthRef","peakInputLengthRef","dismissStashHint","prevLength","peakLength","currentLength","clearedSubstantialInput","wasRapidClear","config","hasUsedStash","jsx","pushToBuffer","undo","canUndo","clearBuffer","maxBufferSize","debounceMs","defaultPlaceholder","onChange","isSingleCharInsertion","insertedAtStart","valueWithoutMode","replaceAll","processedValue","resetHistory","onHistoryUp","onHistoryDown","dismissSearchHint","historyIndex","historyMode","handleHistoryUp","suggestions","hasEditableCommand","popAllCommandsFromQueue","handleHistoryDown","first","hasSeenTasksHint","c","suggestionsState","setSuggestionsStateRaw","selectedSuggestion","commandArgumentHint","setSuggestionsState","updater","inputParam","isSubmittingSlashCommand","trimEnd","hasImages","type","suggestionText","inputMatchesSuggestion","trim","skipReset","shownAt","directMessage","recipientName","message","success","error","hasDirectorySuggestions","every","description","activeAgent","inlineGhostText","maxColumnWidth","suppressSuggestions","showPromptSuggestion","promptId","acceptedAt","generationRequestId","onImagePaste","image","mediaType","filename","dimensions","sourcePath","pasteId","newContent","id","content","prefix","insertTextAtCursor","referencedIds","Set","orphaned","has","img","onTextPaste","rawText","replace","pastedMode","numLines","maxLines","min","rows","lazySpaceInputFilter","newInput","doublePressEscFromEmpty","images","newContents","onIdeAtMentioned","atMentioned","atMentionedText","relativePath","relative","filePath","lineStart","lineEnd","cursorChar","handleUndo","previousState","handleNewline","handleExternalEditor","err","Error","handleStash","handleModelPicker","handleFastModePicker","handleThinkingToggle","handleCycleMode","teammateContext","nextMode","to","teammateTaskId","isAutoModeAvailable","isEnteringAutoModeFirstTime","clearTimeout","setTimeout","context","preparedContext","lastPlanModeUse","Date","now","handleAutoModeOptInAccept","strippedContext","handleAutoModeOptInDecline","handleImagePaste","then","imageData","base64","shortcutDisplay","isSSH","keybindingContext","registerHandler","action","handler","chatHandlers","isActive","quickSearchActive","footer:up","footer:down","footer:next","totalAgents","footer:previous","footer:openSelected","teammate","selectedTaskId","tungstenPanelAutoHidden","tungstenPanelVisible","footer:clearSelection","footer:close","char","shortcut","terminalName","ctrl","meta","escape","return","backspace","delete","swarmBanner","fastModeCooldown","showFastIcon","showFastIconHint","effortNotificationText","companionSpeaking","companionReaction","columns","textInputColumns","maxVisibleLines","floor","handleInputClick","e","fromText","viewportStart","getViewportStartLine","offset","measuredText","getOffsetFromPosition","line","localRow","column","localCol","handleOpenTasksDialog","taskId","placeholder","isInputWrapped","handleModelSelect","model","_effort","wasFastModeDisabled","effectiveFastMode","handleModelCancel","modelPickerElement","handleFastModeSelect","fastModePickerElement","handleThinkingSelect","enabled","handleThinkingCancel","thinkingToggleElement","m","autoModeOptInDialog","insertWithSpacing","entryMode","baseProps","multiline","onHistoryReset","onExitMessage","disableCursorMovementForUpDownKeys","disableEscapeDoublePress","onChangeCursorOffset","onPaste","onIsPastingChange","focus","showCursor","argumentHint","onUndo","inputFilter","getBorderColor","modeColors","bash","teammateColorName","textInputElement","bgColor","repeat","buildBorderText","maxId","imagePasteIds","isArray","block","refs","fastSeg","dim","position","align","memo"],"sources":["PromptInput.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport chalk from 'chalk'\nimport * as path from 'path'\nimport * as React from 'react'\nimport {\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n  useSyncExternalStore,\n} from 'react'\nimport { useNotifications } from 'src/context/notifications.js'\nimport { useCommandQueue } from 'src/hooks/useCommandQueue.js'\nimport {\n  type IDEAtMentioned,\n  useIdeAtMentioned,\n} from 'src/hooks/useIdeAtMentioned.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from 'src/services/analytics/index.js'\nimport {\n  type AppState,\n  useAppState,\n  useAppStateStore,\n  useSetAppState,\n} from 'src/state/AppState.js'\nimport type { FooterItem } from 'src/state/AppStateStore.js'\nimport { getCwd } from 'src/utils/cwd.js'\nimport {\n  isQueuedCommandEditable,\n  popAllEditable,\n} from 'src/utils/messageQueueManager.js'\nimport stripAnsi from 'strip-ansi'\nimport { companionReservedColumns } from '../../buddy/CompanionSprite.js'\nimport {\n  findBuddyTriggerPositions,\n  useBuddyNotification,\n} from '../../buddy/useBuddyNotification.js'\nimport { FastModePicker } from '../../commands/fast/fast.js'\nimport { isUltrareviewEnabled } from '../../commands/review/ultrareviewEnabled.js'\nimport { getNativeCSIuTerminalDisplayName } from '../../commands/terminalSetup/terminalSetup.js'\nimport { type Command, hasCommand } from '../../commands.js'\nimport { useIsModalOverlayActive } from '../../context/overlayContext.js'\nimport { useSetPromptOverlayDialog } from '../../context/promptOverlayContext.js'\nimport {\n  formatImageRef,\n  formatPastedTextRef,\n  getPastedTextRefNumLines,\n  parseReferences,\n} from '../../history.js'\nimport type { VerificationStatus } from '../../hooks/useApiKeyVerification.js'\nimport {\n  type HistoryMode,\n  useArrowKeyHistory,\n} from '../../hooks/useArrowKeyHistory.js'\nimport { useDoublePress } from '../../hooks/useDoublePress.js'\nimport { useHistorySearch } from '../../hooks/useHistorySearch.js'\nimport type { IDESelection } from '../../hooks/useIdeSelection.js'\nimport { useInputBuffer } from '../../hooks/useInputBuffer.js'\nimport { useMainLoopModel } from '../../hooks/useMainLoopModel.js'\nimport { usePromptSuggestion } from '../../hooks/usePromptSuggestion.js'\nimport { useTerminalSize } from '../../hooks/useTerminalSize.js'\nimport { useTypeahead } from '../../hooks/useTypeahead.js'\nimport type { BorderTextOptions } from '../../ink/render-border.js'\nimport { stringWidth } from '../../ink/stringWidth.js'\nimport { Box, type ClickEvent, type Key, Text, useInput } from '../../ink.js'\nimport { useOptionalKeybindingContext } from '../../keybindings/KeybindingContext.js'\nimport { getShortcutDisplay } from '../../keybindings/shortcutFormat.js'\nimport {\n  useKeybinding,\n  useKeybindings,\n} from '../../keybindings/useKeybinding.js'\nimport type { MCPServerConnection } from '../../services/mcp/types.js'\nimport {\n  abortPromptSuggestion,\n  logSuggestionSuppressed,\n} from '../../services/PromptSuggestion/promptSuggestion.js'\nimport {\n  type ActiveSpeculationState,\n  abortSpeculation,\n} from '../../services/PromptSuggestion/speculation.js'\nimport {\n  getActiveAgentForInput,\n  getViewedTeammateTask,\n} from '../../state/selectors.js'\nimport {\n  enterTeammateView,\n  exitTeammateView,\n  stopOrDismissAgent,\n} from '../../state/teammateViewHelpers.js'\nimport type { ToolPermissionContext } from '../../Tool.js'\nimport { getRunningTeammatesSorted } from '../../tasks/InProcessTeammateTask/InProcessTeammateTask.js'\nimport type { InProcessTeammateTaskState } from '../../tasks/InProcessTeammateTask/types.js'\nimport {\n  isPanelAgentTask,\n  type LocalAgentTaskState,\n} from '../../tasks/LocalAgentTask/LocalAgentTask.js'\nimport { isBackgroundTask } from '../../tasks/types.js'\nimport {\n  AGENT_COLOR_TO_THEME_COLOR,\n  AGENT_COLORS,\n  type AgentColorName,\n} from '../../tools/AgentTool/agentColorManager.js'\nimport type { AgentDefinition } from '../../tools/AgentTool/loadAgentsDir.js'\nimport type { Message } from '../../types/message.js'\nimport type { PermissionMode } from '../../types/permissions.js'\nimport type {\n  BaseTextInputProps,\n  PromptInputMode,\n  VimMode,\n} from '../../types/textInputTypes.js'\nimport { isAgentSwarmsEnabled } from '../../utils/agentSwarmsEnabled.js'\nimport { count } from '../../utils/array.js'\nimport type { AutoUpdaterResult } from '../../utils/autoUpdater.js'\nimport { Cursor } from '../../utils/Cursor.js'\nimport {\n  getGlobalConfig,\n  type PastedContent,\n  saveGlobalConfig,\n} from '../../utils/config.js'\nimport { logForDebugging } from '../../utils/debug.js'\nimport {\n  parseDirectMemberMessage,\n  sendDirectMemberMessage,\n} from '../../utils/directMemberMessage.js'\nimport type { EffortLevel } from '../../utils/effort.js'\nimport { env } from '../../utils/env.js'\nimport { errorMessage } from '../../utils/errors.js'\nimport { isBilledAsExtraUsage } from '../../utils/extraUsage.js'\nimport {\n  getFastModeUnavailableReason,\n  isFastModeAvailable,\n  isFastModeCooldown,\n  isFastModeEnabled,\n  isFastModeSupportedByModel,\n} from '../../utils/fastMode.js'\nimport { isFullscreenEnvEnabled } from '../../utils/fullscreen.js'\nimport type { PromptInputHelpers } from '../../utils/handlePromptSubmit.js'\nimport {\n  getImageFromClipboard,\n  PASTE_THRESHOLD,\n} from '../../utils/imagePaste.js'\nimport type { ImageDimensions } from '../../utils/imageResizer.js'\nimport { cacheImagePath, storeImage } from '../../utils/imageStore.js'\nimport {\n  isMacosOptionChar,\n  MACOS_OPTION_SPECIAL_CHARS,\n} from '../../utils/keyboardShortcuts.js'\nimport { logError } from '../../utils/log.js'\nimport {\n  isOpus1mMergeEnabled,\n  modelDisplayString,\n} from '../../utils/model/model.js'\nimport { setAutoModeActive } from '../../utils/permissions/autoModeState.js'\nimport {\n  cyclePermissionMode,\n  getNextPermissionMode,\n} from '../../utils/permissions/getNextPermissionMode.js'\nimport { transitionPermissionMode } from '../../utils/permissions/permissionSetup.js'\nimport { getPlatform } from '../../utils/platform.js'\nimport type { ProcessUserInputContext } from '../../utils/processUserInput/processUserInput.js'\nimport { editPromptInEditor } from '../../utils/promptEditor.js'\nimport { hasAutoModeOptIn } from '../../utils/settings/settings.js'\nimport { findBtwTriggerPositions } from '../../utils/sideQuestion.js'\nimport { findSlashCommandPositions } from '../../utils/suggestions/commandSuggestions.js'\nimport {\n  findSlackChannelPositions,\n  getKnownChannelsVersion,\n  hasSlackMcpServer,\n  subscribeKnownChannels,\n} from '../../utils/suggestions/slackChannelSuggestions.js'\nimport { isInProcessEnabled } from '../../utils/swarm/backends/registry.js'\nimport { syncTeammateMode } from '../../utils/swarm/teamHelpers.js'\nimport type { TeamSummary } from '../../utils/teamDiscovery.js'\nimport { getTeammateColor } from '../../utils/teammate.js'\nimport { isInProcessTeammate } from '../../utils/teammateContext.js'\nimport { writeToMailbox } from '../../utils/teammateMailbox.js'\nimport type { TextHighlight } from '../../utils/textHighlighting.js'\nimport type { Theme } from '../../utils/theme.js'\nimport {\n  findThinkingTriggerPositions,\n  getRainbowColor,\n  isUltrathinkEnabled,\n} from '../../utils/thinking.js'\nimport { findTokenBudgetPositions } from '../../utils/tokenBudget.js'\nimport {\n  findUltraplanTriggerPositions,\n  findUltrareviewTriggerPositions,\n} from '../../utils/ultraplan/keyword.js'\nimport { AutoModeOptInDialog } from '../AutoModeOptInDialog.js'\nimport { BridgeDialog } from '../BridgeDialog.js'\nimport { ConfigurableShortcutHint } from '../ConfigurableShortcutHint.js'\nimport {\n  getVisibleAgentTasks,\n  useCoordinatorTaskCount,\n} from '../CoordinatorAgentStatus.js'\nimport { getEffortNotificationText } from '../EffortIndicator.js'\nimport { getFastIconString } from '../FastIcon.js'\nimport { GlobalSearchDialog } from '../GlobalSearchDialog.js'\nimport { HistorySearchDialog } from '../HistorySearchDialog.js'\nimport { ModelPicker } from '../ModelPicker.js'\nimport { QuickOpenDialog } from '../QuickOpenDialog.js'\nimport TextInput from '../TextInput.js'\nimport { ThinkingToggle } from '../ThinkingToggle.js'\nimport { BackgroundTasksDialog } from '../tasks/BackgroundTasksDialog.js'\nimport { shouldHideTasksFooter } from '../tasks/taskStatusUtils.js'\nimport { TeamsDialog } from '../teams/TeamsDialog.js'\nimport VimTextInput from '../VimTextInput.js'\nimport { getModeFromInput, getValueFromInput } from './inputModes.js'\nimport {\n  FOOTER_TEMPORARY_STATUS_TIMEOUT,\n  Notifications,\n} from './Notifications.js'\nimport PromptInputFooter from './PromptInputFooter.js'\nimport type { SuggestionItem } from './PromptInputFooterSuggestions.js'\nimport { PromptInputModeIndicator } from './PromptInputModeIndicator.js'\nimport { PromptInputQueuedCommands } from './PromptInputQueuedCommands.js'\nimport { PromptInputStashNotice } from './PromptInputStashNotice.js'\nimport { useMaybeTruncateInput } from './useMaybeTruncateInput.js'\nimport { usePromptInputPlaceholder } from './usePromptInputPlaceholder.js'\nimport { useShowFastIconHint } from './useShowFastIconHint.js'\nimport { useSwarmBanner } from './useSwarmBanner.js'\nimport { isNonSpacePrintable, isVimModeEnabled } from './utils.js'\n\ntype Props = {\n  debug: boolean\n  ideSelection: IDESelection | undefined\n  toolPermissionContext: ToolPermissionContext\n  setToolPermissionContext: (ctx: ToolPermissionContext) => void\n  apiKeyStatus: VerificationStatus\n  commands: Command[]\n  agents: AgentDefinition[]\n  isLoading: boolean\n  verbose: boolean\n  messages: Message[]\n  onAutoUpdaterResult: (result: AutoUpdaterResult) => void\n  autoUpdaterResult: AutoUpdaterResult | null\n  input: string\n  onInputChange: (value: string) => void\n  mode: PromptInputMode\n  onModeChange: (mode: PromptInputMode) => void\n  stashedPrompt:\n    | {\n        text: string\n        cursorOffset: number\n        pastedContents: Record<number, PastedContent>\n      }\n    | undefined\n  setStashedPrompt: (\n    value:\n      | {\n          text: string\n          cursorOffset: number\n          pastedContents: Record<number, PastedContent>\n        }\n      | undefined,\n  ) => void\n  submitCount: number\n  onShowMessageSelector: () => void\n  /** Fullscreen message actions: shift+↑ enters cursor. */\n  onMessageActionsEnter?: () => void\n  mcpClients: MCPServerConnection[]\n  pastedContents: Record<number, PastedContent>\n  setPastedContents: React.Dispatch<\n    React.SetStateAction<Record<number, PastedContent>>\n  >\n  vimMode: VimMode\n  setVimMode: (mode: VimMode) => void\n  showBashesDialog: string | boolean\n  setShowBashesDialog: (show: string | boolean) => void\n  onExit: () => void\n  getToolUseContext: (\n    messages: Message[],\n    newMessages: Message[],\n    abortController: AbortController,\n    mainLoopModel: string,\n  ) => ProcessUserInputContext\n  onSubmit: (\n    input: string,\n    helpers: PromptInputHelpers,\n    speculationAccept?: {\n      state: ActiveSpeculationState\n      speculationSessionTimeSavedMs: number\n      setAppState: (f: (prev: AppState) => AppState) => void\n    },\n    options?: { fromKeybinding?: boolean },\n  ) => Promise<void>\n  onAgentSubmit?: (\n    input: string,\n    task: InProcessTeammateTaskState | LocalAgentTaskState,\n    helpers: PromptInputHelpers,\n  ) => Promise<void>\n  isSearchingHistory: boolean\n  setIsSearchingHistory: (isSearching: boolean) => void\n  onDismissSideQuestion?: () => void\n  isSideQuestionVisible?: boolean\n  helpOpen: boolean\n  setHelpOpen: React.Dispatch<React.SetStateAction<boolean>>\n  hasSuppressedDialogs?: boolean\n  isLocalJSXCommandActive?: boolean\n  insertTextRef?: React.MutableRefObject<{\n    insert: (text: string) => void\n    setInputWithCursor: (value: string, cursor: number) => void\n    cursorOffset: number\n  } | null>\n  voiceInterimRange?: { start: number; end: number } | null\n}\n\n// Bottom slot has maxHeight=\"50%\"; reserve lines for footer, border, status.\nconst PROMPT_FOOTER_LINES = 5\nconst MIN_INPUT_VIEWPORT_LINES = 3\n\nfunction PromptInput({\n  debug,\n  ideSelection,\n  toolPermissionContext,\n  setToolPermissionContext,\n  apiKeyStatus,\n  commands,\n  agents,\n  isLoading,\n  verbose,\n  messages,\n  onAutoUpdaterResult,\n  autoUpdaterResult,\n  input,\n  onInputChange,\n  mode,\n  onModeChange,\n  stashedPrompt,\n  setStashedPrompt,\n  submitCount,\n  onShowMessageSelector,\n  onMessageActionsEnter,\n  mcpClients,\n  pastedContents,\n  setPastedContents,\n  vimMode,\n  setVimMode,\n  showBashesDialog,\n  setShowBashesDialog,\n  onExit,\n  getToolUseContext,\n  onSubmit: onSubmitProp,\n  onAgentSubmit,\n  isSearchingHistory,\n  setIsSearchingHistory,\n  onDismissSideQuestion,\n  isSideQuestionVisible,\n  helpOpen,\n  setHelpOpen,\n  hasSuppressedDialogs,\n  isLocalJSXCommandActive = false,\n  insertTextRef,\n  voiceInterimRange,\n}: Props): React.ReactNode {\n  const mainLoopModel = useMainLoopModel()\n  // A local-jsx command (e.g., /mcp while agent is running) renders a full-\n  // screen dialog on top of PromptInput via the immediate-command path with\n  // shouldHidePromptInput: false. Those dialogs don't register in the overlay\n  // system, so treat them as a modal overlay here to stop navigation keys from\n  // leaking into TextInput/footer handlers and stacking a second dialog.\n  const isModalOverlayActive =\n    useIsModalOverlayActive() || isLocalJSXCommandActive\n  const [isAutoUpdating, setIsAutoUpdating] = useState(false)\n  const [exitMessage, setExitMessage] = useState<{\n    show: boolean\n    key?: string\n  }>({ show: false })\n  const [cursorOffset, setCursorOffset] = useState<number>(input.length)\n  // Track the last input value set via internal handlers so we can detect\n  // external input changes (e.g. speech-to-text injection) and move cursor to end.\n  const lastInternalInputRef = React.useRef(input)\n  if (input !== lastInternalInputRef.current) {\n    // Input changed externally (not through any internal handler) — move cursor to end\n    setCursorOffset(input.length)\n    lastInternalInputRef.current = input\n  }\n  // Wrap onInputChange to track internal changes before they trigger re-render\n  const trackAndSetInput = React.useCallback(\n    (value: string) => {\n      lastInternalInputRef.current = value\n      onInputChange(value)\n    },\n    [onInputChange],\n  )\n  // Expose an insertText function so callers (e.g. STT) can splice text at the\n  // current cursor position instead of replacing the entire input.\n  if (insertTextRef) {\n    insertTextRef.current = {\n      cursorOffset,\n      insert: (text: string) => {\n        const needsSpace =\n          cursorOffset === input.length &&\n          input.length > 0 &&\n          !/\\s$/.test(input)\n        const insertText = needsSpace ? ' ' + text : text\n        const newValue =\n          input.slice(0, cursorOffset) + insertText + input.slice(cursorOffset)\n        lastInternalInputRef.current = newValue\n        onInputChange(newValue)\n        setCursorOffset(cursorOffset + insertText.length)\n      },\n      setInputWithCursor: (value: string, cursor: number) => {\n        lastInternalInputRef.current = value\n        onInputChange(value)\n        setCursorOffset(cursor)\n      },\n    }\n  }\n  const store = useAppStateStore()\n  const setAppState = useSetAppState()\n  const tasks = useAppState(s => s.tasks)\n  const replBridgeConnected = useAppState(s => s.replBridgeConnected)\n  const replBridgeExplicit = useAppState(s => s.replBridgeExplicit)\n  const replBridgeReconnecting = useAppState(s => s.replBridgeReconnecting)\n  // Must match BridgeStatusIndicator's render condition (PromptInputFooter.tsx) —\n  // the pill returns null for implicit-and-not-reconnecting, so nav must too,\n  // otherwise bridge becomes an invisible selection stop.\n  const bridgeFooterVisible =\n    replBridgeConnected && (replBridgeExplicit || replBridgeReconnecting)\n  // Tmux pill (ant-only) — visible when there's an active tungsten session\n  const hasTungstenSession = useAppState(\n    s =>\n      \"external\" === 'ant' && s.tungstenActiveSession !== undefined,\n  )\n  const tmuxFooterVisible =\n    \"external\" === 'ant' && hasTungstenSession\n  // WebBrowser pill — visible when a browser is open\n  const bagelFooterVisible = useAppState(s =>\n        false,\n  )\n  const teamContext = useAppState(s => s.teamContext)\n  const queuedCommands = useCommandQueue()\n  const promptSuggestionState = useAppState(s => s.promptSuggestion)\n  const speculation = useAppState(s => s.speculation)\n  const speculationSessionTimeSavedMs = useAppState(\n    s => s.speculationSessionTimeSavedMs,\n  )\n  const viewingAgentTaskId = useAppState(s => s.viewingAgentTaskId)\n  const viewSelectionMode = useAppState(s => s.viewSelectionMode)\n  const showSpinnerTree = useAppState(s => s.expandedView) === 'teammates'\n  const { companion: _companion, companionMuted } = feature('BUDDY')\n    ? getGlobalConfig()\n    : { companion: undefined, companionMuted: undefined }\n  const companionFooterVisible = !!_companion && !companionMuted\n  // Brief mode: BriefSpinner/BriefIdleStatus own the 2-row footprint above\n  // the input. Dropping marginTop here lets the spinner sit flush against\n  // the input bar. viewingAgentTaskId mirrors the gate on both (Spinner.tsx,\n  // REPL.tsx) — teammate view falls back to SpinnerWithVerbInner which has\n  // its own marginTop, so the gap stays even without ours.\n  const briefOwnsGap =\n    feature('KAIROS') || feature('KAIROS_BRIEF')\n      ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n        useAppState(s => s.isBriefOnly) && !viewingAgentTaskId\n      : false\n  const mainLoopModel_ = useAppState(s => s.mainLoopModel)\n  const mainLoopModelForSession = useAppState(s => s.mainLoopModelForSession)\n  const thinkingEnabled = useAppState(s => s.thinkingEnabled)\n  const isFastMode = useAppState(s =>\n    isFastModeEnabled() ? s.fastMode : false,\n  )\n  const effortValue = useAppState(s => s.effortValue)\n  const viewedTeammate = getViewedTeammateTask(store.getState())\n  const viewingAgentName = viewedTeammate?.identity.agentName\n  // identity.color is typed as `string | undefined` (not AgentColorName) because\n  // teammate identity comes from file-based config. Validate before casting to\n  // ensure we only use valid color names (falls back to cyan if invalid).\n  const viewingAgentColor =\n    viewedTeammate?.identity.color &&\n    AGENT_COLORS.includes(viewedTeammate.identity.color as AgentColorName)\n      ? (viewedTeammate.identity.color as AgentColorName)\n      : undefined\n  // In-process teammates sorted alphabetically for footer team selector\n  const inProcessTeammates = useMemo(\n    () => getRunningTeammatesSorted(tasks),\n    [tasks],\n  )\n\n  // Team mode: all background tasks are in-process teammates\n  const isTeammateMode =\n    inProcessTeammates.length > 0 || viewedTeammate !== undefined\n\n  // When viewing a teammate, show their permission mode in the footer instead of the leader's\n  const effectiveToolPermissionContext = useMemo((): ToolPermissionContext => {\n    if (viewedTeammate) {\n      return {\n        ...toolPermissionContext,\n        mode: viewedTeammate.permissionMode,\n      }\n    }\n    return toolPermissionContext\n  }, [viewedTeammate, toolPermissionContext])\n  const { historyQuery, setHistoryQuery, historyMatch, historyFailedMatch } =\n    useHistorySearch(\n      entry => {\n        setPastedContents(entry.pastedContents)\n        void onSubmit(entry.display)\n      },\n      input,\n      trackAndSetInput,\n      setCursorOffset,\n      cursorOffset,\n      onModeChange,\n      mode,\n      isSearchingHistory,\n      setIsSearchingHistory,\n      setPastedContents,\n      pastedContents,\n    )\n  // Counter for paste IDs (shared between images and text).\n  // Compute initial value once from existing messages (for --continue/--resume).\n  // useRef(fn()) evaluates fn() on every render and discards the result after\n  // mount — getInitialPasteId walks all messages + regex-scans text blocks,\n  // so guard with a lazy-init pattern to run it exactly once.\n  const nextPasteIdRef = useRef(-1)\n  if (nextPasteIdRef.current === -1) {\n    nextPasteIdRef.current = getInitialPasteId(messages)\n  }\n  // Armed by onImagePaste; if the very next keystroke is a non-space\n  // printable, inputFilter prepends a space before it. Any other input\n  // (arrow, escape, backspace, paste, space) disarms without inserting.\n  const pendingSpaceAfterPillRef = useRef(false)\n\n  const [showTeamsDialog, setShowTeamsDialog] = useState(false)\n  const [showBridgeDialog, setShowBridgeDialog] = useState(false)\n  const [teammateFooterIndex, setTeammateFooterIndex] = useState(0)\n  // -1 sentinel: tasks pill is selected but no specific agent row is selected yet.\n  // First ↓ selects the pill, second ↓ moves to row 0. Prevents double-select\n  // of pill + row when both bg tasks (pill) and forked agents (rows) are visible.\n  const coordinatorTaskIndex = useAppState(s => s.coordinatorTaskIndex)\n  const setCoordinatorTaskIndex = useCallback(\n    (v: number | ((prev: number) => number)) =>\n      setAppState(prev => {\n        const next = typeof v === 'function' ? v(prev.coordinatorTaskIndex) : v\n        if (next === prev.coordinatorTaskIndex) return prev\n        return { ...prev, coordinatorTaskIndex: next }\n      }),\n    [setAppState],\n  )\n  const coordinatorTaskCount = useCoordinatorTaskCount()\n  // The pill (BackgroundTaskStatus) only renders when non-local_agent bg tasks\n  // exist. When only local_agent tasks are running (coordinator/fork mode), the\n  // pill is absent, so the -1 sentinel would leave nothing visually selected.\n  // In that case, skip -1 and treat 0 as the minimum selectable index.\n  const hasBgTaskPill = useMemo(\n    () =>\n      Object.values(tasks).some(\n        t =>\n          isBackgroundTask(t) &&\n          !(\"external\" === 'ant' && isPanelAgentTask(t)),\n      ),\n    [tasks],\n  )\n  const minCoordinatorIndex = hasBgTaskPill ? -1 : 0\n  // Clamp index when tasks complete and the list shrinks beneath the cursor\n  useEffect(() => {\n    if (coordinatorTaskIndex >= coordinatorTaskCount) {\n      setCoordinatorTaskIndex(\n        Math.max(minCoordinatorIndex, coordinatorTaskCount - 1),\n      )\n    } else if (coordinatorTaskIndex < minCoordinatorIndex) {\n      setCoordinatorTaskIndex(minCoordinatorIndex)\n    }\n  }, [coordinatorTaskCount, coordinatorTaskIndex, minCoordinatorIndex])\n  const [isPasting, setIsPasting] = useState(false)\n  const [isExternalEditorActive, setIsExternalEditorActive] = useState(false)\n  const [showModelPicker, setShowModelPicker] = useState(false)\n  const [showQuickOpen, setShowQuickOpen] = useState(false)\n  const [showGlobalSearch, setShowGlobalSearch] = useState(false)\n  const [showHistoryPicker, setShowHistoryPicker] = useState(false)\n  const [showFastModePicker, setShowFastModePicker] = useState(false)\n  const [showThinkingToggle, setShowThinkingToggle] = useState(false)\n  const [showAutoModeOptIn, setShowAutoModeOptIn] = useState(false)\n  const [previousModeBeforeAuto, setPreviousModeBeforeAuto] =\n    useState<PermissionMode | null>(null)\n  const autoModeOptInTimeoutRef = useRef<NodeJS.Timeout | null>(null)\n\n  // Check if cursor is on the first line of input\n  const isCursorOnFirstLine = useMemo(() => {\n    const firstNewlineIndex = input.indexOf('\\n')\n    if (firstNewlineIndex === -1) {\n      return true // No newlines, cursor is always on first line\n    }\n    return cursorOffset <= firstNewlineIndex\n  }, [input, cursorOffset])\n\n  const isCursorOnLastLine = useMemo(() => {\n    const lastNewlineIndex = input.lastIndexOf('\\n')\n    if (lastNewlineIndex === -1) {\n      return true // No newlines, cursor is always on last line\n    }\n    return cursorOffset > lastNewlineIndex\n  }, [input, cursorOffset])\n\n  // Derive team info from teamContext (no filesystem I/O needed)\n  // A session can only lead one team at a time\n  const cachedTeams: TeamSummary[] = useMemo(() => {\n    if (!isAgentSwarmsEnabled()) return []\n    // In-process mode uses Shift+Down/Up navigation instead of footer menu\n    if (isInProcessEnabled()) return []\n    if (!teamContext) {\n      return []\n    }\n    const teammateCount = count(\n      Object.values(teamContext.teammates),\n      t => t.name !== 'team-lead',\n    )\n    return [\n      {\n        name: teamContext.teamName,\n        memberCount: teammateCount,\n        runningCount: 0,\n        idleCount: 0,\n      },\n    ]\n  }, [teamContext])\n\n  // ─── Footer pill navigation ─────────────────────────────────────────────\n  // Which pills render below the input box. Order here IS the nav order\n  // (down/right = forward, up/left = back). Selection lives in AppState so\n  // pills rendered outside PromptInput (CompanionSprite) can read focus.\n  const runningTaskCount = useMemo(\n    () => count(Object.values(tasks), t => t.status === 'running'),\n    [tasks],\n  )\n  // Panel shows retained-completed agents too (getVisibleAgentTasks), so the\n  // pill must stay navigable whenever the panel has rows — not just when\n  // something is running.\n  const tasksFooterVisible =\n    (runningTaskCount > 0 ||\n      (\"external\" === 'ant' && coordinatorTaskCount > 0)) &&\n    !shouldHideTasksFooter(tasks, showSpinnerTree)\n  const teamsFooterVisible = cachedTeams.length > 0\n\n  const footerItems = useMemo(\n    () =>\n      [\n        tasksFooterVisible && 'tasks',\n        tmuxFooterVisible && 'tmux',\n        bagelFooterVisible && 'bagel',\n        teamsFooterVisible && 'teams',\n        bridgeFooterVisible && 'bridge',\n        companionFooterVisible && 'companion',\n      ].filter(Boolean) as FooterItem[],\n    [\n      tasksFooterVisible,\n      tmuxFooterVisible,\n      bagelFooterVisible,\n      teamsFooterVisible,\n      bridgeFooterVisible,\n      companionFooterVisible,\n    ],\n  )\n\n  // Effective selection: null if the selected pill stopped rendering (bridge\n  // disconnected, task finished). The derivation makes the UI correct\n  // immediately; the useEffect below clears the raw state so it doesn't\n  // resurrect when the same pill reappears (new task starts → focus stolen).\n  const rawFooterSelection = useAppState(s => s.footerSelection)\n  const footerItemSelected =\n    rawFooterSelection && footerItems.includes(rawFooterSelection)\n      ? rawFooterSelection\n      : null\n\n  useEffect(() => {\n    if (rawFooterSelection && !footerItemSelected) {\n      setAppState(prev =>\n        prev.footerSelection === null\n          ? prev\n          : { ...prev, footerSelection: null },\n      )\n    }\n  }, [rawFooterSelection, footerItemSelected, setAppState])\n\n  const tasksSelected = footerItemSelected === 'tasks'\n  const tmuxSelected = footerItemSelected === 'tmux'\n  const bagelSelected = footerItemSelected === 'bagel'\n  const teamsSelected = footerItemSelected === 'teams'\n  const bridgeSelected = footerItemSelected === 'bridge'\n\n  function selectFooterItem(item: FooterItem | null): void {\n    setAppState(prev =>\n      prev.footerSelection === item ? prev : { ...prev, footerSelection: item },\n    )\n    if (item === 'tasks') {\n      setTeammateFooterIndex(0)\n      setCoordinatorTaskIndex(minCoordinatorIndex)\n    }\n  }\n\n  // delta: +1 = down/right, -1 = up/left. Returns true if nav happened\n  // (including deselecting at the start), false if at a boundary.\n  function navigateFooter(delta: 1 | -1, exitAtStart = false): boolean {\n    const idx = footerItemSelected\n      ? footerItems.indexOf(footerItemSelected)\n      : -1\n    const next = footerItems[idx + delta]\n    if (next) {\n      selectFooterItem(next)\n      return true\n    }\n    if (delta < 0 && exitAtStart) {\n      selectFooterItem(null)\n      return true\n    }\n    return false\n  }\n\n  // Prompt suggestion hook - reads suggestions generated by forked agent in query loop\n  const {\n    suggestion: promptSuggestion,\n    markAccepted,\n    logOutcomeAtSubmission,\n    markShown,\n  } = usePromptSuggestion({\n    inputValue: input,\n    isAssistantResponding: isLoading,\n  })\n\n  const displayedValue = useMemo(\n    () =>\n      isSearchingHistory && historyMatch\n        ? getValueFromInput(\n            typeof historyMatch === 'string'\n              ? historyMatch\n              : historyMatch.display,\n          )\n        : input,\n    [isSearchingHistory, historyMatch, input],\n  )\n\n  const thinkTriggers = useMemo(\n    () => findThinkingTriggerPositions(displayedValue),\n    [displayedValue],\n  )\n\n  const ultraplanSessionUrl = useAppState(s => s.ultraplanSessionUrl)\n  const ultraplanLaunching = useAppState(s => s.ultraplanLaunching)\n  const ultraplanTriggers = useMemo(\n    () =>\n      feature('ULTRAPLAN') && !ultraplanSessionUrl && !ultraplanLaunching\n        ? findUltraplanTriggerPositions(displayedValue)\n        : [],\n    [displayedValue, ultraplanSessionUrl, ultraplanLaunching],\n  )\n\n  const ultrareviewTriggers = useMemo(\n    () =>\n      isUltrareviewEnabled()\n        ? findUltrareviewTriggerPositions(displayedValue)\n        : [],\n    [displayedValue],\n  )\n\n  const btwTriggers = useMemo(\n    () => findBtwTriggerPositions(displayedValue),\n    [displayedValue],\n  )\n\n  const buddyTriggers = useMemo(\n    () => findBuddyTriggerPositions(displayedValue),\n    [displayedValue],\n  )\n\n  const slashCommandTriggers = useMemo(() => {\n    const positions = findSlashCommandPositions(displayedValue)\n    // Only highlight valid commands\n    return positions.filter(pos => {\n      const commandName = displayedValue.slice(pos.start + 1, pos.end) // +1 to skip \"/\"\n      return hasCommand(commandName, commands)\n    })\n  }, [displayedValue, commands])\n\n  const tokenBudgetTriggers = useMemo(\n    () =>\n      feature('TOKEN_BUDGET') ? findTokenBudgetPositions(displayedValue) : [],\n    [displayedValue],\n  )\n\n  const knownChannelsVersion = useSyncExternalStore(\n    subscribeKnownChannels,\n    getKnownChannelsVersion,\n  )\n  const slackChannelTriggers = useMemo(\n    () =>\n      hasSlackMcpServer(store.getState().mcp.clients)\n        ? findSlackChannelPositions(displayedValue)\n        : [],\n    // eslint-disable-next-line react-hooks/exhaustive-deps -- store is a stable ref\n    [displayedValue, knownChannelsVersion],\n  )\n\n  // Find @name mentions and highlight with team member's color\n  const memberMentionHighlights = useMemo((): Array<{\n    start: number\n    end: number\n    themeColor: keyof Theme\n  }> => {\n    if (!isAgentSwarmsEnabled()) return []\n    if (!teamContext?.teammates) return []\n\n    const highlights: Array<{\n      start: number\n      end: number\n      themeColor: keyof Theme\n    }> = []\n    const members = teamContext.teammates\n    if (!members) return highlights\n\n    // Find all @name patterns in the input\n    const regex = /(^|\\s)@([\\w-]+)/g\n    const memberValues = Object.values(members)\n    let match\n    while ((match = regex.exec(displayedValue)) !== null) {\n      const leadingSpace = match[1] ?? ''\n      const nameStart = match.index + leadingSpace.length\n      const fullMatch = match[0].trimStart()\n      const name = match[2]\n\n      // Check if this name matches a team member\n      const member = memberValues.find(t => t.name === name)\n      if (member?.color) {\n        const themeColor =\n          AGENT_COLOR_TO_THEME_COLOR[member.color as AgentColorName]\n        if (themeColor) {\n          highlights.push({\n            start: nameStart,\n            end: nameStart + fullMatch.length,\n            themeColor,\n          })\n        }\n      }\n    }\n    return highlights\n  }, [displayedValue, teamContext])\n\n  const imageRefPositions = useMemo(\n    () =>\n      parseReferences(displayedValue)\n        .filter(r => r.match.startsWith('[Image'))\n        .map(r => ({ start: r.index, end: r.index + r.match.length })),\n    [displayedValue],\n  )\n\n  // chip.start is the \"selected\" state: the inverted chip IS the cursor.\n  // chip.end stays a normal position so you can park the cursor right after\n  // `]` like any other character.\n  const cursorAtImageChip = imageRefPositions.some(\n    r => r.start === cursorOffset,\n  )\n\n  // up/down movement or a fullscreen click can land the cursor strictly\n  // inside a chip; snap to the nearer boundary so it's never editable\n  // char-by-char.\n  useEffect(() => {\n    const inside = imageRefPositions.find(\n      r => cursorOffset > r.start && cursorOffset < r.end,\n    )\n    if (inside) {\n      const mid = (inside.start + inside.end) / 2\n      setCursorOffset(cursorOffset < mid ? inside.start : inside.end)\n    }\n  }, [cursorOffset, imageRefPositions, setCursorOffset])\n\n  const combinedHighlights = useMemo((): TextHighlight[] => {\n    const highlights: TextHighlight[] = []\n\n    // Invert the [Image #N] chip when the cursor is at chip.start (the\n    // \"selected\" state) so backspace-to-delete is visually obvious.\n    for (const ref of imageRefPositions) {\n      if (cursorOffset === ref.start) {\n        highlights.push({\n          start: ref.start,\n          end: ref.end,\n          color: undefined,\n          inverse: true,\n          priority: 8,\n        })\n      }\n    }\n\n    if (isSearchingHistory && historyMatch && !historyFailedMatch) {\n      highlights.push({\n        start: cursorOffset,\n        end: cursorOffset + historyQuery.length,\n        color: 'warning',\n        priority: 20,\n      })\n    }\n\n    // Add \"btw\" highlighting (solid yellow)\n    for (const trigger of btwTriggers) {\n      highlights.push({\n        start: trigger.start,\n        end: trigger.end,\n        color: 'warning',\n        priority: 15,\n      })\n    }\n\n    // Add /command highlighting (blue)\n    for (const trigger of slashCommandTriggers) {\n      highlights.push({\n        start: trigger.start,\n        end: trigger.end,\n        color: 'suggestion',\n        priority: 5,\n      })\n    }\n\n    // Add token budget highlighting (blue)\n    for (const trigger of tokenBudgetTriggers) {\n      highlights.push({\n        start: trigger.start,\n        end: trigger.end,\n        color: 'suggestion',\n        priority: 5,\n      })\n    }\n\n    for (const trigger of slackChannelTriggers) {\n      highlights.push({\n        start: trigger.start,\n        end: trigger.end,\n        color: 'suggestion',\n        priority: 5,\n      })\n    }\n\n    // Add @name highlighting with team member's color\n    for (const mention of memberMentionHighlights) {\n      highlights.push({\n        start: mention.start,\n        end: mention.end,\n        color: mention.themeColor,\n        priority: 5,\n      })\n    }\n\n    // Dim interim voice dictation text\n    if (voiceInterimRange) {\n      highlights.push({\n        start: voiceInterimRange.start,\n        end: voiceInterimRange.end,\n        color: undefined,\n        dimColor: true,\n        priority: 1,\n      })\n    }\n\n    // Rainbow highlighting for ultrathink keyword (per-character cycling colors)\n    if (isUltrathinkEnabled()) {\n      for (const trigger of thinkTriggers) {\n        for (let i = trigger.start; i < trigger.end; i++) {\n          highlights.push({\n            start: i,\n            end: i + 1,\n            color: getRainbowColor(i - trigger.start),\n            shimmerColor: getRainbowColor(i - trigger.start, true),\n            priority: 10,\n          })\n        }\n      }\n    }\n\n    // Same rainbow treatment for the ultraplan keyword\n    if (feature('ULTRAPLAN')) {\n      for (const trigger of ultraplanTriggers) {\n        for (let i = trigger.start; i < trigger.end; i++) {\n          highlights.push({\n            start: i,\n            end: i + 1,\n            color: getRainbowColor(i - trigger.start),\n            shimmerColor: getRainbowColor(i - trigger.start, true),\n            priority: 10,\n          })\n        }\n      }\n    }\n\n    // Same rainbow treatment for the ultrareview keyword\n    for (const trigger of ultrareviewTriggers) {\n      for (let i = trigger.start; i < trigger.end; i++) {\n        highlights.push({\n          start: i,\n          end: i + 1,\n          color: getRainbowColor(i - trigger.start),\n          shimmerColor: getRainbowColor(i - trigger.start, true),\n          priority: 10,\n        })\n      }\n    }\n\n    // Rainbow for /buddy\n    for (const trigger of buddyTriggers) {\n      for (let i = trigger.start; i < trigger.end; i++) {\n        highlights.push({\n          start: i,\n          end: i + 1,\n          color: getRainbowColor(i - trigger.start),\n          shimmerColor: getRainbowColor(i - trigger.start, true),\n          priority: 10,\n        })\n      }\n    }\n\n    return highlights\n  }, [\n    isSearchingHistory,\n    historyQuery,\n    historyMatch,\n    historyFailedMatch,\n    cursorOffset,\n    btwTriggers,\n    imageRefPositions,\n    memberMentionHighlights,\n    slashCommandTriggers,\n    tokenBudgetTriggers,\n    slackChannelTriggers,\n    displayedValue,\n    voiceInterimRange,\n    thinkTriggers,\n    ultraplanTriggers,\n    ultrareviewTriggers,\n    buddyTriggers,\n  ])\n\n  const { addNotification, removeNotification } = useNotifications()\n\n  // Show ultrathink notification\n  useEffect(() => {\n    if (thinkTriggers.length && isUltrathinkEnabled()) {\n      addNotification({\n        key: 'ultrathink-active',\n        text: 'Effort set to high for this turn',\n        priority: 'immediate',\n        timeoutMs: 5000,\n      })\n    } else {\n      removeNotification('ultrathink-active')\n    }\n  }, [addNotification, removeNotification, thinkTriggers.length])\n\n  useEffect(() => {\n    if (feature('ULTRAPLAN') && ultraplanTriggers.length) {\n      addNotification({\n        key: 'ultraplan-active',\n        text: 'This prompt will launch an ultraplan session in Claude Code on the web',\n        priority: 'immediate',\n        timeoutMs: 5000,\n      })\n    } else {\n      removeNotification('ultraplan-active')\n    }\n  }, [addNotification, removeNotification, ultraplanTriggers.length])\n\n  useEffect(() => {\n    if (isUltrareviewEnabled() && ultrareviewTriggers.length) {\n      addNotification({\n        key: 'ultrareview-active',\n        text: 'Run /ultrareview after Claude finishes to review these changes in the cloud',\n        priority: 'immediate',\n        timeoutMs: 5000,\n      })\n    }\n  }, [addNotification, ultrareviewTriggers.length])\n\n  // Track input length for stash hint\n  const prevInputLengthRef = useRef(input.length)\n  const peakInputLengthRef = useRef(input.length)\n\n  // Dismiss stash hint when user makes any input change\n  const dismissStashHint = useCallback(() => {\n    removeNotification('stash-hint')\n  }, [removeNotification])\n\n  // Show stash hint when user gradually clears substantial input\n  useEffect(() => {\n    const prevLength = prevInputLengthRef.current\n    const peakLength = peakInputLengthRef.current\n    const currentLength = input.length\n    prevInputLengthRef.current = currentLength\n\n    // Update peak when input grows\n    if (currentLength > peakLength) {\n      peakInputLengthRef.current = currentLength\n      return\n    }\n\n    // Reset state when input is empty\n    if (currentLength === 0) {\n      peakInputLengthRef.current = 0\n      return\n    }\n\n    // Detect gradual clear: peak was high, current is low, but this wasn't a single big jump\n    // (rapid clears like esc-esc go from 20+ to 0 in one step)\n    const clearedSubstantialInput = peakLength >= 20 && currentLength <= 5\n    const wasRapidClear = prevLength >= 20 && currentLength <= 5\n\n    if (clearedSubstantialInput && !wasRapidClear) {\n      const config = getGlobalConfig()\n      if (!config.hasUsedStash) {\n        addNotification({\n          key: 'stash-hint',\n          jsx: (\n            <Text dimColor>\n              Tip:{' '}\n              <ConfigurableShortcutHint\n                action=\"chat:stash\"\n                context=\"Chat\"\n                fallback=\"ctrl+s\"\n                description=\"stash\"\n              />\n            </Text>\n          ),\n          priority: 'immediate',\n          timeoutMs: FOOTER_TEMPORARY_STATUS_TIMEOUT,\n        })\n      }\n      peakInputLengthRef.current = currentLength\n    }\n  }, [input.length, addNotification])\n\n  // Initialize input buffer for undo functionality\n  const { pushToBuffer, undo, canUndo, clearBuffer } = useInputBuffer({\n    maxBufferSize: 50,\n    debounceMs: 1000,\n  })\n\n  useMaybeTruncateInput({\n    input,\n    pastedContents,\n    onInputChange: trackAndSetInput,\n    setCursorOffset,\n    setPastedContents,\n  })\n\n  const defaultPlaceholder = usePromptInputPlaceholder({\n    input,\n    submitCount,\n    viewingAgentName,\n  })\n\n  const onChange = useCallback(\n    (value: string) => {\n      if (value === '?') {\n        logEvent('tengu_help_toggled', {})\n        setHelpOpen(v => !v)\n        return\n      }\n      setHelpOpen(false)\n\n      // Dismiss stash hint when user makes any input change\n      dismissStashHint()\n\n      // Cancel any pending prompt suggestion and speculation when user types\n      abortPromptSuggestion()\n      abortSpeculation(setAppState)\n\n      // Check if this is a single character insertion at the start\n      const isSingleCharInsertion = value.length === input.length + 1\n      const insertedAtStart = cursorOffset === 0\n      const mode = getModeFromInput(value)\n\n      if (insertedAtStart && mode !== 'prompt') {\n        if (isSingleCharInsertion) {\n          onModeChange(mode)\n          return\n        }\n        // Multi-char insertion into empty input (e.g. tab-accepting \"! gcloud auth login\")\n        if (input.length === 0) {\n          onModeChange(mode)\n          const valueWithoutMode = getValueFromInput(value).replaceAll(\n            '\\t',\n            '    ',\n          )\n          pushToBuffer(input, cursorOffset, pastedContents)\n          trackAndSetInput(valueWithoutMode)\n          setCursorOffset(valueWithoutMode.length)\n          return\n        }\n      }\n\n      const processedValue = value.replaceAll('\\t', '    ')\n\n      // Push current state to buffer before making changes\n      if (input !== processedValue) {\n        pushToBuffer(input, cursorOffset, pastedContents)\n      }\n\n      // Deselect footer items when user types\n      setAppState(prev =>\n        prev.footerSelection === null\n          ? prev\n          : { ...prev, footerSelection: null },\n      )\n\n      trackAndSetInput(processedValue)\n    },\n    [\n      trackAndSetInput,\n      onModeChange,\n      input,\n      cursorOffset,\n      pushToBuffer,\n      pastedContents,\n      dismissStashHint,\n      setAppState,\n    ],\n  )\n\n  const {\n    resetHistory,\n    onHistoryUp,\n    onHistoryDown,\n    dismissSearchHint,\n    historyIndex,\n  } = useArrowKeyHistory(\n    (\n      value: string,\n      historyMode: HistoryMode,\n      pastedContents: Record<number, PastedContent>,\n    ) => {\n      onChange(value)\n      onModeChange(historyMode)\n      setPastedContents(pastedContents)\n    },\n    input,\n    pastedContents,\n    setCursorOffset,\n    mode,\n  )\n\n  // Dismiss search hint when user starts searching\n  useEffect(() => {\n    if (isSearchingHistory) {\n      dismissSearchHint()\n    }\n  }, [isSearchingHistory, dismissSearchHint])\n\n  // Only use history navigation when there are 0 or 1 slash command suggestions.\n  // Footer nav is NOT here — when a pill is selected, TextInput focus=false so\n  // these never fire. The Footer keybinding context handles ↑/↓ instead.\n  function handleHistoryUp() {\n    if (suggestions.length > 1) {\n      return\n    }\n\n    // Only navigate history when cursor is on the first line.\n    // In multiline inputs, up arrow should move the cursor (handled by TextInput)\n    // and only trigger history when at the top of the input.\n    if (!isCursorOnFirstLine) {\n      return\n    }\n\n    // If there's an editable queued command, move it to the input for editing when UP is pressed\n    const hasEditableCommand = queuedCommands.some(isQueuedCommandEditable)\n    if (hasEditableCommand) {\n      void popAllCommandsFromQueue()\n      return\n    }\n\n    onHistoryUp()\n  }\n\n  function handleHistoryDown() {\n    if (suggestions.length > 1) {\n      return\n    }\n\n    // Only navigate history/footer when cursor is on the last line.\n    // In multiline inputs, down arrow should move the cursor (handled by TextInput)\n    // and only trigger navigation when at the bottom of the input.\n    if (!isCursorOnLastLine) {\n      return\n    }\n\n    // At bottom of history → enter footer at first visible pill\n    if (onHistoryDown() && footerItems.length > 0) {\n      const first = footerItems[0]!\n      selectFooterItem(first)\n      if (first === 'tasks' && !getGlobalConfig().hasSeenTasksHint) {\n        saveGlobalConfig(c =>\n          c.hasSeenTasksHint ? c : { ...c, hasSeenTasksHint: true },\n        )\n      }\n    }\n  }\n\n  // Create a suggestions state directly - we'll sync it with useTypeahead later\n  const [suggestionsState, setSuggestionsStateRaw] = useState<{\n    suggestions: SuggestionItem[]\n    selectedSuggestion: number\n    commandArgumentHint?: string\n  }>({\n    suggestions: [],\n    selectedSuggestion: -1,\n    commandArgumentHint: undefined,\n  })\n\n  // Setter for suggestions state\n  const setSuggestionsState = useCallback(\n    (\n      updater:\n        | typeof suggestionsState\n        | ((prev: typeof suggestionsState) => typeof suggestionsState),\n    ) => {\n      setSuggestionsStateRaw(prev =>\n        typeof updater === 'function' ? updater(prev) : updater,\n      )\n    },\n    [],\n  )\n\n  const onSubmit = useCallback(\n    async (inputParam: string, isSubmittingSlashCommand = false) => {\n      inputParam = inputParam.trimEnd()\n\n      // Don't submit if a footer indicator is being opened. Read fresh from\n      // store — footer:openSelected calls selectFooterItem(null) then onSubmit\n      // in the same tick, and the closure value hasn't updated yet. Apply the\n      // same \"still visible?\" derivation as footerItemSelected so a stale\n      // selection (pill disappeared) doesn't swallow Enter.\n      const state = store.getState()\n      if (\n        state.footerSelection &&\n        footerItems.includes(state.footerSelection)\n      ) {\n        return\n      }\n\n      // Enter in selection modes confirms selection (useBackgroundTaskNavigation).\n      // BaseTextInput's useInput registers before that hook (child effects fire first),\n      // so without this guard Enter would double-fire and auto-submit the suggestion.\n      if (state.viewSelectionMode === 'selecting-agent') {\n        return\n      }\n\n      // Check for images early - we need this for suggestion logic below\n      const hasImages = Object.values(pastedContents).some(\n        c => c.type === 'image',\n      )\n\n      // If input is empty OR matches the suggestion, submit it\n      // But if there are images attached, don't auto-accept the suggestion -\n      // the user wants to submit just the image(s).\n      // Only in leader view — promptSuggestion is leader-context, not teammate.\n      const suggestionText = promptSuggestionState.text\n      const inputMatchesSuggestion =\n        inputParam.trim() === '' || inputParam === suggestionText\n      if (\n        inputMatchesSuggestion &&\n        suggestionText &&\n        !hasImages &&\n        !state.viewingAgentTaskId\n      ) {\n        // If speculation is active, inject messages immediately as they stream\n        if (speculation.status === 'active') {\n          markAccepted()\n          // skipReset: resetSuggestion would abort the speculation before we accept it\n          logOutcomeAtSubmission(suggestionText, { skipReset: true })\n\n          void onSubmitProp(\n            suggestionText,\n            {\n              setCursorOffset,\n              clearBuffer,\n              resetHistory,\n            },\n            {\n              state: speculation,\n              speculationSessionTimeSavedMs: speculationSessionTimeSavedMs,\n              setAppState,\n            },\n          )\n          return // Skip normal query - speculation handled it\n        }\n\n        // Regular suggestion acceptance (requires shownAt > 0)\n        if (promptSuggestionState.shownAt > 0) {\n          markAccepted()\n          inputParam = suggestionText\n        }\n      }\n\n      // Handle @name direct message\n      if (isAgentSwarmsEnabled()) {\n        const directMessage = parseDirectMemberMessage(inputParam)\n        if (directMessage) {\n          const result = await sendDirectMemberMessage(\n            directMessage.recipientName,\n            directMessage.message,\n            teamContext,\n            writeToMailbox,\n          )\n\n          if (result.success) {\n            addNotification({\n              key: 'direct-message-sent',\n              text: `Sent to @${result.recipientName}`,\n              priority: 'immediate',\n              timeoutMs: 3000,\n            })\n            trackAndSetInput('')\n            setCursorOffset(0)\n            clearBuffer()\n            resetHistory()\n            return\n          } else if (result.error === 'no_team_context') {\n            // No team context - fall through to normal prompt submission\n          } else {\n            // Unknown recipient - fall through to normal prompt submission\n            // This allows e.g. \"@utils explain this code\" to be sent as a prompt\n          }\n        }\n      }\n\n      // Allow submission if there are images attached, even without text\n      if (inputParam.trim() === '' && !hasImages) {\n        return\n      }\n\n      // PromptInput UX: Check if suggestions dropdown is showing\n      // For directory suggestions, allow submission (Tab is used for completion)\n      const hasDirectorySuggestions =\n        suggestionsState.suggestions.length > 0 &&\n        suggestionsState.suggestions.every(s => s.description === 'directory')\n\n      if (\n        suggestionsState.suggestions.length > 0 &&\n        !isSubmittingSlashCommand &&\n        !hasDirectorySuggestions\n      ) {\n        logForDebugging(\n          `[onSubmit] early return: suggestions showing (count=${suggestionsState.suggestions.length})`,\n        )\n        return // Don't submit, user needs to clear suggestions first\n      }\n\n      // Log suggestion outcome if one exists\n      if (promptSuggestionState.text && promptSuggestionState.shownAt > 0) {\n        logOutcomeAtSubmission(inputParam)\n      }\n\n      // Clear stash hint notification on submit\n      removeNotification('stash-hint')\n\n      // Route input to viewed agent (in-process teammate or named local_agent).\n      const activeAgent = getActiveAgentForInput(store.getState())\n      if (activeAgent.type !== 'leader' && onAgentSubmit) {\n        logEvent('tengu_transcript_input_to_teammate', {})\n        await onAgentSubmit(inputParam, activeAgent.task, {\n          setCursorOffset,\n          clearBuffer,\n          resetHistory,\n        })\n        return\n      }\n\n      // Normal leader submission\n      await onSubmitProp(inputParam, {\n        setCursorOffset,\n        clearBuffer,\n        resetHistory,\n      })\n    },\n    [\n      promptSuggestionState,\n      speculation,\n      speculationSessionTimeSavedMs,\n      teamContext,\n      store,\n      footerItems,\n      suggestionsState.suggestions,\n      onSubmitProp,\n      onAgentSubmit,\n      clearBuffer,\n      resetHistory,\n      logOutcomeAtSubmission,\n      setAppState,\n      markAccepted,\n      pastedContents,\n      removeNotification,\n    ],\n  )\n\n  const {\n    suggestions,\n    selectedSuggestion,\n    commandArgumentHint,\n    inlineGhostText,\n    maxColumnWidth,\n  } = useTypeahead({\n    commands,\n    onInputChange: trackAndSetInput,\n    onSubmit,\n    setCursorOffset,\n    input,\n    cursorOffset,\n    mode,\n    agents,\n    setSuggestionsState,\n    suggestionsState,\n    suppressSuggestions: isSearchingHistory || historyIndex > 0,\n    markAccepted,\n    onModeChange,\n  })\n\n  // Track if prompt suggestion should be shown (computed later with terminal width).\n  // Hidden in teammate view — suggestion is leader-context only.\n  const showPromptSuggestion =\n    mode === 'prompt' &&\n    suggestions.length === 0 &&\n    promptSuggestion &&\n    !viewingAgentTaskId\n  if (showPromptSuggestion) {\n    markShown()\n  }\n\n  // If suggestion was generated but can't be shown due to timing, log suppression.\n  // Exclude teammate view: markShown() is gated above, so shownAt stays 0 there —\n  // but that's not a timing failure, the suggestion is valid when returning to leader.\n  if (\n    promptSuggestionState.text &&\n    !promptSuggestion &&\n    promptSuggestionState.shownAt === 0 &&\n    !viewingAgentTaskId\n  ) {\n    logSuggestionSuppressed('timing', promptSuggestionState.text)\n    setAppState(prev => ({\n      ...prev,\n      promptSuggestion: {\n        text: null,\n        promptId: null,\n        shownAt: 0,\n        acceptedAt: 0,\n        generationRequestId: null,\n      },\n    }))\n  }\n\n  function onImagePaste(\n    image: string,\n    mediaType?: string,\n    filename?: string,\n    dimensions?: ImageDimensions,\n    sourcePath?: string,\n  ) {\n    logEvent('tengu_paste_image', {})\n    onModeChange('prompt')\n\n    const pasteId = nextPasteIdRef.current++\n\n    const newContent: PastedContent = {\n      id: pasteId,\n      type: 'image',\n      content: image,\n      mediaType: mediaType || 'image/png', // default to PNG if not provided\n      filename: filename || 'Pasted image',\n      dimensions,\n      sourcePath,\n    }\n\n    // Cache path immediately (fast) so links work on render\n    cacheImagePath(newContent)\n\n    // Store image to disk in background\n    void storeImage(newContent)\n\n    // Update UI\n    setPastedContents(prev => ({ ...prev, [pasteId]: newContent }))\n    // Multi-image paste calls onImagePaste in a loop. If the ref is already\n    // armed, the previous pill's lazy space fires now (before this pill)\n    // rather than being lost.\n    const prefix = pendingSpaceAfterPillRef.current ? ' ' : ''\n    insertTextAtCursor(prefix + formatImageRef(pasteId))\n    pendingSpaceAfterPillRef.current = true\n  }\n\n  // Prune images whose [Image #N] placeholder is no longer in the input text.\n  // Covers pill backspace, Ctrl+U, char-by-char deletion — any edit that drops\n  // the ref. onImagePaste batches setPastedContents + insertTextAtCursor in the\n  // same event, so this effect sees the placeholder already present.\n  useEffect(() => {\n    const referencedIds = new Set(parseReferences(input).map(r => r.id))\n    setPastedContents(prev => {\n      const orphaned = Object.values(prev).filter(\n        c => c.type === 'image' && !referencedIds.has(c.id),\n      )\n      if (orphaned.length === 0) return prev\n      const next = { ...prev }\n      for (const img of orphaned) delete next[img.id]\n      return next\n    })\n  }, [input, setPastedContents])\n\n  function onTextPaste(rawText: string) {\n    pendingSpaceAfterPillRef.current = false\n    // Clean up pasted text - strip ANSI escape codes and normalize line endings and tabs\n    let text = stripAnsi(rawText).replace(/\\r/g, '\\n').replaceAll('\\t', '    ')\n\n    // Match typed/auto-suggest: `!cmd` pasted into empty input enters bash mode.\n    if (input.length === 0) {\n      const pastedMode = getModeFromInput(text)\n      if (pastedMode !== 'prompt') {\n        onModeChange(pastedMode)\n        text = getValueFromInput(text)\n      }\n    }\n\n    const numLines = getPastedTextRefNumLines(text)\n    // Limit the number of lines to show in the input\n    // If the overall layout is too high then Ink will repaint\n    // the entire terminal.\n    // The actual required height is dependent on the content, this\n    // is just an estimate.\n    const maxLines = Math.min(rows - 10, 2)\n\n    // Use special handling for long pasted text (>PASTE_THRESHOLD chars)\n    // or if it exceeds the number of lines we want to show\n    if (text.length > PASTE_THRESHOLD || numLines > maxLines) {\n      const pasteId = nextPasteIdRef.current++\n\n      const newContent: PastedContent = {\n        id: pasteId,\n        type: 'text',\n        content: text,\n      }\n\n      setPastedContents(prev => ({ ...prev, [pasteId]: newContent }))\n\n      insertTextAtCursor(formatPastedTextRef(pasteId, numLines))\n    } else {\n      // For shorter pastes, just insert the text normally\n      insertTextAtCursor(text)\n    }\n  }\n\n  const lazySpaceInputFilter = useCallback(\n    (input: string, key: Key): string => {\n      if (!pendingSpaceAfterPillRef.current) return input\n      pendingSpaceAfterPillRef.current = false\n      if (isNonSpacePrintable(input, key)) return ' ' + input\n      return input\n    },\n    [],\n  )\n\n  function insertTextAtCursor(text: string) {\n    // Push current state to buffer before inserting\n    pushToBuffer(input, cursorOffset, pastedContents)\n\n    const newInput =\n      input.slice(0, cursorOffset) + text + input.slice(cursorOffset)\n    trackAndSetInput(newInput)\n    setCursorOffset(cursorOffset + text.length)\n  }\n\n  const doublePressEscFromEmpty = useDoublePress(\n    () => {},\n    () => onShowMessageSelector(),\n  )\n\n  // Function to get the queued command for editing. Returns true if commands were popped.\n  const popAllCommandsFromQueue = useCallback((): boolean => {\n    const result = popAllEditable(input, cursorOffset)\n    if (!result) {\n      return false\n    }\n\n    trackAndSetInput(result.text)\n    onModeChange('prompt') // Always prompt mode for queued commands\n    setCursorOffset(result.cursorOffset)\n\n    // Restore images from queued commands to pastedContents\n    if (result.images.length > 0) {\n      setPastedContents(prev => {\n        const newContents = { ...prev }\n        for (const image of result.images) {\n          newContents[image.id] = image\n        }\n        return newContents\n      })\n    }\n\n    return true\n  }, [trackAndSetInput, onModeChange, input, cursorOffset, setPastedContents])\n\n  // Insert the at-mentioned reference (the file and, optionally, a line range) when\n  // we receive an at-mentioned notification the IDE.\n  const onIdeAtMentioned = function (atMentioned: IDEAtMentioned) {\n    logEvent('tengu_ext_at_mentioned', {})\n    let atMentionedText: string\n    const relativePath = path.relative(getCwd(), atMentioned.filePath)\n    if (atMentioned.lineStart && atMentioned.lineEnd) {\n      atMentionedText =\n        atMentioned.lineStart === atMentioned.lineEnd\n          ? `@${relativePath}#L${atMentioned.lineStart} `\n          : `@${relativePath}#L${atMentioned.lineStart}-${atMentioned.lineEnd} `\n    } else {\n      atMentionedText = `@${relativePath} `\n    }\n    const cursorChar = input[cursorOffset - 1] ?? ' '\n    if (!/\\s/.test(cursorChar)) {\n      atMentionedText = ` ${atMentionedText}`\n    }\n    insertTextAtCursor(atMentionedText)\n  }\n  useIdeAtMentioned(mcpClients, onIdeAtMentioned)\n\n  // Handler for chat:undo - undo last edit\n  const handleUndo = useCallback(() => {\n    if (canUndo) {\n      const previousState = undo()\n      if (previousState) {\n        trackAndSetInput(previousState.text)\n        setCursorOffset(previousState.cursorOffset)\n        setPastedContents(previousState.pastedContents)\n      }\n    }\n  }, [canUndo, undo, trackAndSetInput, setPastedContents])\n\n  // Handler for chat:newline - insert a newline at the cursor position\n  const handleNewline = useCallback(() => {\n    pushToBuffer(input, cursorOffset, pastedContents)\n    const newInput =\n      input.slice(0, cursorOffset) + '\\n' + input.slice(cursorOffset)\n    trackAndSetInput(newInput)\n    setCursorOffset(cursorOffset + 1)\n  }, [\n    input,\n    cursorOffset,\n    trackAndSetInput,\n    setCursorOffset,\n    pushToBuffer,\n    pastedContents,\n  ])\n\n  // Handler for chat:externalEditor - edit in $EDITOR\n  const handleExternalEditor = useCallback(async () => {\n    logEvent('tengu_external_editor_used', {})\n    setIsExternalEditorActive(true)\n\n    try {\n      // Pass pastedContents to expand collapsed text references\n      const result = await editPromptInEditor(input, pastedContents)\n\n      if (result.error) {\n        addNotification({\n          key: 'external-editor-error',\n          text: result.error,\n          color: 'warning',\n          priority: 'high',\n        })\n      }\n\n      if (result.content !== null && result.content !== input) {\n        // Push current state to buffer before making changes\n        pushToBuffer(input, cursorOffset, pastedContents)\n\n        trackAndSetInput(result.content)\n        setCursorOffset(result.content.length)\n      }\n    } catch (err) {\n      if (err instanceof Error) {\n        logError(err)\n      }\n      addNotification({\n        key: 'external-editor-error',\n        text: `External editor failed: ${errorMessage(err)}`,\n        color: 'warning',\n        priority: 'high',\n      })\n    } finally {\n      setIsExternalEditorActive(false)\n    }\n  }, [\n    input,\n    cursorOffset,\n    pastedContents,\n    pushToBuffer,\n    trackAndSetInput,\n    addNotification,\n  ])\n\n  // Handler for chat:stash - stash/unstash prompt\n  const handleStash = useCallback(() => {\n    if (input.trim() === '' && stashedPrompt !== undefined) {\n      // Pop stash when input is empty\n      trackAndSetInput(stashedPrompt.text)\n      setCursorOffset(stashedPrompt.cursorOffset)\n      setPastedContents(stashedPrompt.pastedContents)\n      setStashedPrompt(undefined)\n    } else if (input.trim() !== '') {\n      // Push to stash (save text, cursor position, and pasted contents)\n      setStashedPrompt({ text: input, cursorOffset, pastedContents })\n      trackAndSetInput('')\n      setCursorOffset(0)\n      setPastedContents({})\n      // Track usage for /discover and stop showing hint\n      saveGlobalConfig(c => {\n        if (c.hasUsedStash) return c\n        return { ...c, hasUsedStash: true }\n      })\n    }\n  }, [\n    input,\n    cursorOffset,\n    stashedPrompt,\n    trackAndSetInput,\n    setStashedPrompt,\n    pastedContents,\n    setPastedContents,\n  ])\n\n  // Handler for chat:modelPicker - toggle model picker\n  const handleModelPicker = useCallback(() => {\n    setShowModelPicker(prev => !prev)\n    if (helpOpen) {\n      setHelpOpen(false)\n    }\n  }, [helpOpen])\n\n  // Handler for chat:fastMode - toggle fast mode picker\n  const handleFastModePicker = useCallback(() => {\n    setShowFastModePicker(prev => !prev)\n    if (helpOpen) {\n      setHelpOpen(false)\n    }\n  }, [helpOpen])\n\n  // Handler for chat:thinkingToggle - toggle thinking mode\n  const handleThinkingToggle = useCallback(() => {\n    setShowThinkingToggle(prev => !prev)\n    if (helpOpen) {\n      setHelpOpen(false)\n    }\n  }, [helpOpen])\n\n  // Handler for chat:cycleMode - cycle through permission modes\n  const handleCycleMode = useCallback(() => {\n    // When viewing a teammate, cycle their mode instead of the leader's\n    if (isAgentSwarmsEnabled() && viewedTeammate && viewingAgentTaskId) {\n      const teammateContext: ToolPermissionContext = {\n        ...toolPermissionContext,\n        mode: viewedTeammate.permissionMode,\n      }\n      // Pass undefined for teamContext (unused but kept for API compatibility)\n      const nextMode = getNextPermissionMode(teammateContext, undefined)\n\n      logEvent('tengu_mode_cycle', {\n        to: nextMode as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      const teammateTaskId = viewingAgentTaskId\n      setAppState(prev => {\n        const task = prev.tasks[teammateTaskId]\n        if (!task || task.type !== 'in_process_teammate') {\n          return prev\n        }\n        if (task.permissionMode === nextMode) {\n          return prev\n        }\n        return {\n          ...prev,\n          tasks: {\n            ...prev.tasks,\n            [teammateTaskId]: {\n              ...task,\n              permissionMode: nextMode,\n            },\n          },\n        }\n      })\n\n      if (helpOpen) {\n        setHelpOpen(false)\n      }\n      return\n    }\n\n    // Compute the next mode without triggering side effects first\n    logForDebugging(\n      `[auto-mode] handleCycleMode: currentMode=${toolPermissionContext.mode} isAutoModeAvailable=${toolPermissionContext.isAutoModeAvailable} showAutoModeOptIn=${showAutoModeOptIn} timeoutPending=${!!autoModeOptInTimeoutRef.current}`,\n    )\n    const nextMode = getNextPermissionMode(toolPermissionContext, teamContext)\n\n    // Check if user is entering auto mode for the first time. Gated on the\n    // persistent settings flag (hasAutoModeOptIn) rather than the broader\n    // hasAutoModeOptInAnySource so that --enable-auto-mode users still see\n    // the warning dialog once — the CLI flag should grant carousel access,\n    // not bypass the safety text.\n    let isEnteringAutoModeFirstTime = false\n    if (feature('TRANSCRIPT_CLASSIFIER')) {\n      isEnteringAutoModeFirstTime =\n        nextMode === 'auto' &&\n        toolPermissionContext.mode !== 'auto' &&\n        !hasAutoModeOptIn() &&\n        !viewingAgentTaskId // Only show for primary agent, not subagents\n    }\n\n    if (feature('TRANSCRIPT_CLASSIFIER')) {\n      if (isEnteringAutoModeFirstTime) {\n        // Store previous mode so we can revert if user declines\n        setPreviousModeBeforeAuto(toolPermissionContext.mode)\n\n        // Only update the UI mode label — do NOT call transitionPermissionMode\n        // or cyclePermissionMode yet; we haven't confirmed with the user.\n        setAppState(prev => ({\n          ...prev,\n          toolPermissionContext: {\n            ...prev.toolPermissionContext,\n            mode: 'auto',\n          },\n        }))\n        setToolPermissionContext({\n          ...toolPermissionContext,\n          mode: 'auto',\n        })\n\n        // Show opt-in dialog after 400ms debounce\n        if (autoModeOptInTimeoutRef.current) {\n          clearTimeout(autoModeOptInTimeoutRef.current)\n        }\n        autoModeOptInTimeoutRef.current = setTimeout(\n          (setShowAutoModeOptIn, autoModeOptInTimeoutRef) => {\n            setShowAutoModeOptIn(true)\n            autoModeOptInTimeoutRef.current = null\n          },\n          400,\n          setShowAutoModeOptIn,\n          autoModeOptInTimeoutRef,\n        )\n\n        if (helpOpen) {\n          setHelpOpen(false)\n        }\n        return\n      }\n    }\n\n    // Dismiss auto mode opt-in dialog if showing or pending (user is cycling away).\n    // Do NOT revert to previousModeBeforeAuto here — shift+tab means \"advance the\n    // carousel\", not \"decline\". Reverting causes a ping-pong loop: auto reverts to\n    // the prior mode, whose next mode is auto again, forever.\n    // The dialog's own decline button (handleAutoModeOptInDecline) handles revert.\n    if (feature('TRANSCRIPT_CLASSIFIER')) {\n      if (showAutoModeOptIn || autoModeOptInTimeoutRef.current) {\n        if (showAutoModeOptIn) {\n          logEvent('tengu_auto_mode_opt_in_dialog_decline', {})\n        }\n        setShowAutoModeOptIn(false)\n        if (autoModeOptInTimeoutRef.current) {\n          clearTimeout(autoModeOptInTimeoutRef.current)\n          autoModeOptInTimeoutRef.current = null\n        }\n        setPreviousModeBeforeAuto(null)\n        // Fall through — mode is 'auto', cyclePermissionMode below goes to 'default'.\n      }\n    }\n\n    // Now that we know this is NOT the first-time auto mode path,\n    // call cyclePermissionMode to apply side effects (e.g. strip\n    // dangerous permissions, activate classifier)\n    const { context: preparedContext } = cyclePermissionMode(\n      toolPermissionContext,\n      teamContext,\n    )\n\n    logEvent('tengu_mode_cycle', {\n      to: nextMode as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n\n    // Track when user enters plan mode\n    if (nextMode === 'plan') {\n      saveGlobalConfig(current => ({\n        ...current,\n        lastPlanModeUse: Date.now(),\n      }))\n    }\n\n    // Set the mode via setAppState directly because setToolPermissionContext\n    // intentionally preserves the existing mode (to prevent coordinator mode\n    // corruption from workers). Then call setToolPermissionContext to trigger\n    // recheck of queued permission prompts.\n    setAppState(prev => ({\n      ...prev,\n      toolPermissionContext: {\n        ...preparedContext,\n        mode: nextMode,\n      },\n    }))\n    setToolPermissionContext({\n      ...preparedContext,\n      mode: nextMode,\n    })\n\n    // If this is a teammate, update config.json so team lead sees the change\n    syncTeammateMode(nextMode, teamContext?.teamName)\n\n    // Close help tips if they're open when mode is cycled\n    if (helpOpen) {\n      setHelpOpen(false)\n    }\n  }, [\n    toolPermissionContext,\n    teamContext,\n    viewingAgentTaskId,\n    viewedTeammate,\n    setAppState,\n    setToolPermissionContext,\n    helpOpen,\n    showAutoModeOptIn,\n  ])\n\n  // Handler for auto mode opt-in dialog acceptance\n  const handleAutoModeOptInAccept = useCallback(() => {\n    if (feature('TRANSCRIPT_CLASSIFIER')) {\n      setShowAutoModeOptIn(false)\n      setPreviousModeBeforeAuto(null)\n\n      // Now that the user accepted, apply the full transition: activate the\n      // auto mode backend (classifier, beta headers) and strip dangerous\n      // permissions (e.g. Bash(*) always-allow rules).\n      const strippedContext = transitionPermissionMode(\n        previousModeBeforeAuto ?? toolPermissionContext.mode,\n        'auto',\n        toolPermissionContext,\n      )\n      setAppState(prev => ({\n        ...prev,\n        toolPermissionContext: {\n          ...strippedContext,\n          mode: 'auto',\n        },\n      }))\n      setToolPermissionContext({\n        ...strippedContext,\n        mode: 'auto',\n      })\n\n      // Close help tips if they're open when auto mode is enabled\n      if (helpOpen) {\n        setHelpOpen(false)\n      }\n    }\n  }, [\n    helpOpen,\n    setHelpOpen,\n    previousModeBeforeAuto,\n    toolPermissionContext,\n    setAppState,\n    setToolPermissionContext,\n  ])\n\n  // Handler for auto mode opt-in dialog decline\n  const handleAutoModeOptInDecline = useCallback(() => {\n    if (feature('TRANSCRIPT_CLASSIFIER')) {\n      logForDebugging(\n        `[auto-mode] handleAutoModeOptInDecline: reverting to ${previousModeBeforeAuto}, setting isAutoModeAvailable=false`,\n      )\n      setShowAutoModeOptIn(false)\n      if (autoModeOptInTimeoutRef.current) {\n        clearTimeout(autoModeOptInTimeoutRef.current)\n        autoModeOptInTimeoutRef.current = null\n      }\n\n      // Revert to previous mode and remove auto from the carousel\n      // for the rest of this session\n      if (previousModeBeforeAuto) {\n        setAutoModeActive(false)\n        setAppState(prev => ({\n          ...prev,\n          toolPermissionContext: {\n            ...prev.toolPermissionContext,\n            mode: previousModeBeforeAuto,\n            isAutoModeAvailable: false,\n          },\n        }))\n        setToolPermissionContext({\n          ...toolPermissionContext,\n          mode: previousModeBeforeAuto,\n          isAutoModeAvailable: false,\n        })\n        setPreviousModeBeforeAuto(null)\n      }\n    }\n  }, [\n    previousModeBeforeAuto,\n    toolPermissionContext,\n    setAppState,\n    setToolPermissionContext,\n  ])\n\n  // Handler for chat:imagePaste - paste image from clipboard\n  const handleImagePaste = useCallback(() => {\n    void getImageFromClipboard().then(imageData => {\n      if (imageData) {\n        onImagePaste(imageData.base64, imageData.mediaType)\n      } else {\n        const shortcutDisplay = getShortcutDisplay(\n          'chat:imagePaste',\n          'Chat',\n          'ctrl+v',\n        )\n        const message = env.isSSH()\n          ? \"No image found in clipboard. You're SSH'd; try scp?\"\n          : `No image found in clipboard. Use ${shortcutDisplay} to paste images.`\n        addNotification({\n          key: 'no-image-in-clipboard',\n          text: message,\n          priority: 'immediate',\n          timeoutMs: 1000,\n        })\n      }\n    })\n  }, [addNotification, onImagePaste])\n\n  // Register chat:submit handler directly in the handler registry (not via\n  // useKeybindings) so that only the ChordInterceptor can invoke it for chord\n  // completions (e.g., \"ctrl+e s\"). The default Enter binding for submit is\n  // handled by TextInput directly (via onSubmit prop) and useTypeahead (for\n  // autocomplete acceptance). Using useKeybindings would cause\n  // stopImmediatePropagation on Enter, blocking autocomplete from seeing the key.\n  const keybindingContext = useOptionalKeybindingContext()\n  useEffect(() => {\n    if (!keybindingContext || isModalOverlayActive) return\n    return keybindingContext.registerHandler({\n      action: 'chat:submit',\n      context: 'Chat',\n      handler: () => {\n        void onSubmit(input)\n      },\n    })\n  }, [keybindingContext, isModalOverlayActive, onSubmit, input])\n\n  // Chat context keybindings for editing shortcuts\n  // Note: history:previous/history:next are NOT handled here. They are passed as\n  // onHistoryUp/onHistoryDown props to TextInput, so that useTextInput's\n  // upOrHistoryUp/downOrHistoryDown can try cursor movement first and only\n  // fall through to history when the cursor can't move further.\n  const chatHandlers = useMemo(\n    () => ({\n      'chat:undo': handleUndo,\n      'chat:newline': handleNewline,\n      'chat:externalEditor': handleExternalEditor,\n      'chat:stash': handleStash,\n      'chat:modelPicker': handleModelPicker,\n      'chat:thinkingToggle': handleThinkingToggle,\n      'chat:cycleMode': handleCycleMode,\n      'chat:imagePaste': handleImagePaste,\n    }),\n    [\n      handleUndo,\n      handleNewline,\n      handleExternalEditor,\n      handleStash,\n      handleModelPicker,\n      handleThinkingToggle,\n      handleCycleMode,\n      handleImagePaste,\n    ],\n  )\n\n  useKeybindings(chatHandlers, {\n    context: 'Chat',\n    isActive: !isModalOverlayActive,\n  })\n\n  // Shift+↑ enters message-actions cursor. Separate isActive so ctrl+r search\n  // doesn't leave stale isSearchingHistory on cursor-exit remount.\n  useKeybinding('chat:messageActions', () => onMessageActionsEnter?.(), {\n    context: 'Chat',\n    isActive: !isModalOverlayActive && !isSearchingHistory,\n  })\n\n  // Fast mode keybinding is only active when fast mode is enabled and available\n  useKeybinding('chat:fastMode', handleFastModePicker, {\n    context: 'Chat',\n    isActive:\n      !isModalOverlayActive && isFastModeEnabled() && isFastModeAvailable(),\n  })\n\n  // Handle help:dismiss keybinding (ESC closes help menu)\n  // This is registered separately from Chat context so it has priority over\n  // CancelRequestHandler when help menu is open\n  useKeybinding(\n    'help:dismiss',\n    () => {\n      setHelpOpen(false)\n    },\n    { context: 'Help', isActive: helpOpen },\n  )\n\n  // Quick Open / Global Search. Hook calls are unconditional (Rules of Hooks);\n  // the handler body is feature()-gated so the setState calls and component\n  // references get tree-shaken in external builds.\n  const quickSearchActive = feature('QUICK_SEARCH')\n    ? !isModalOverlayActive\n    : false\n  useKeybinding(\n    'app:quickOpen',\n    () => {\n      if (feature('QUICK_SEARCH')) {\n        setShowQuickOpen(true)\n        setHelpOpen(false)\n      }\n    },\n    { context: 'Global', isActive: quickSearchActive },\n  )\n  useKeybinding(\n    'app:globalSearch',\n    () => {\n      if (feature('QUICK_SEARCH')) {\n        setShowGlobalSearch(true)\n        setHelpOpen(false)\n      }\n    },\n    { context: 'Global', isActive: quickSearchActive },\n  )\n\n  useKeybinding(\n    'history:search',\n    () => {\n      if (feature('HISTORY_PICKER')) {\n        setShowHistoryPicker(true)\n        setHelpOpen(false)\n      }\n    },\n    {\n      context: 'Global',\n      isActive: feature('HISTORY_PICKER') ? !isModalOverlayActive : false,\n    },\n  )\n\n  // Handle Ctrl+C to abort speculation when idle (not loading)\n  // CancelRequestHandler only handles Ctrl+C during active tasks\n  useKeybinding(\n    'app:interrupt',\n    () => {\n      abortSpeculation(setAppState)\n    },\n    {\n      context: 'Global',\n      isActive: !isLoading && speculation.status === 'active',\n    },\n  )\n\n  // Footer indicator navigation keybindings. ↑/↓ live here (not in\n  // handleHistoryUp/Down) because TextInput focus=false when a pill is\n  // selected — its useInput is inactive, so this is the only path.\n  useKeybindings(\n    {\n      'footer:up': () => {\n        // ↑ scrolls within the coordinator task list before leaving the pill\n        if (\n          tasksSelected &&\n          \"external\" === 'ant' &&\n          coordinatorTaskCount > 0 &&\n          coordinatorTaskIndex > minCoordinatorIndex\n        ) {\n          setCoordinatorTaskIndex(prev => prev - 1)\n          return\n        }\n        navigateFooter(-1, true)\n      },\n      'footer:down': () => {\n        // ↓ scrolls within the coordinator task list, never leaves the pill\n        if (\n          tasksSelected &&\n          \"external\" === 'ant' &&\n          coordinatorTaskCount > 0\n        ) {\n          if (coordinatorTaskIndex < coordinatorTaskCount - 1) {\n            setCoordinatorTaskIndex(prev => prev + 1)\n          }\n          return\n        }\n        if (tasksSelected && !isTeammateMode) {\n          setShowBashesDialog(true)\n          selectFooterItem(null)\n          return\n        }\n        navigateFooter(1)\n      },\n      'footer:next': () => {\n        // Teammate mode: ←/→ cycles within the team member list\n        if (tasksSelected && isTeammateMode) {\n          const totalAgents = 1 + inProcessTeammates.length\n          setTeammateFooterIndex(prev => (prev + 1) % totalAgents)\n          return\n        }\n        navigateFooter(1)\n      },\n      'footer:previous': () => {\n        if (tasksSelected && isTeammateMode) {\n          const totalAgents = 1 + inProcessTeammates.length\n          setTeammateFooterIndex(prev => (prev - 1 + totalAgents) % totalAgents)\n          return\n        }\n        navigateFooter(-1)\n      },\n      'footer:openSelected': () => {\n        if (viewSelectionMode === 'selecting-agent') {\n          return\n        }\n        switch (footerItemSelected) {\n          case 'companion':\n            if (feature('BUDDY')) {\n              selectFooterItem(null)\n              void onSubmit('/buddy')\n            }\n            break\n          case 'tasks':\n            if (isTeammateMode) {\n              // Enter switches to the selected agent's view\n              if (teammateFooterIndex === 0) {\n                exitTeammateView(setAppState)\n              } else {\n                const teammate = inProcessTeammates[teammateFooterIndex - 1]\n                if (teammate) enterTeammateView(teammate.id, setAppState)\n              }\n            } else if (coordinatorTaskIndex === 0 && coordinatorTaskCount > 0) {\n              exitTeammateView(setAppState)\n            } else {\n              const selectedTaskId =\n                getVisibleAgentTasks(tasks)[coordinatorTaskIndex - 1]?.id\n              if (selectedTaskId) {\n                enterTeammateView(selectedTaskId, setAppState)\n              } else {\n                setShowBashesDialog(true)\n                selectFooterItem(null)\n              }\n            }\n            break\n          case 'tmux':\n            if (\"external\" === 'ant') {\n              setAppState(prev =>\n                prev.tungstenPanelAutoHidden\n                  ? { ...prev, tungstenPanelAutoHidden: false }\n                  : {\n                      ...prev,\n                      tungstenPanelVisible: !(\n                        prev.tungstenPanelVisible ?? true\n                      ),\n                    },\n              )\n            }\n            break\n          case 'bagel':\n            break\n          case 'teams':\n            setShowTeamsDialog(true)\n            selectFooterItem(null)\n            break\n          case 'bridge':\n            setShowBridgeDialog(true)\n            selectFooterItem(null)\n            break\n        }\n      },\n      'footer:clearSelection': () => {\n        selectFooterItem(null)\n      },\n      'footer:close': () => {\n        if (tasksSelected && coordinatorTaskIndex >= 1) {\n          const task = getVisibleAgentTasks(tasks)[coordinatorTaskIndex - 1]\n          if (!task) return false\n          // When the selected row IS the viewed agent, 'x' types into the\n          // steering input. Any other row — dismiss it.\n          if (\n            viewSelectionMode === 'viewing-agent' &&\n            task.id === viewingAgentTaskId\n          ) {\n            onChange(\n              input.slice(0, cursorOffset) + 'x' + input.slice(cursorOffset),\n            )\n            setCursorOffset(cursorOffset + 1)\n            return\n          }\n          stopOrDismissAgent(task.id, setAppState)\n          if (task.status !== 'running') {\n            setCoordinatorTaskIndex(i => Math.max(minCoordinatorIndex, i - 1))\n          }\n          return\n        }\n        // Not handled — let 'x' fall through to type-to-exit\n        return false\n      },\n    },\n    {\n      context: 'Footer',\n      isActive: !!footerItemSelected && !isModalOverlayActive,\n    },\n  )\n\n  useInput((char, key) => {\n    // Skip all input handling when a full-screen dialog is open. These dialogs\n    // render via early return, but hooks run unconditionally — so without this\n    // guard, Escape inside a dialog leaks to the double-press message-selector.\n    if (\n      showTeamsDialog ||\n      showQuickOpen ||\n      showGlobalSearch ||\n      showHistoryPicker\n    ) {\n      return\n    }\n\n    // Detect failed Alt shortcuts on macOS (Option key produces special characters)\n    if (getPlatform() === 'macos' && isMacosOptionChar(char)) {\n      const shortcut = MACOS_OPTION_SPECIAL_CHARS[char]\n      const terminalName = getNativeCSIuTerminalDisplayName()\n      const jsx = terminalName ? (\n        <Text dimColor>\n          To enable {shortcut}, set <Text bold>Option as Meta</Text> in{' '}\n          {terminalName} preferences (⌘,)\n        </Text>\n      ) : (\n        <Text dimColor>To enable {shortcut}, run /terminal-setup</Text>\n      )\n      addNotification({\n        key: 'option-meta-hint',\n        jsx,\n        priority: 'immediate',\n        timeoutMs: 5000,\n      })\n      // Don't return - let the character be typed so user sees the issue\n    }\n\n    // Footer navigation is handled via useKeybindings above (Footer context)\n\n    // NOTE: ctrl+_, ctrl+g, ctrl+s are handled via Chat context keybindings above\n\n    // Type-to-exit footer: printable chars while a pill is selected refocus\n    // the input and type the char. Nav keys are captured by useKeybindings\n    // above, so anything reaching here is genuinely not a footer action.\n    // onChange clears footerSelection, so no explicit deselect.\n    if (\n      footerItemSelected &&\n      char &&\n      !key.ctrl &&\n      !key.meta &&\n      !key.escape &&\n      !key.return\n    ) {\n      onChange(input.slice(0, cursorOffset) + char + input.slice(cursorOffset))\n      setCursorOffset(cursorOffset + char.length)\n      return\n    }\n\n    // Exit special modes when backspace/escape/delete/ctrl+u is pressed at cursor position 0\n    if (\n      cursorOffset === 0 &&\n      (key.escape || key.backspace || key.delete || (key.ctrl && char === 'u'))\n    ) {\n      onModeChange('prompt')\n      setHelpOpen(false)\n    }\n\n    // Exit help mode when backspace is pressed and input is empty\n    if (helpOpen && input === '' && (key.backspace || key.delete)) {\n      setHelpOpen(false)\n    }\n\n    // esc is a little overloaded:\n    // - when we're loading a response, it's used to cancel the request\n    // - otherwise, it's used to show the message selector\n    // - when double pressed, it's used to clear the input\n    // - when input is empty, pop from command queue\n\n    // Handle ESC key press\n    if (key.escape) {\n      // Abort active speculation\n      if (speculation.status === 'active') {\n        abortSpeculation(setAppState)\n        return\n      }\n\n      // Dismiss side question response if visible\n      if (isSideQuestionVisible && onDismissSideQuestion) {\n        onDismissSideQuestion()\n        return\n      }\n\n      // Close help menu if open\n      if (helpOpen) {\n        setHelpOpen(false)\n        return\n      }\n\n      // Footer selection clearing is now handled via Footer context keybindings\n      // (footer:clearSelection action bound to escape)\n      // If a footer item is selected, let the Footer keybinding handle it\n      if (footerItemSelected) {\n        return\n      }\n\n      // If there's an editable queued command, move it to the input for editing when ESC is pressed\n      const hasEditableCommand = queuedCommands.some(isQueuedCommandEditable)\n      if (hasEditableCommand) {\n        void popAllCommandsFromQueue()\n        return\n      }\n\n      if (messages.length > 0 && !input && !isLoading) {\n        doublePressEscFromEmpty()\n      }\n    }\n\n    if (key.return && helpOpen) {\n      setHelpOpen(false)\n    }\n  })\n\n  const swarmBanner = useSwarmBanner()\n\n  const fastModeCooldown = isFastModeEnabled() ? isFastModeCooldown() : false\n  const showFastIcon = isFastModeEnabled()\n    ? isFastMode && (isFastModeAvailable() || fastModeCooldown)\n    : false\n\n  const showFastIconHint = useShowFastIconHint(showFastIcon ?? false)\n\n  // Show effort notification on startup and when effort changes.\n  // Suppressed in brief/assistant mode — the value reflects the local\n  // client's effort, not the connected agent's.\n  const effortNotificationText = briefOwnsGap\n    ? undefined\n    : getEffortNotificationText(effortValue, mainLoopModel)\n  useEffect(() => {\n    if (!effortNotificationText) {\n      removeNotification('effort-level')\n      return\n    }\n    addNotification({\n      key: 'effort-level',\n      text: effortNotificationText,\n      priority: 'high',\n      timeoutMs: 12_000,\n    })\n  }, [effortNotificationText, addNotification, removeNotification])\n\n  useBuddyNotification()\n\n  const companionSpeaking = feature('BUDDY')\n    ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n      useAppState(s => s.companionReaction !== undefined)\n    : false\n  const { columns, rows } = useTerminalSize()\n  const textInputColumns =\n    columns - 3 - companionReservedColumns(columns, companionSpeaking)\n\n  // POC: click-to-position-cursor. Mouse tracking is only enabled inside\n  // <AlternateScreen>, so this is dormant in the normal main-screen REPL.\n  // localCol/localRow are relative to the onClick Box's top-left; the Box\n  // tightly wraps the text input so they map directly to (column, line)\n  // in the Cursor wrap model. MeasuredText.getOffsetFromPosition handles\n  // wide chars, wrapped lines, and clamps past-end clicks to line end.\n  const maxVisibleLines = isFullscreenEnvEnabled()\n    ? Math.max(\n        MIN_INPUT_VIEWPORT_LINES,\n        Math.floor(rows / 2) - PROMPT_FOOTER_LINES,\n      )\n    : undefined\n\n  const handleInputClick = useCallback(\n    (e: ClickEvent) => {\n      // During history search the displayed text is historyMatch, not\n      // input, and showCursor is false anyway — skip rather than\n      // compute an offset against the wrong string.\n      if (!input || isSearchingHistory) return\n      const c = Cursor.fromText(input, textInputColumns, cursorOffset)\n      const viewportStart = c.getViewportStartLine(maxVisibleLines)\n      const offset = c.measuredText.getOffsetFromPosition({\n        line: e.localRow + viewportStart,\n        column: e.localCol,\n      })\n      setCursorOffset(offset)\n    },\n    [\n      input,\n      textInputColumns,\n      isSearchingHistory,\n      cursorOffset,\n      maxVisibleLines,\n    ],\n  )\n\n  const handleOpenTasksDialog = useCallback(\n    (taskId?: string) => setShowBashesDialog(taskId ?? true),\n    [setShowBashesDialog],\n  )\n\n  const placeholder =\n    showPromptSuggestion && promptSuggestion\n      ? promptSuggestion\n      : defaultPlaceholder\n\n  // Calculate if input has multiple lines\n  const isInputWrapped = useMemo(() => input.includes('\\n'), [input])\n\n  // Memoized callbacks for model picker to prevent re-renders when unrelated\n  // state (like notifications) changes. This prevents the inline model picker\n  // from visually \"jumping\" when notifications arrive.\n  const handleModelSelect = useCallback(\n    (model: string | null, _effort: EffortLevel | undefined) => {\n      let wasFastModeDisabled = false\n      setAppState(prev => {\n        wasFastModeDisabled =\n          isFastModeEnabled() &&\n          !isFastModeSupportedByModel(model) &&\n          !!prev.fastMode\n        return {\n          ...prev,\n          mainLoopModel: model,\n          mainLoopModelForSession: null,\n          // Turn off fast mode if switching to a model that doesn't support it\n          ...(wasFastModeDisabled && { fastMode: false }),\n        }\n      })\n      setShowModelPicker(false)\n      const effectiveFastMode = (isFastMode ?? false) && !wasFastModeDisabled\n      let message = `Model set to ${modelDisplayString(model)}`\n      if (\n        isBilledAsExtraUsage(model, effectiveFastMode, isOpus1mMergeEnabled())\n      ) {\n        message += ' · Billed as extra usage'\n      }\n      if (wasFastModeDisabled) {\n        message += ' · Fast mode OFF'\n      }\n      addNotification({\n        key: 'model-switched',\n        jsx: <Text>{message}</Text>,\n        priority: 'immediate',\n        timeoutMs: 3000,\n      })\n      logEvent('tengu_model_picker_hotkey', {\n        model:\n          model as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n    },\n    [setAppState, addNotification, isFastMode],\n  )\n\n  const handleModelCancel = useCallback(() => {\n    setShowModelPicker(false)\n  }, [])\n\n  // Memoize the model picker element to prevent unnecessary re-renders\n  // when AppState changes for unrelated reasons (e.g., notifications arriving)\n  const modelPickerElement = useMemo(() => {\n    if (!showModelPicker) return null\n    return (\n      <Box flexDirection=\"column\" marginTop={1}>\n        <ModelPicker\n          initial={mainLoopModel_}\n          sessionModel={mainLoopModelForSession}\n          onSelect={handleModelSelect}\n          onCancel={handleModelCancel}\n          isStandaloneCommand\n          showFastModeNotice={\n            isFastModeEnabled() &&\n            isFastMode &&\n            isFastModeSupportedByModel(mainLoopModel_) &&\n            isFastModeAvailable()\n          }\n        />\n      </Box>\n    )\n  }, [\n    showModelPicker,\n    mainLoopModel_,\n    mainLoopModelForSession,\n    handleModelSelect,\n    handleModelCancel,\n  ])\n\n  const handleFastModeSelect = useCallback(\n    (result?: string) => {\n      setShowFastModePicker(false)\n      if (result) {\n        addNotification({\n          key: 'fast-mode-toggled',\n          jsx: <Text>{result}</Text>,\n          priority: 'immediate',\n          timeoutMs: 3000,\n        })\n      }\n    },\n    [addNotification],\n  )\n\n  // Memoize the fast mode picker element\n  const fastModePickerElement = useMemo(() => {\n    if (!showFastModePicker) return null\n    return (\n      <Box flexDirection=\"column\" marginTop={1}>\n        <FastModePicker\n          onDone={handleFastModeSelect}\n          unavailableReason={getFastModeUnavailableReason()}\n        />\n      </Box>\n    )\n  }, [showFastModePicker, handleFastModeSelect])\n\n  // Memoized callbacks for thinking toggle\n  const handleThinkingSelect = useCallback(\n    (enabled: boolean) => {\n      setAppState(prev => ({\n        ...prev,\n        thinkingEnabled: enabled,\n      }))\n      setShowThinkingToggle(false)\n      logEvent('tengu_thinking_toggled_hotkey', { enabled })\n      addNotification({\n        key: 'thinking-toggled-hotkey',\n        jsx: (\n          <Text color={enabled ? 'suggestion' : undefined} dimColor={!enabled}>\n            Thinking {enabled ? 'on' : 'off'}\n          </Text>\n        ),\n        priority: 'immediate',\n        timeoutMs: 3000,\n      })\n    },\n    [setAppState, addNotification],\n  )\n\n  const handleThinkingCancel = useCallback(() => {\n    setShowThinkingToggle(false)\n  }, [])\n\n  // Memoize the thinking toggle element\n  const thinkingToggleElement = useMemo(() => {\n    if (!showThinkingToggle) return null\n    return (\n      <Box flexDirection=\"column\" marginTop={1}>\n        <ThinkingToggle\n          currentValue={thinkingEnabled ?? true}\n          onSelect={handleThinkingSelect}\n          onCancel={handleThinkingCancel}\n          isMidConversation={messages.some(m => m.type === 'assistant')}\n        />\n      </Box>\n    )\n  }, [\n    showThinkingToggle,\n    thinkingEnabled,\n    handleThinkingSelect,\n    handleThinkingCancel,\n    messages.length,\n  ])\n\n  // Portal dialog to DialogOverlay in fullscreen so it escapes the bottom\n  // slot's overflowY:hidden clip (same pattern as SuggestionsOverlay).\n  // Must be called before early returns below to satisfy rules-of-hooks.\n  // Memoized so the portal useEffect doesn't churn on every PromptInput render.\n  const autoModeOptInDialog = useMemo(\n    () =>\n      feature('TRANSCRIPT_CLASSIFIER') && showAutoModeOptIn ? (\n        <AutoModeOptInDialog\n          onAccept={handleAutoModeOptInAccept}\n          onDecline={handleAutoModeOptInDecline}\n        />\n      ) : null,\n    [showAutoModeOptIn, handleAutoModeOptInAccept, handleAutoModeOptInDecline],\n  )\n  useSetPromptOverlayDialog(\n    isFullscreenEnvEnabled() ? autoModeOptInDialog : null,\n  )\n\n  if (showBashesDialog) {\n    return (\n      <BackgroundTasksDialog\n        onDone={() => setShowBashesDialog(false)}\n        toolUseContext={getToolUseContext(\n          messages,\n          [],\n          new AbortController(),\n          mainLoopModel,\n        )}\n        initialDetailTaskId={\n          typeof showBashesDialog === 'string' ? showBashesDialog : undefined\n        }\n      />\n    )\n  }\n\n  if (isAgentSwarmsEnabled() && showTeamsDialog) {\n    return (\n      <TeamsDialog\n        initialTeams={cachedTeams}\n        onDone={() => {\n          setShowTeamsDialog(false)\n        }}\n      />\n    )\n  }\n\n  if (feature('QUICK_SEARCH')) {\n    const insertWithSpacing = (text: string) => {\n      const cursorChar = input[cursorOffset - 1] ?? ' '\n      insertTextAtCursor(/\\s/.test(cursorChar) ? text : ` ${text}`)\n    }\n    if (showQuickOpen) {\n      return (\n        <QuickOpenDialog\n          onDone={() => setShowQuickOpen(false)}\n          onInsert={insertWithSpacing}\n        />\n      )\n    }\n    if (showGlobalSearch) {\n      return (\n        <GlobalSearchDialog\n          onDone={() => setShowGlobalSearch(false)}\n          onInsert={insertWithSpacing}\n        />\n      )\n    }\n  }\n\n  if (feature('HISTORY_PICKER') && showHistoryPicker) {\n    return (\n      <HistorySearchDialog\n        initialQuery={input}\n        onSelect={entry => {\n          const entryMode = getModeFromInput(entry.display)\n          const value = getValueFromInput(entry.display)\n          onModeChange(entryMode)\n          trackAndSetInput(value)\n          setPastedContents(entry.pastedContents)\n          setCursorOffset(value.length)\n          setShowHistoryPicker(false)\n        }}\n        onCancel={() => setShowHistoryPicker(false)}\n      />\n    )\n  }\n\n  // Show loop mode menu when requested (ant-only, eliminated from external builds)\n  if (modelPickerElement) {\n    return modelPickerElement\n  }\n\n  if (fastModePickerElement) {\n    return fastModePickerElement\n  }\n\n  if (thinkingToggleElement) {\n    return thinkingToggleElement\n  }\n\n  if (showBridgeDialog) {\n    return (\n      <BridgeDialog\n        onDone={() => {\n          setShowBridgeDialog(false)\n          selectFooterItem(null)\n        }}\n      />\n    )\n  }\n\n  const baseProps: BaseTextInputProps = {\n    multiline: true,\n    onSubmit,\n    onChange,\n    value: historyMatch\n      ? getValueFromInput(\n          typeof historyMatch === 'string'\n            ? historyMatch\n            : historyMatch.display,\n        )\n      : input,\n    // History navigation is handled via TextInput props (onHistoryUp/onHistoryDown),\n    // NOT via useKeybindings. This allows useTextInput's upOrHistoryUp/downOrHistoryDown\n    // to try cursor movement first and only fall through to history navigation when the\n    // cursor can't move further (important for wrapped text and multi-line input).\n    onHistoryUp: handleHistoryUp,\n    onHistoryDown: handleHistoryDown,\n    onHistoryReset: resetHistory,\n    placeholder,\n    onExit,\n    onExitMessage: (show, key) => setExitMessage({ show, key }),\n    onImagePaste,\n    columns: textInputColumns,\n    maxVisibleLines,\n    disableCursorMovementForUpDownKeys:\n      suggestions.length > 0 || !!footerItemSelected,\n    disableEscapeDoublePress: suggestions.length > 0,\n    cursorOffset,\n    onChangeCursorOffset: setCursorOffset,\n    onPaste: onTextPaste,\n    onIsPastingChange: setIsPasting,\n    focus: !isSearchingHistory && !isModalOverlayActive && !footerItemSelected,\n    showCursor:\n      !footerItemSelected && !isSearchingHistory && !cursorAtImageChip,\n    argumentHint: commandArgumentHint,\n    onUndo: canUndo\n      ? () => {\n          const previousState = undo()\n          if (previousState) {\n            trackAndSetInput(previousState.text)\n            setCursorOffset(previousState.cursorOffset)\n            setPastedContents(previousState.pastedContents)\n          }\n        }\n      : undefined,\n    highlights: combinedHighlights,\n    inlineGhostText,\n    inputFilter: lazySpaceInputFilter,\n  }\n\n  const getBorderColor = (): keyof Theme => {\n    const modeColors: Record<string, keyof Theme> = {\n      bash: 'bashBorder',\n    }\n\n    // Mode colors take priority, then teammate color, then default\n    if (modeColors[mode]) {\n      return modeColors[mode]\n    }\n\n    // In-process teammates run headless - don't apply teammate colors to leader UI\n    if (isInProcessTeammate()) {\n      return 'promptBorder'\n    }\n\n    // Check for teammate color from environment\n    const teammateColorName = getTeammateColor()\n    if (\n      teammateColorName &&\n      AGENT_COLORS.includes(teammateColorName as AgentColorName)\n    ) {\n      return AGENT_COLOR_TO_THEME_COLOR[teammateColorName as AgentColorName]\n    }\n\n    return 'promptBorder'\n  }\n\n  if (isExternalEditorActive) {\n    return (\n      <Box\n        flexDirection=\"row\"\n        alignItems=\"center\"\n        justifyContent=\"center\"\n        borderColor={getBorderColor()}\n        borderStyle=\"round\"\n        borderLeft={false}\n        borderRight={false}\n        borderBottom\n        width=\"100%\"\n      >\n        <Text dimColor italic>\n          Save and close editor to continue...\n        </Text>\n      </Box>\n    )\n  }\n\n  const textInputElement = isVimModeEnabled() ? (\n    <VimTextInput\n      {...baseProps}\n      initialMode={vimMode}\n      onModeChange={setVimMode}\n    />\n  ) : (\n    <TextInput {...baseProps} />\n  )\n\n  return (\n    <Box flexDirection=\"column\" marginTop={briefOwnsGap ? 0 : 1}>\n      {!isFullscreenEnvEnabled() && <PromptInputQueuedCommands />}\n      {hasSuppressedDialogs && (\n        <Box marginTop={1} marginLeft={2}>\n          <Text dimColor>Waiting for permission…</Text>\n        </Box>\n      )}\n      <PromptInputStashNotice hasStash={stashedPrompt !== undefined} />\n      {swarmBanner ? (\n        <>\n          <Text color={swarmBanner.bgColor}>\n            {swarmBanner.text ? (\n              <>\n                {'─'.repeat(\n                  Math.max(0, columns - stringWidth(swarmBanner.text) - 4),\n                )}\n                <Text backgroundColor={swarmBanner.bgColor} color=\"inverseText\">\n                  {' '}\n                  {swarmBanner.text}{' '}\n                </Text>\n                {'──'}\n              </>\n            ) : (\n              '─'.repeat(columns)\n            )}\n          </Text>\n          <Box flexDirection=\"row\" width=\"100%\">\n            <PromptInputModeIndicator\n              mode={mode}\n              isLoading={isLoading}\n              viewingAgentName={viewingAgentName}\n              viewingAgentColor={viewingAgentColor}\n            />\n            <Box flexGrow={1} flexShrink={1} onClick={handleInputClick}>\n              {textInputElement}\n            </Box>\n          </Box>\n          <Text color={swarmBanner.bgColor}>{'─'.repeat(columns)}</Text>\n        </>\n      ) : (\n        <Box\n          flexDirection=\"row\"\n          alignItems=\"flex-start\"\n          justifyContent=\"flex-start\"\n          borderColor={getBorderColor()}\n          borderStyle=\"round\"\n          borderLeft={false}\n          borderRight={false}\n          borderBottom\n          width=\"100%\"\n          borderText={buildBorderText(\n            showFastIcon ?? false,\n            showFastIconHint,\n            fastModeCooldown,\n          )}\n        >\n          <PromptInputModeIndicator\n            mode={mode}\n            isLoading={isLoading}\n            viewingAgentName={viewingAgentName}\n            viewingAgentColor={viewingAgentColor}\n          />\n          <Box flexGrow={1} flexShrink={1} onClick={handleInputClick}>\n            {textInputElement}\n          </Box>\n        </Box>\n      )}\n      <PromptInputFooter\n        apiKeyStatus={apiKeyStatus}\n        debug={debug}\n        exitMessage={exitMessage}\n        vimMode={isVimModeEnabled() ? vimMode : undefined}\n        mode={mode}\n        autoUpdaterResult={autoUpdaterResult}\n        isAutoUpdating={isAutoUpdating}\n        verbose={verbose}\n        onAutoUpdaterResult={onAutoUpdaterResult}\n        onChangeIsUpdating={setIsAutoUpdating}\n        suggestions={suggestions}\n        selectedSuggestion={selectedSuggestion}\n        maxColumnWidth={maxColumnWidth}\n        toolPermissionContext={effectiveToolPermissionContext}\n        helpOpen={helpOpen}\n        suppressHint={input.length > 0}\n        isLoading={isLoading}\n        tasksSelected={tasksSelected}\n        teamsSelected={teamsSelected}\n        bridgeSelected={bridgeSelected}\n        tmuxSelected={tmuxSelected}\n        teammateFooterIndex={teammateFooterIndex}\n        ideSelection={ideSelection}\n        mcpClients={mcpClients}\n        isPasting={isPasting}\n        isInputWrapped={isInputWrapped}\n        messages={messages}\n        isSearching={isSearchingHistory}\n        historyQuery={historyQuery}\n        setHistoryQuery={setHistoryQuery}\n        historyFailedMatch={historyFailedMatch}\n        onOpenTasksDialog={\n          isFullscreenEnvEnabled() ? handleOpenTasksDialog : undefined\n        }\n      />\n      {isFullscreenEnvEnabled() ? null : autoModeOptInDialog}\n      {isFullscreenEnvEnabled() ? (\n        // position=absolute takes zero layout height so the spinner\n        // doesn't shift when a notification appears/disappears. Yoga\n        // anchors absolute children at the parent's content-box origin;\n        // marginTop=-1 pulls it into the marginTop=1 gap row above the\n        // prompt border. In brief mode there is no such gap (briefOwnsGap\n        // strips our marginTop) and BriefSpinner sits flush against the\n        // border — marginTop=-2 skips over the spinner content into\n        // BriefSpinner's own marginTop=1 blank row. height=1 +\n        // overflow=hidden clips multi-line notifications to a single row.\n        // flex-end anchors the bottom line so the visible row is always\n        // the most recent. Suppressed while the slash overlay or\n        // auto-mode opt-in dialog is up by height=0 (NOT unmount) — this\n        // Box renders later in tree order so it would paint over their\n        // bottom row. Keeping Notifications mounted prevents AutoUpdater's\n        // initial-check effect from re-firing on every slash-completion\n        // toggle (PR#22413).\n        <Box\n          position=\"absolute\"\n          marginTop={briefOwnsGap ? -2 : -1}\n          height={suggestions.length === 0 && !showAutoModeOptIn ? 1 : 0}\n          width=\"100%\"\n          paddingLeft={2}\n          paddingRight={1}\n          flexDirection=\"column\"\n          justifyContent=\"flex-end\"\n          overflow=\"hidden\"\n        >\n          <Notifications\n            apiKeyStatus={apiKeyStatus}\n            autoUpdaterResult={autoUpdaterResult}\n            debug={debug}\n            isAutoUpdating={isAutoUpdating}\n            verbose={verbose}\n            messages={messages}\n            onAutoUpdaterResult={onAutoUpdaterResult}\n            onChangeIsUpdating={setIsAutoUpdating}\n            ideSelection={ideSelection}\n            mcpClients={mcpClients}\n            isInputWrapped={isInputWrapped}\n          />\n        </Box>\n      ) : null}\n    </Box>\n  )\n}\n\n/**\n * Compute the initial paste ID by finding the max ID used in existing messages.\n * This handles --continue/--resume scenarios where we need to avoid ID collisions.\n */\nfunction getInitialPasteId(messages: Message[]): number {\n  let maxId = 0\n  for (const message of messages) {\n    if (message.type === 'user') {\n      // Check image paste IDs\n      if (message.imagePasteIds) {\n        for (const id of message.imagePasteIds) {\n          if (id > maxId) maxId = id\n        }\n      }\n      // Check text paste references in message content\n      if (Array.isArray(message.message.content)) {\n        for (const block of message.message.content) {\n          if (block.type === 'text') {\n            const refs = parseReferences(block.text)\n            for (const ref of refs) {\n              if (ref.id > maxId) maxId = ref.id\n            }\n          }\n        }\n      }\n    }\n  }\n  return maxId + 1\n}\n\nfunction buildBorderText(\n  showFastIcon: boolean,\n  showFastIconHint: boolean,\n  fastModeCooldown: boolean,\n): BorderTextOptions | undefined {\n  if (!showFastIcon) return undefined\n  const fastSeg = showFastIconHint\n    ? `${getFastIconString(true, fastModeCooldown)} ${chalk.dim('/fast')}`\n    : getFastIconString(true, fastModeCooldown)\n  return {\n    content: ` ${fastSeg} `,\n    position: 'top',\n    align: 'end',\n    offset: 0,\n  }\n}\n\nexport default React.memo(PromptInput)\n"],"mappings":"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","ignoreList":[]}