import { feature } from 'bun:bundle';
import chalk from 'chalk';
import * as path from 'path';
import * as React from 'react';
import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';
import { useNotifications } from 'src/context/notifications.js';
import { useCommandQueue } from 'src/hooks/useCommandQueue.js';
import { type IDEAtMentioned, useIdeAtMentioned } from 'src/hooks/useIdeAtMentioned.js';
import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from 'src/services/analytics/index.js';
import { type AppState, useAppState, useAppStateStore, useSetAppState } from 'src/state/AppState.js';
import type { FooterItem } from 'src/state/AppStateStore.js';
import { getCwd } from 'src/utils/cwd.js';
import { isQueuedCommandEditable, popAllEditable } from 'src/utils/messageQueueManager.js';
import stripAnsi from 'strip-ansi';
import { companionReservedColumns } from '../../buddy/CompanionSprite.js';
import { findBuddyTriggerPositions, useBuddyNotification } from '../../buddy/useBuddyNotification.js';
import { FastModePicker } from '../../commands/fast/fast.js';
import { isUltrareviewEnabled } from '../../commands/review/ultrareviewEnabled.js';
import { getNativeCSIuTerminalDisplayName } from '../../commands/terminalSetup/terminalSetup.js';
import { type Command, hasCommand } from '../../commands.js';
import { useIsModalOverlayActive } from '../../context/overlayContext.js';
import { useSetPromptOverlayDialog } from '../../context/promptOverlayContext.js';
import { formatImageRef, formatPastedTextRef, getPastedTextRefNumLines, parseReferences } from '../../history.js';
import type { VerificationStatus } from '../../hooks/useApiKeyVerification.js';
import { type HistoryMode, useArrowKeyHistory } from '../../hooks/useArrowKeyHistory.js';
import { useDoublePress } from '../../hooks/useDoublePress.js';
import { useHistorySearch } from '../../hooks/useHistorySearch.js';
import type { IDESelection } from '../../hooks/useIdeSelection.js';
import { useInputBuffer } from '../../hooks/useInputBuffer.js';
import { useMainLoopModel } from '../../hooks/useMainLoopModel.js';
import { usePromptSuggestion } from '../../hooks/usePromptSuggestion.js';
import { useTerminalSize } from '../../hooks/useTerminalSize.js';
import { useTypeahead } from '../../hooks/useTypeahead.js';
import type { BorderTextOptions } from '../../ink/render-border.js';
import { stringWidth } from '../../ink/stringWidth.js';
import { Box, type ClickEvent, type Key, Text, useInput } from '../../ink.js';
import { useOptionalKeybindingContext } from '../../keybindings/KeybindingContext.js';
import { getShortcutDisplay } from '../../keybindings/shortcutFormat.js';
import { useKeybinding, useKeybindings } from '../../keybindings/useKeybinding.js';
import type { MCPServerConnection } from '../../services/mcp/types.js';
import { abortPromptSuggestion, logSuggestionSuppressed } from '../../services/PromptSuggestion/promptSuggestion.js';
import { type ActiveSpeculationState, abortSpeculation } from '../../services/PromptSuggestion/speculation.js';
import { getActiveAgentForInput, getViewedTeammateTask } from '../../state/selectors.js';
import { enterTeammateView, exitTeammateView, stopOrDismissAgent } from '../../state/teammateViewHelpers.js';
import type { ToolPermissionContext } from '../../Tool.js';
import { getRunningTeammatesSorted } from '../../tasks/InProcessTeammateTask/InProcessTeammateTask.js';
import type { InProcessTeammateTaskState } from '../../tasks/InProcessTeammateTask/types.js';
import { isPanelAgentTask, type LocalAgentTaskState } from '../../tasks/LocalAgentTask/LocalAgentTask.js';
import { isBackgroundTask } from '../../tasks/types.js';
import { AGENT_COLOR_TO_THEME_COLOR, AGENT_COLORS, type AgentColorName } from '../../tools/AgentTool/agentColorManager.js';
import type { AgentDefinition } from '../../tools/AgentTool/loadAgentsDir.js';
import type { Message } from '../../types/message.js';
import type { PermissionMode } from '../../types/permissions.js';
import type { BaseTextInputProps, PromptInputMode, VimMode } from '../../types/textInputTypes.js';
import { isAgentSwarmsEnabled } from '../../utils/agentSwarmsEnabled.js';
import { count } from '../../utils/array.js';
import type { AutoUpdaterResult } from '../../utils/autoUpdater.js';
import { Cursor } from '../../utils/Cursor.js';
import { getGlobalConfig, type PastedContent, saveGlobalConfig } from '../../utils/config.js';
import { logForDebugging } from '../../utils/debug.js';
import { parseDirectMemberMessage, sendDirectMemberMessage } from '../../utils/directMemberMessage.js';
import type { EffortLevel } from '../../utils/effort.js';
import { env } from '../../utils/env.js';
import { errorMessage } from '../../utils/errors.js';
import { isBilledAsExtraUsage } from '../../utils/extraUsage.js';
import { getFastModeUnavailableReason, isFastModeAvailable, isFastModeCooldown, isFastModeEnabled, isFastModeSupportedByModel } from '../../utils/fastMode.js';
import { isFullscreenEnvEnabled } from '../../utils/fullscreen.js';
import type { PromptInputHelpers } from '../../utils/handlePromptSubmit.js';
import { getImageFromClipboard, PASTE_THRESHOLD } from '../../utils/imagePaste.js';
import type { ImageDimensions } from '../../utils/imageResizer.js';
import { cacheImagePath, storeImage } from '../../utils/imageStore.js';
import { isMacosOptionChar, MACOS_OPTION_SPECIAL_CHARS } from '../../utils/keyboardShortcuts.js';
import { logError } from '../../utils/log.js';
import { isOpus1mMergeEnabled, modelDisplayString } from '../../utils/model/model.js';
import { setAutoModeActive } from '../../utils/permissions/autoModeState.js';
import { cyclePermissionMode, getNextPermissionMode } from '../../utils/permissions/getNextPermissionMode.js';
import { transitionPermissionMode } from '../../utils/permissions/permissionSetup.js';
import { getPlatform } from '../../utils/platform.js';
import type { ProcessUserInputContext } from '../../utils/processUserInput/processUserInput.js';
import { editPromptInEditor } from '../../utils/promptEditor.js';
import { hasAutoModeOptIn } from '../../utils/settings/settings.js';
import { findBtwTriggerPositions } from '../../utils/sideQuestion.js';
import { findSlashCommandPositions } from '../../utils/suggestions/commandSuggestions.js';
import { findSlackChannelPositions, getKnownChannelsVersion, hasSlackMcpServer, subscribeKnownChannels } from '../../utils/suggestions/slackChannelSuggestions.js';
import { isInProcessEnabled } from '../../utils/swarm/backends/registry.js';
import { syncTeammateMode } from '../../utils/swarm/teamHelpers.js';
import type { TeamSummary } from '../../utils/teamDiscovery.js';
import { getTeammateColor } from '../../utils/teammate.js';
import { isInProcessTeammate } from '../../utils/teammateContext.js';
import { writeToMailbox } from '../../utils/teammateMailbox.js';
import type { TextHighlight } from '../../utils/textHighlighting.js';
import type { Theme } from '../../utils/theme.js';
import { findThinkingTriggerPositions, getRainbowColor, isUltrathinkEnabled } from '../../utils/thinking.js';
import { findTokenBudgetPositions } from '../../utils/tokenBudget.js';
import { findUltraplanTriggerPositions, findUltrareviewTriggerPositions } from '../../utils/ultraplan/keyword.js';
import { AutoModeOptInDialog } from '../AutoModeOptInDialog.js';
import { BridgeDialog } from '../BridgeDialog.js';
import { ConfigurableShortcutHint } from '../ConfigurableShortcutHint.js';
import { getVisibleAgentTasks, useCoordinatorTaskCount } from '../CoordinatorAgentStatus.js';
import { getEffortNotificationText } from '../EffortIndicator.js';
import { getFastIconString } from '../FastIcon.js';
import { GlobalSearchDialog } from '../GlobalSearchDialog.js';
import { HistorySearchDialog } from '../HistorySearchDialog.js';
import { ModelPicker } from '../ModelPicker.js';
import { QuickOpenDialog } from '../QuickOpenDialog.js';
import TextInput from '../TextInput.js';
import { ThinkingToggle } from '../ThinkingToggle.js';
import { BackgroundTasksDialog } from '../tasks/BackgroundTasksDialog.js';
import { shouldHideTasksFooter } from '../tasks/taskStatusUtils.js';
import { TeamsDialog } from '../teams/TeamsDialog.js';
import VimTextInput from '../VimTextInput.js';
import { getModeFromInput, getValueFromInput } from './inputModes.js';
import { FOOTER_TEMPORARY_STATUS_TIMEOUT, Notifications } from './Notifications.js';
import PromptInputFooter from './PromptInputFooter.js';
import type { SuggestionItem } from './PromptInputFooterSuggestions.js';
import { PromptInputModeIndicator } from './PromptInputModeIndicator.js';
import { PromptInputQueuedCommands } from './PromptInputQueuedCommands.js';
import { PromptInputStashNotice } from './PromptInputStashNotice.js';
import { useMaybeTruncateInput } from './useMaybeTruncateInput.js';
import { usePromptInputPlaceholder } from './usePromptInputPlaceholder.js';
import { useShowFastIconHint } from './useShowFastIconHint.js';
import { useSwarmBanner } from './useSwarmBanner.js';
import { isNonSpacePrintable, isVimModeEnabled } from './utils.js';
type Props = {
  debug: boolean;
  ideSelection: IDESelection | undefined;
  toolPermissionContext: ToolPermissionContext;
  setToolPermissionContext: (ctx: ToolPermissionContext) => void;
  apiKeyStatus: VerificationStatus;
  commands: Command[];
  agents: AgentDefinition[];
  isLoading: boolean;
  verbose: boolean;
  messages: Message[];
  onAutoUpdaterResult: (result: AutoUpdaterResult) => void;
  autoUpdaterResult: AutoUpdaterResult | null;
  input: string;
  onInputChange: (value: string) => void;
  mode: PromptInputMode;
  onModeChange: (mode: PromptInputMode) => void;
  stashedPrompt: {
    text: string;
    cursorOffset: number;
    pastedContents: Record<number, PastedContent>;
  } | undefined;
  setStashedPrompt: (value: {
    text: string;
    cursorOffset: number;
    pastedContents: Record<number, PastedContent>;
  } | undefined) => void;
  submitCount: number;
  onShowMessageSelector: () => void;
  /** Fullscreen message actions: shift+↑ enters cursor. */
  onMessageActionsEnter?: () => void;
  mcpClients: MCPServerConnection[];
  pastedContents: Record<number, PastedContent>;
  setPastedContents: React.Dispatch<React.SetStateAction<Record<number, PastedContent>>>;
  vimMode: VimMode;
  setVimMode: (mode: VimMode) => void;
  showBashesDialog: string | boolean;
  setShowBashesDialog: (show: string | boolean) => void;
  onExit: () => void;
  getToolUseContext: (messages: Message[], newMessages: Message[], abortController: AbortController, mainLoopModel: string) => ProcessUserInputContext;
  onSubmit: (input: string, helpers: PromptInputHelpers, speculationAccept?: {
    state: ActiveSpeculationState;
    speculationSessionTimeSavedMs: number;
    setAppState: (f: (prev: AppState) => AppState) => void;
  }, options?: {
    fromKeybinding?: boolean;
  }) => Promise<void>;
  onAgentSubmit?: (input: string, task: InProcessTeammateTaskState | LocalAgentTaskState, helpers: PromptInputHelpers) => Promise<void>;
  isSearchingHistory: boolean;
  setIsSearchingHistory: (isSearching: boolean) => void;
  onDismissSideQuestion?: () => void;
  isSideQuestionVisible?: boolean;
  helpOpen: boolean;
  setHelpOpen: React.Dispatch<React.SetStateAction<boolean>>;
  hasSuppressedDialogs?: boolean;
  isLocalJSXCommandActive?: boolean;
  insertTextRef?: React.MutableRefObject<{
    insert: (text: string) => void;
    setInputWithCursor: (value: string, cursor: number) => void;
    cursorOffset: number;
  } | null>;
  voiceInterimRange?: {
    start: number;
    end: number;
  } | null;
};

// Bottom slot has maxHeight="50%"; reserve lines for footer, border, status.
const PROMPT_FOOTER_LINES = 5;
const MIN_INPUT_VIEWPORT_LINES = 3;
function PromptInput({
  debug,
  ideSelection,
  toolPermissionContext,
  setToolPermissionContext,
  apiKeyStatus,
  commands,
  agents,
  isLoading,
  verbose,
  messages,
  onAutoUpdaterResult,
  autoUpdaterResult,
  input,
  onInputChange,
  mode,
  onModeChange,
  stashedPrompt,
  setStashedPrompt,
  submitCount,
  onShowMessageSelector,
  onMessageActionsEnter,
  mcpClients,
  pastedContents,
  setPastedContents,
  vimMode,
  setVimMode,
  showBashesDialog,
  setShowBashesDialog,
  onExit,
  getToolUseContext,
  onSubmit: onSubmitProp,
  onAgentSubmit,
  isSearchingHistory,
  setIsSearchingHistory,
  onDismissSideQuestion,
  isSideQuestionVisible,
  helpOpen,
  setHelpOpen,
  hasSuppressedDialogs,
  isLocalJSXCommandActive = false,
  insertTextRef,
  voiceInterimRange
}: Props): React.ReactNode {
  const mainLoopModel = useMainLoopModel();
  // A local-jsx command (e.g., /mcp while agent is running) renders a full-
  // screen dialog on top of PromptInput via the immediate-command path with
  // shouldHidePromptInput: false. Those dialogs don't register in the overlay
  // system, so treat them as a modal overlay here to stop navigation keys from
  // leaking into TextInput/footer handlers and stacking a second dialog.
  const isModalOverlayActive = useIsModalOverlayActive() || isLocalJSXCommandActive;
  const [isAutoUpdating, setIsAutoUpdating] = useState(false);
  const [exitMessage, setExitMessage] = useState<{
    show: boolean;
    key?: string;
  }>({
    show: false
  });
  const [cursorOffset, setCursorOffset] = useState<number>(input.length);
  // Track the last input value set via internal handlers so we can detect
  // external input changes (e.g. speech-to-text injection) and move cursor to end.
  const lastInternalInputRef = React.useRef(input);
  if (input !== lastInternalInputRef.current) {
    // Input changed externally (not through any internal handler) — move cursor to end
    setCursorOffset(input.length);
    lastInternalInputRef.current = input;
  }
  // Wrap onInputChange to track internal changes before they trigger re-render
  const trackAndSetInput = React.useCallback((value: string) => {
    lastInternalInputRef.current = value;
    onInputChange(value);
  }, [onInputChange]);
  // Expose an insertText function so callers (e.g. STT) can splice text at the
  // current cursor position instead of replacing the entire input.
  if (insertTextRef) {
    insertTextRef.current = {
      cursorOffset,
      insert: (text: string) => {
        const needsSpace = cursorOffset === input.length && input.length > 0 && !/\s$/.test(input);
        const insertText = needsSpace ? ' ' + text : text;
        const newValue = input.slice(0, cursorOffset) + insertText + input.slice(cursorOffset);
        lastInternalInputRef.current = newValue;
        onInputChange(newValue);
        setCursorOffset(cursorOffset + insertText.length);
      },
      setInputWithCursor: (value: string, cursor: number) => {
        lastInternalInputRef.current = value;
        onInputChange(value);
        setCursorOffset(cursor);
      }
    };
  }
  const store = useAppStateStore();
  const setAppState = useSetAppState();
  const tasks = useAppState(s => s.tasks);
  const replBridgeConnected = useAppState(s => s.replBridgeConnected);
  const replBridgeExplicit = useAppState(s => s.replBridgeExplicit);
  const replBridgeReconnecting = useAppState(s => s.replBridgeReconnecting);
  // Must match BridgeStatusIndicator's render condition (PromptInputFooter.tsx) —
  // the pill returns null for implicit-and-not-reconnecting, so nav must too,
  // otherwise bridge becomes an invisible selection stop.
  const bridgeFooterVisible = replBridgeConnected && (replBridgeExplicit || replBridgeReconnecting);
  // Tmux pill (ant-only) — visible when there's an active tungsten session
  const hasTungstenSession = useAppState(s => ("external" as string) === 'ant' && s.tungstenActiveSession !== undefined);
  const tmuxFooterVisible = ("external" as string) === 'ant' && hasTungstenSession;
  // WebBrowser pill — visible when a browser is open
  const bagelFooterVisible = useAppState(s => false);
  const teamContext = useAppState(s => s.teamContext);
  const queuedCommands = useCommandQueue();
  const promptSuggestionState = useAppState(s => s.promptSuggestion);
  const speculation = useAppState(s => s.speculation);
  const speculationSessionTimeSavedMs = useAppState(s => s.speculationSessionTimeSavedMs);
  const viewingAgentTaskId = useAppState(s => s.viewingAgentTaskId);
  const viewSelectionMode = useAppState(s => s.viewSelectionMode);
  const showSpinnerTree = useAppState(s => s.expandedView) === 'teammates';
  const {
    companion: _companion,
    companionMuted
  } = feature('BUDDY') ? getGlobalConfig() : {
    companion: undefined,
    companionMuted: undefined
  };
  const companionFooterVisible = !!_companion && !companionMuted;
  // Brief mode: BriefSpinner/BriefIdleStatus own the 2-row footprint above
  // the input. Dropping marginTop here lets the spinner sit flush against
  // the input bar. viewingAgentTaskId mirrors the gate on both (Spinner.tsx,
  // REPL.tsx) — teammate view falls back to SpinnerWithVerbInner which has
  // its own marginTop, so the gap stays even without ours.
  const briefOwnsGap = feature('KAIROS') || feature('KAIROS_BRIEF') ?
  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
  useAppState(s => s.isBriefOnly) && !viewingAgentTaskId : false;
  const mainLoopModel_ = useAppState(s => s.mainLoopModel);
  const mainLoopModelForSession = useAppState(s => s.mainLoopModelForSession);
  const thinkingEnabled = useAppState(s => s.thinkingEnabled);
  const isFastMode = useAppState(s => isFastModeEnabled() ? s.fastMode : false);
  const effortValue = useAppState(s => s.effortValue);
  const viewedTeammate = getViewedTeammateTask(store.getState());
  const viewingAgentName = viewedTeammate?.identity.agentName;
  // identity.color is typed as `string | undefined` (not AgentColorName) because
  // teammate identity comes from file-based config. Validate before casting to
  // ensure we only use valid color names (falls back to cyan if invalid).
  const viewingAgentColor = viewedTeammate?.identity.color && AGENT_COLORS.includes(viewedTeammate.identity.color as AgentColorName) ? viewedTeammate.identity.color as AgentColorName : undefined;
  // In-process teammates sorted alphabetically for footer team selector
  const inProcessTeammates = useMemo(() => getRunningTeammatesSorted(tasks), [tasks]);

  // Team mode: all background tasks are in-process teammates
  const isTeammateMode = inProcessTeammates.length > 0 || viewedTeammate !== undefined;

  // When viewing a teammate, show their permission mode in the footer instead of the leader's
  const effectiveToolPermissionContext = useMemo((): ToolPermissionContext => {
    if (viewedTeammate) {
      return {
        ...toolPermissionContext,
        mode: viewedTeammate.permissionMode
      };
    }
    return toolPermissionContext;
  }, [viewedTeammate, toolPermissionContext]);
  const {
    historyQuery,
    setHistoryQuery,
    historyMatch,
    historyFailedMatch
  } = useHistorySearch(entry => {
    setPastedContents(entry.pastedContents);
    void onSubmit(entry.display);
  }, input, trackAndSetInput, setCursorOffset, cursorOffset, onModeChange, mode, isSearchingHistory, setIsSearchingHistory, setPastedContents, pastedContents);
  // Counter for paste IDs (shared between images and text).
  // Compute initial value once from existing messages (for --continue/--resume).
  // useRef(fn()) evaluates fn() on every render and discards the result after
  // mount — getInitialPasteId walks all messages + regex-scans text blocks,
  // so guard with a lazy-init pattern to run it exactly once.
  const nextPasteIdRef = useRef(-1);
  if (nextPasteIdRef.current === -1) {
    nextPasteIdRef.current = getInitialPasteId(messages);
  }
  // Armed by onImagePaste; if the very next keystroke is a non-space
  // printable, inputFilter prepends a space before it. Any other input
  // (arrow, escape, backspace, paste, space) disarms without inserting.
  const pendingSpaceAfterPillRef = useRef(false);
  const [showTeamsDialog, setShowTeamsDialog] = useState(false);
  const [showBridgeDialog, setShowBridgeDialog] = useState(false);
  const [teammateFooterIndex, setTeammateFooterIndex] = useState(0);
  // -1 sentinel: tasks pill is selected but no specific agent row is selected yet.
  // First ↓ selects the pill, second ↓ moves to row 0. Prevents double-select
  // of pill + row when both bg tasks (pill) and forked agents (rows) are visible.
  const coordinatorTaskIndex = useAppState(s => s.coordinatorTaskIndex);
  const setCoordinatorTaskIndex = useCallback((v: number | ((prev: number) => number)) => setAppState(prev => {
    const next = typeof v === 'function' ? v(prev.coordinatorTaskIndex) : v;
    if (next === prev.coordinatorTaskIndex) return prev;
    return {
      ...prev,
      coordinatorTaskIndex: next
    };
  }), [setAppState]);
  const coordinatorTaskCount = useCoordinatorTaskCount();
  // The pill (BackgroundTaskStatus) only renders when non-local_agent bg tasks
  // exist. When only local_agent tasks are running (coordinator/fork mode), the
  // pill is absent, so the -1 sentinel would leave nothing visually selected.
  // In that case, skip -1 and treat 0 as the minimum selectable index.
  const hasBgTaskPill = useMemo(() => Object.values(tasks).some(t => isBackgroundTask(t) && !(("external" as string) === 'ant' && isPanelAgentTask(t))), [tasks]);
  const minCoordinatorIndex = hasBgTaskPill ? -1 : 0;
  // Clamp index when tasks complete and the list shrinks beneath the cursor
  useEffect(() => {
    if (coordinatorTaskIndex >= coordinatorTaskCount) {
      setCoordinatorTaskIndex(Math.max(minCoordinatorIndex, coordinatorTaskCount - 1));
    } else if (coordinatorTaskIndex < minCoordinatorIndex) {
      setCoordinatorTaskIndex(minCoordinatorIndex);
    }
  }, [coordinatorTaskCount, coordinatorTaskIndex, minCoordinatorIndex]);
  const [isPasting, setIsPasting] = useState(false);
  const [isExternalEditorActive, setIsExternalEditorActive] = useState(false);
  const [showModelPicker, setShowModelPicker] = useState(false);
  const [showQuickOpen, setShowQuickOpen] = useState(false);
  const [showGlobalSearch, setShowGlobalSearch] = useState(false);
  const [showHistoryPicker, setShowHistoryPicker] = useState(false);
  const [showFastModePicker, setShowFastModePicker] = useState(false);
  const [showThinkingToggle, setShowThinkingToggle] = useState(false);
  const [showAutoModeOptIn, setShowAutoModeOptIn] = useState(false);
  const [previousModeBeforeAuto, setPreviousModeBeforeAuto] = useState<PermissionMode | null>(null);
  const autoModeOptInTimeoutRef = useRef<NodeJS.Timeout | null>(null);

  // Check if cursor is on the first line of input
  const isCursorOnFirstLine = useMemo(() => {
    const firstNewlineIndex = input.indexOf('\n');
    if (firstNewlineIndex === -1) {
      return true; // No newlines, cursor is always on first line
    }
    return cursorOffset <= firstNewlineIndex;
  }, [input, cursorOffset]);
  const isCursorOnLastLine = useMemo(() => {
    const lastNewlineIndex = input.lastIndexOf('\n');
    if (lastNewlineIndex === -1) {
      return true; // No newlines, cursor is always on last line
    }
    return cursorOffset > lastNewlineIndex;
  }, [input, cursorOffset]);

  // Derive team info from teamContext (no filesystem I/O needed)
  // A session can only lead one team at a time
  const cachedTeams: TeamSummary[] = useMemo(() => {
    if (!isAgentSwarmsEnabled()) return [];
    // In-process mode uses Shift+Down/Up navigation instead of footer menu
    if (isInProcessEnabled()) return [];
    if (!teamContext) {
      return [];
    }
    const teammateCount = count(Object.values(teamContext.teammates), t => t.name !== 'team-lead');
    return [{
      name: teamContext.teamName,
      memberCount: teammateCount,
      runningCount: 0,
      idleCount: 0
    }];
  }, [teamContext]);

  // ─── Footer pill navigation ─────────────────────────────────────────────
  // Which pills render below the input box. Order here IS the nav order
  // (down/right = forward, up/left = back). Selection lives in AppState so
  // pills rendered outside PromptInput (CompanionSprite) can read focus.
  const runningTaskCount = useMemo(() => count(Object.values(tasks), t => t.status === 'running'), [tasks]);
  // Panel shows retained-completed agents too (getVisibleAgentTasks), so the
  // pill must stay navigable whenever the panel has rows — not just when
  // something is running.
  const tasksFooterVisible = (runningTaskCount > 0 || ("external" as string) === 'ant' && coordinatorTaskCount > 0) && !shouldHideTasksFooter(tasks, showSpinnerTree);
  const teamsFooterVisible = cachedTeams.length > 0;
  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]);

  // Effective selection: null if the selected pill stopped rendering (bridge
  // disconnected, task finished). The derivation makes the UI correct
  // immediately; the useEffect below clears the raw state so it doesn't
  // resurrect when the same pill reappears (new task starts → focus stolen).
  const rawFooterSelection = useAppState(s => s.footerSelection);
  const footerItemSelected = rawFooterSelection && footerItems.includes(rawFooterSelection) ? rawFooterSelection : null;
  useEffect(() => {
    if (rawFooterSelection && !footerItemSelected) {
      setAppState(prev => prev.footerSelection === null ? prev : {
        ...prev,
        footerSelection: null
      });
    }
  }, [rawFooterSelection, footerItemSelected, setAppState]);
  const tasksSelected = footerItemSelected === 'tasks';
  const tmuxSelected = footerItemSelected === 'tmux';
  const bagelSelected = footerItemSelected === 'bagel';
  const teamsSelected = footerItemSelected === 'teams';
  const bridgeSelected = footerItemSelected === 'bridge';
  function selectFooterItem(item: FooterItem | null): void {
    setAppState(prev => prev.footerSelection === item ? prev : {
      ...prev,
      footerSelection: item
    });
    if (item === 'tasks') {
      setTeammateFooterIndex(0);
      setCoordinatorTaskIndex(minCoordinatorIndex);
    }
  }

  // delta: +1 = down/right, -1 = up/left. Returns true if nav happened
  // (including deselecting at the start), false if at a boundary.
  function navigateFooter(delta: 1 | -1, exitAtStart = false): boolean {
    const idx = footerItemSelected ? footerItems.indexOf(footerItemSelected) : -1;
    const next = footerItems[idx + delta];
    if (next) {
      selectFooterItem(next);
      return true;
    }
    if (delta < 0 && exitAtStart) {
      selectFooterItem(null);
      return true;
    }
    return false;
  }

  // Prompt suggestion hook - reads suggestions generated by forked agent in query loop
  const {
    suggestion: promptSuggestion,
    markAccepted,
    logOutcomeAtSubmission,
    markShown
  } = usePromptSuggestion({
    inputValue: input,
    isAssistantResponding: isLoading
  });
  const displayedValue = useMemo(() => isSearchingHistory && historyMatch ? getValueFromInput(typeof historyMatch === 'string' ? historyMatch : historyMatch.display) : input, [isSearchingHistory, historyMatch, input]);
  const thinkTriggers = useMemo(() => findThinkingTriggerPositions(displayedValue), [displayedValue]);
  const ultraplanSessionUrl = useAppState(s => s.ultraplanSessionUrl);
  const ultraplanLaunching = useAppState(s => s.ultraplanLaunching);
  const ultraplanTriggers = useMemo(() => feature('ULTRAPLAN') && !ultraplanSessionUrl && !ultraplanLaunching ? findUltraplanTriggerPositions(displayedValue) : [], [displayedValue, ultraplanSessionUrl, ultraplanLaunching]);
  const ultrareviewTriggers = useMemo(() => isUltrareviewEnabled() ? findUltrareviewTriggerPositions(displayedValue) : [], [displayedValue]);
  const btwTriggers = useMemo(() => findBtwTriggerPositions(displayedValue), [displayedValue]);
  const buddyTriggers = useMemo(() => findBuddyTriggerPositions(displayedValue), [displayedValue]);
  const slashCommandTriggers = useMemo(() => {
    const positions = findSlashCommandPositions(displayedValue);
    // Only highlight valid commands
    return positions.filter(pos => {
      const commandName = displayedValue.slice(pos.start + 1, pos.end); // +1 to skip "/"
      return hasCommand(commandName, commands);
    });
  }, [displayedValue, commands]);
  const tokenBudgetTriggers = useMemo(() => feature('TOKEN_BUDGET') ? findTokenBudgetPositions(displayedValue) : [], [displayedValue]);
  const knownChannelsVersion = useSyncExternalStore(subscribeKnownChannels, getKnownChannelsVersion);
  const slackChannelTriggers = useMemo(() => hasSlackMcpServer(store.getState().mcp.clients) ? findSlackChannelPositions(displayedValue) : [],
  // eslint-disable-next-line react-hooks/exhaustive-deps -- store is a stable ref
  [displayedValue, knownChannelsVersion]);

  // Find @name mentions and highlight with team member's color
  const memberMentionHighlights = useMemo((): Array<{
    start: number;
    end: number;
    themeColor: keyof Theme;
  }> => {
    if (!isAgentSwarmsEnabled()) return [];
    if (!teamContext?.teammates) return [];
    const highlights: Array<{
      start: number;
      end: number;
      themeColor: keyof Theme;
    }> = [];
    const members = teamContext.teammates;
    if (!members) return highlights;

    // Find all @name patterns in the input
    const regex = /(^|\s)@([\w-]+)/g;
    const memberValues = Object.values(members);
    let match;
    while ((match = regex.exec(displayedValue)) !== null) {
      const leadingSpace = match[1] ?? '';
      const nameStart = match.index + leadingSpace.length;
      const fullMatch = match[0].trimStart();
      const name = match[2];

      // Check if this name matches a team member
      const member = memberValues.find(t => t.name === name);
      if (member?.color) {
        const themeColor = AGENT_COLOR_TO_THEME_COLOR[member.color as AgentColorName];
        if (themeColor) {
          highlights.push({
            start: nameStart,
            end: nameStart + fullMatch.length,
            themeColor
          });
        }
      }
    }
    return highlights;
  }, [displayedValue, teamContext]);
  const imageRefPositions = useMemo(() => parseReferences(displayedValue).filter(r => r.match.startsWith('[Image')).map(r => ({
    start: r.index,
    end: r.index + r.match.length
  })), [displayedValue]);

  // chip.start is the "selected" state: the inverted chip IS the cursor.
  // chip.end stays a normal position so you can park the cursor right after
  // `]` like any other character.
  const cursorAtImageChip = imageRefPositions.some(r => r.start === cursorOffset);

  // up/down movement or a fullscreen click can land the cursor strictly
  // inside a chip; snap to the nearer boundary so it's never editable
  // char-by-char.
  useEffect(() => {
    const inside = imageRefPositions.find(r => cursorOffset > r.start && cursorOffset < r.end);
    if (inside) {
      const mid = (inside.start + inside.end) / 2;
      setCursorOffset(cursorOffset < mid ? inside.start : inside.end);
    }
  }, [cursorOffset, imageRefPositions, setCursorOffset]);
  const combinedHighlights = useMemo((): TextHighlight[] => {
    const highlights: TextHighlight[] = [];

    // Invert the [Image #N] chip when the cursor is at chip.start (the
    // "selected" state) so backspace-to-delete is visually obvious.
    for (const ref of imageRefPositions) {
      if (cursorOffset === ref.start) {
        highlights.push({
          start: ref.start,
          end: ref.end,
          color: undefined,
          inverse: true,
          priority: 8
        });
      }
    }
    if (isSearchingHistory && historyMatch && !historyFailedMatch) {
      highlights.push({
        start: cursorOffset,
        end: cursorOffset + historyQuery.length,
        color: 'warning',
        priority: 20
      });
    }

    // Add "btw" highlighting (solid yellow)
    for (const trigger of btwTriggers) {
      highlights.push({
        start: trigger.start,
        end: trigger.end,
        color: 'warning',
        priority: 15
      });
    }

    // Add /command highlighting (blue)
    for (const trigger of slashCommandTriggers) {
      highlights.push({
        start: trigger.start,
        end: trigger.end,
        color: 'suggestion',
        priority: 5
      });
    }

    // Add token budget highlighting (blue)
    for (const trigger of tokenBudgetTriggers) {
      highlights.push({
        start: trigger.start,
        end: trigger.end,
        color: 'suggestion',
        priority: 5
      });
    }
    for (const trigger of slackChannelTriggers) {
      highlights.push({
        start: trigger.start,
        end: trigger.end,
        color: 'suggestion',
        priority: 5
      });
    }

    // Add @name highlighting with team member's color
    for (const mention of memberMentionHighlights) {
      highlights.push({
        start: mention.start,
        end: mention.end,
        color: mention.themeColor,
        priority: 5
      });
    }

    // Dim interim voice dictation text
    if (voiceInterimRange) {
      highlights.push({
        start: voiceInterimRange.start,
        end: voiceInterimRange.end,
        color: undefined,
        dimColor: true,
        priority: 1
      });
    }

    // Rainbow highlighting for ultrathink keyword (per-character cycling colors)
    if (isUltrathinkEnabled()) {
      for (const trigger of thinkTriggers) {
        for (let i = trigger.start; i < trigger.end; i++) {
          highlights.push({
            start: i,
            end: i + 1,
            color: getRainbowColor(i - trigger.start),
            shimmerColor: getRainbowColor(i - trigger.start, true),
            priority: 10
          });
        }
      }
    }

    // Same rainbow treatment for the ultraplan keyword
    if (feature('ULTRAPLAN')) {
      for (const trigger of ultraplanTriggers) {
        for (let i = trigger.start; i < trigger.end; i++) {
          highlights.push({
            start: i,
            end: i + 1,
            color: getRainbowColor(i - trigger.start),
            shimmerColor: getRainbowColor(i - trigger.start, true),
            priority: 10
          });
        }
      }
    }

    // Same rainbow treatment for the ultrareview keyword
    for (const trigger of ultrareviewTriggers) {
      for (let i = trigger.start; i < trigger.end; i++) {
        highlights.push({
          start: i,
          end: i + 1,
          color: getRainbowColor(i - trigger.start),
          shimmerColor: getRainbowColor(i - trigger.start, true),
          priority: 10
        });
      }
    }

    // Rainbow for /buddy
    for (const trigger of buddyTriggers) {
      for (let i = trigger.start; i < trigger.end; i++) {
        highlights.push({
          start: i,
          end: i + 1,
          color: getRainbowColor(i - trigger.start),
          shimmerColor: getRainbowColor(i - trigger.start, true),
          priority: 10
        });
      }
    }
    return highlights;
  }, [isSearchingHistory, historyQuery, historyMatch, historyFailedMatch, cursorOffset, btwTriggers, imageRefPositions, memberMentionHighlights, slashCommandTriggers, tokenBudgetTriggers, slackChannelTriggers, displayedValue, voiceInterimRange, thinkTriggers, ultraplanTriggers, ultrareviewTriggers, buddyTriggers]);
  const {
    addNotification,
    removeNotification
  } = useNotifications();

  // Show ultrathink notification
  useEffect(() => {
    if (thinkTriggers.length && isUltrathinkEnabled()) {
      addNotification({
        key: 'ultrathink-active',
        text: 'Effort set to high for this turn',
        priority: 'immediate',
        timeoutMs: 5000
      });
    } else {
      removeNotification('ultrathink-active');
    }
  }, [addNotification, removeNotification, thinkTriggers.length]);
  useEffect(() => {
    if (feature('ULTRAPLAN') && ultraplanTriggers.length) {
      addNotification({
        key: 'ultraplan-active',
        text: 'This prompt will launch an ultraplan session in Claude Code on the web',
        priority: 'immediate',
        timeoutMs: 5000
      });
    } else {
      removeNotification('ultraplan-active');
    }
  }, [addNotification, removeNotification, ultraplanTriggers.length]);
  useEffect(() => {
    if (isUltrareviewEnabled() && ultrareviewTriggers.length) {
      addNotification({
        key: 'ultrareview-active',
        text: 'Run /ultrareview after Claude finishes to review these changes in the cloud',
        priority: 'immediate',
        timeoutMs: 5000
      });
    }
  }, [addNotification, ultrareviewTriggers.length]);

  // Track input length for stash hint
  const prevInputLengthRef = useRef(input.length);
  const peakInputLengthRef = useRef(input.length);

  // Dismiss stash hint when user makes any input change
  const dismissStashHint = useCallback(() => {
    removeNotification('stash-hint');
  }, [removeNotification]);

  // Show stash hint when user gradually clears substantial input
  useEffect(() => {
    const prevLength = prevInputLengthRef.current;
    const peakLength = peakInputLengthRef.current;
    const currentLength = input.length;
    prevInputLengthRef.current = currentLength;

    // Update peak when input grows
    if (currentLength > peakLength) {
      peakInputLengthRef.current = currentLength;
      return;
    }

    // Reset state when input is empty
    if (currentLength === 0) {
      peakInputLengthRef.current = 0;
      return;
    }

    // Detect gradual clear: peak was high, current is low, but this wasn't a single big jump
    // (rapid clears like esc-esc go from 20+ to 0 in one step)
    const clearedSubstantialInput = peakLength >= 20 && currentLength <= 5;
    const wasRapidClear = prevLength >= 20 && currentLength <= 5;
    if (clearedSubstantialInput && !wasRapidClear) {
      const config = getGlobalConfig();
      if (!config.hasUsedStash) {
        addNotification({
          key: 'stash-hint',
          jsx: <Text dimColor>
              Tip:{' '}
              <ConfigurableShortcutHint action="chat:stash" context="Chat" fallback="ctrl+s" description="stash" />
            </Text>,
          priority: 'immediate',
          timeoutMs: FOOTER_TEMPORARY_STATUS_TIMEOUT
        });
      }
      peakInputLengthRef.current = currentLength;
    }
  }, [input.length, addNotification]);

  // Initialize input buffer for undo functionality
  const {
    pushToBuffer,
    undo,
    canUndo,
    clearBuffer
  } = useInputBuffer({
    maxBufferSize: 50,
    debounceMs: 1000
  });
  useMaybeTruncateInput({
    input,
    pastedContents,
    onInputChange: trackAndSetInput,
    setCursorOffset,
    setPastedContents
  });
  const defaultPlaceholder = usePromptInputPlaceholder({
    input,
    submitCount,
    viewingAgentName
  });
  const onChange = useCallback((value: string) => {
    if (value === '?') {
      logEvent('tengu_help_toggled', {});
      setHelpOpen(v => !v);
      return;
    }
    setHelpOpen(false);

    // Dismiss stash hint when user makes any input change
    dismissStashHint();

    // Cancel any pending prompt suggestion and speculation when user types
    abortPromptSuggestion();
    abortSpeculation(setAppState);

    // Check if this is a single character insertion at the start
    const isSingleCharInsertion = value.length === input.length + 1;
    const insertedAtStart = cursorOffset === 0;
    const mode = getModeFromInput(value);
    if (insertedAtStart && mode !== 'prompt') {
      if (isSingleCharInsertion) {
        onModeChange(mode);
        return;
      }
      // Multi-char insertion into empty input (e.g. tab-accepting "! gcloud auth login")
      if (input.length === 0) {
        onModeChange(mode);
        const valueWithoutMode = getValueFromInput(value).replaceAll('\t', '    ');
        pushToBuffer(input, cursorOffset, pastedContents);
        trackAndSetInput(valueWithoutMode);
        setCursorOffset(valueWithoutMode.length);
        return;
      }
    }
    const processedValue = value.replaceAll('\t', '    ');

    // Push current state to buffer before making changes
    if (input !== processedValue) {
      pushToBuffer(input, cursorOffset, pastedContents);
    }

    // Deselect footer items when user types
    setAppState(prev => prev.footerSelection === null ? prev : {
      ...prev,
      footerSelection: null
    });
    trackAndSetInput(processedValue);
  }, [trackAndSetInput, onModeChange, input, cursorOffset, pushToBuffer, pastedContents, dismissStashHint, setAppState]);
  const {
    resetHistory,
    onHistoryUp,
    onHistoryDown,
    dismissSearchHint,
    historyIndex
  } = useArrowKeyHistory((value: string, historyMode: HistoryMode, pastedContents: Record<number, PastedContent>) => {
    onChange(value);
    onModeChange(historyMode);
    setPastedContents(pastedContents);
  }, input, pastedContents, setCursorOffset, mode);

  // Dismiss search hint when user starts searching
  useEffect(() => {
    if (isSearchingHistory) {
      dismissSearchHint();
    }
  }, [isSearchingHistory, dismissSearchHint]);

  // Only use history navigation when there are 0 or 1 slash command suggestions.
  // Footer nav is NOT here — when a pill is selected, TextInput focus=false so
  // these never fire. The Footer keybinding context handles ↑/↓ instead.
  function handleHistoryUp() {
    if (suggestions.length > 1) {
      return;
    }

    // Only navigate history when cursor is on the first line.
    // In multiline inputs, up arrow should move the cursor (handled by TextInput)
    // and only trigger history when at the top of the input.
    if (!isCursorOnFirstLine) {
      return;
    }

    // If there's an editable queued command, move it to the input for editing when UP is pressed
    const hasEditableCommand = queuedCommands.some(isQueuedCommandEditable);
    if (hasEditableCommand) {
      void popAllCommandsFromQueue();
      return;
    }
    onHistoryUp();
  }
  function handleHistoryDown() {
    if (suggestions.length > 1) {
      return;
    }

    // Only navigate history/footer when cursor is on the last line.
    // In multiline inputs, down arrow should move the cursor (handled by TextInput)
    // and only trigger navigation when at the bottom of the input.
    if (!isCursorOnLastLine) {
      return;
    }

    // At bottom of history → enter footer at first visible pill
    if (onHistoryDown() && footerItems.length > 0) {
      const first = footerItems[0]!;
      selectFooterItem(first);
      if (first === 'tasks' && !getGlobalConfig().hasSeenTasksHint) {
        saveGlobalConfig(c => c.hasSeenTasksHint ? c : {
          ...c,
          hasSeenTasksHint: true
        });
      }
    }
  }

  // Create a suggestions state directly - we'll sync it with useTypeahead later
  const [suggestionsState, setSuggestionsStateRaw] = useState<{
    suggestions: SuggestionItem[];
    selectedSuggestion: number;
    commandArgumentHint?: string;
  }>({
    suggestions: [],
    selectedSuggestion: -1,
    commandArgumentHint: undefined
  });

  // Setter for suggestions state
  const setSuggestionsState = useCallback((updater: typeof suggestionsState | ((prev: typeof suggestionsState) => typeof suggestionsState)) => {
    setSuggestionsStateRaw(prev => typeof updater === 'function' ? updater(prev) : updater);
  }, []);
  const onSubmit = useCallback(async (inputParam: string, isSubmittingSlashCommand = false) => {
    inputParam = inputParam.trimEnd();

    // Don't submit if a footer indicator is being opened. Read fresh from
    // store — footer:openSelected calls selectFooterItem(null) then onSubmit
    // in the same tick, and the closure value hasn't updated yet. Apply the
    // same "still visible?" derivation as footerItemSelected so a stale
    // selection (pill disappeared) doesn't swallow Enter.
    const state = store.getState();
    if (state.footerSelection && footerItems.includes(state.footerSelection)) {
      return;
    }

    // Enter in selection modes confirms selection (useBackgroundTaskNavigation).
    // BaseTextInput's useInput registers before that hook (child effects fire first),
    // so without this guard Enter would double-fire and auto-submit the suggestion.
    if (state.viewSelectionMode === 'selecting-agent') {
      return;
    }

    // Check for images early - we need this for suggestion logic below
    const hasImages = Object.values(pastedContents).some(c => c.type === 'image');

    // If input is empty OR matches the suggestion, submit it
    // But if there are images attached, don't auto-accept the suggestion -
    // the user wants to submit just the image(s).
    // Only in leader view — promptSuggestion is leader-context, not teammate.
    const suggestionText = promptSuggestionState.text;
    const inputMatchesSuggestion = inputParam.trim() === '' || inputParam === suggestionText;
    if (inputMatchesSuggestion && suggestionText && !hasImages && !state.viewingAgentTaskId) {
      // If speculation is active, inject messages immediately as they stream
      if (speculation.status === 'active') {
        markAccepted();
        // skipReset: resetSuggestion would abort the speculation before we accept it
        logOutcomeAtSubmission(suggestionText, {
          skipReset: true
        });
        void onSubmitProp(suggestionText, {
          setCursorOffset,
          clearBuffer,
          resetHistory
        }, {
          state: speculation,
          speculationSessionTimeSavedMs: speculationSessionTimeSavedMs,
          setAppState
        });
        return; // Skip normal query - speculation handled it
      }

      // Regular suggestion acceptance (requires shownAt > 0)
      if (promptSuggestionState.shownAt > 0) {
        markAccepted();
        inputParam = suggestionText;
      }
    }

    // Handle @name direct message
    if (isAgentSwarmsEnabled()) {
      const directMessage = parseDirectMemberMessage(inputParam);
      if (directMessage) {
        const result = await sendDirectMemberMessage(directMessage.recipientName, directMessage.message, teamContext, writeToMailbox);
        if (result.success) {
          addNotification({
            key: 'direct-message-sent',
            text: `Sent to @${result.recipientName}`,
            priority: 'immediate',
            timeoutMs: 3000
          });
          trackAndSetInput('');
          setCursorOffset(0);
          clearBuffer();
          resetHistory();
          return;
        } else if ('error' in result && result.error === 'no_team_context') {
          // No team context - fall through to normal prompt submission
        } else {
          // Unknown recipient - fall through to normal prompt submission
          // This allows e.g. "@utils explain this code" to be sent as a prompt
        }
      }
    }

    // Allow submission if there are images attached, even without text
    if (inputParam.trim() === '' && !hasImages) {
      return;
    }

    // PromptInput UX: Check if suggestions dropdown is showing
    // For directory suggestions, allow submission (Tab is used for completion)
    const hasDirectorySuggestions = suggestionsState.suggestions.length > 0 && suggestionsState.suggestions.every(s => s.description === 'directory');
    if (suggestionsState.suggestions.length > 0 && !isSubmittingSlashCommand && !hasDirectorySuggestions) {
      logForDebugging(`[onSubmit] early return: suggestions showing (count=${suggestionsState.suggestions.length})`);
      return; // Don't submit, user needs to clear suggestions first
    }

    // Log suggestion outcome if one exists
    if (promptSuggestionState.text && promptSuggestionState.shownAt > 0) {
      logOutcomeAtSubmission(inputParam);
    }

    // Clear stash hint notification on submit
    removeNotification('stash-hint');

    // Route input to viewed agent (in-process teammate or named local_agent).
    const activeAgent = getActiveAgentForInput(store.getState());
    if (activeAgent.type !== 'leader' && onAgentSubmit) {
      logEvent('tengu_transcript_input_to_teammate', {});
      await onAgentSubmit(inputParam, activeAgent.task, {
        setCursorOffset,
        clearBuffer,
        resetHistory
      });
      return;
    }

    // Normal leader submission
    await onSubmitProp(inputParam, {
      setCursorOffset,
      clearBuffer,
      resetHistory
    });
  }, [promptSuggestionState, speculation, speculationSessionTimeSavedMs, teamContext, store, footerItems, suggestionsState.suggestions, onSubmitProp, onAgentSubmit, clearBuffer, resetHistory, logOutcomeAtSubmission, setAppState, markAccepted, pastedContents, removeNotification]);
  const {
    suggestions,
    selectedSuggestion,
    commandArgumentHint,
    inlineGhostText,
    maxColumnWidth
  } = useTypeahead({
    commands,
    onInputChange: trackAndSetInput,
    onSubmit,
    setCursorOffset,
    input,
    cursorOffset,
    mode,
    agents,
    setSuggestionsState,
    suggestionsState,
    suppressSuggestions: isSearchingHistory || historyIndex > 0,
    markAccepted,
    onModeChange
  });

  // Track if prompt suggestion should be shown (computed later with terminal width).
  // Hidden in teammate view — suggestion is leader-context only.
  const showPromptSuggestion = mode === 'prompt' && suggestions.length === 0 && promptSuggestion && !viewingAgentTaskId;
  if (showPromptSuggestion) {
    markShown();
  }

  // If suggestion was generated but can't be shown due to timing, log suppression.
  // Exclude teammate view: markShown() is gated above, so shownAt stays 0 there —
  // but that's not a timing failure, the suggestion is valid when returning to leader.
  if (promptSuggestionState.text && !promptSuggestion && promptSuggestionState.shownAt === 0 && !viewingAgentTaskId) {
    logSuggestionSuppressed('timing', promptSuggestionState.text);
    setAppState(prev => ({
      ...prev,
      promptSuggestion: {
        text: null,
        promptId: null,
        shownAt: 0,
        acceptedAt: 0,
        generationRequestId: null
      }
    }));
  }
  function onImagePaste(image: string, mediaType?: string, filename?: string, dimensions?: ImageDimensions, sourcePath?: string) {
    logEvent('tengu_paste_image', {});
    onModeChange('prompt');
    const pasteId = nextPasteIdRef.current++;
    const newContent: PastedContent = {
      id: pasteId,
      type: 'image',
      content: image,
      mediaType: mediaType || 'image/png',
      // default to PNG if not provided
      filename: filename || 'Pasted image',
      dimensions,
      sourcePath
    };

    // Cache path immediately (fast) so links work on render
    cacheImagePath(newContent);

    // Store image to disk in background
    void storeImage(newContent);

    // Update UI
    setPastedContents(prev => ({
      ...prev,
      [pasteId]: newContent
    }));
    // Multi-image paste calls onImagePaste in a loop. If the ref is already
    // armed, the previous pill's lazy space fires now (before this pill)
    // rather than being lost.
    const prefix = pendingSpaceAfterPillRef.current ? ' ' : '';
    insertTextAtCursor(prefix + formatImageRef(pasteId));
    pendingSpaceAfterPillRef.current = true;
  }

  // Prune images whose [Image #N] placeholder is no longer in the input text.
  // Covers pill backspace, Ctrl+U, char-by-char deletion — any edit that drops
  // the ref. onImagePaste batches setPastedContents + insertTextAtCursor in the
  // same event, so this effect sees the placeholder already present.
  useEffect(() => {
    const referencedIds = new Set(parseReferences(input).map(r => r.id));
    setPastedContents(prev => {
      const orphaned = Object.values(prev).filter(c => c.type === 'image' && !referencedIds.has(c.id));
      if (orphaned.length === 0) return prev;
      const next = {
        ...prev
      };
      for (const img of orphaned) delete next[img.id];
      return next;
    });
  }, [input, setPastedContents]);
  function onTextPaste(rawText: string) {
    pendingSpaceAfterPillRef.current = false;
    // Clean up pasted text - strip ANSI escape codes and normalize line endings and tabs
    let text = stripAnsi(rawText).replace(/\r/g, '\n').replaceAll('\t', '    ');

    // Match typed/auto-suggest: `!cmd` pasted into empty input enters bash mode.
    if (input.length === 0) {
      const pastedMode = getModeFromInput(text);
      if (pastedMode !== 'prompt') {
        onModeChange(pastedMode);
        text = getValueFromInput(text);
      }
    }
    const numLines = getPastedTextRefNumLines(text);
    // Limit the number of lines to show in the input
    // If the overall layout is too high then Ink will repaint
    // the entire terminal.
    // The actual required height is dependent on the content, this
    // is just an estimate.
    const maxLines = Math.min(rows - 10, 2);

    // Use special handling for long pasted text (>PASTE_THRESHOLD chars)
    // or if it exceeds the number of lines we want to show
    if (text.length > PASTE_THRESHOLD || numLines > maxLines) {
      const pasteId = nextPasteIdRef.current++;
      const newContent: PastedContent = {
        id: pasteId,
        type: 'text',
        content: text
      };
      setPastedContents(prev => ({
        ...prev,
        [pasteId]: newContent
      }));
      insertTextAtCursor(formatPastedTextRef(pasteId, numLines));
    } else {
      // For shorter pastes, just insert the text normally
      insertTextAtCursor(text);
    }
  }
  const lazySpaceInputFilter = useCallback((input: string, key: Key): string => {
    if (!pendingSpaceAfterPillRef.current) return input;
    pendingSpaceAfterPillRef.current = false;
    if (isNonSpacePrintable(input, key)) return ' ' + input;
    return input;
  }, []);
  function insertTextAtCursor(text: string) {
    // Push current state to buffer before inserting
    pushToBuffer(input, cursorOffset, pastedContents);
    const newInput = input.slice(0, cursorOffset) + text + input.slice(cursorOffset);
    trackAndSetInput(newInput);
    setCursorOffset(cursorOffset + text.length);
  }
  const doublePressEscFromEmpty = useDoublePress(() => {}, () => onShowMessageSelector());

  // Function to get the queued command for editing. Returns true if commands were popped.
  const popAllCommandsFromQueue = useCallback((): boolean => {
    const result = popAllEditable(input, cursorOffset);
    if (!result) {
      return false;
    }
    trackAndSetInput(result.text);
    onModeChange('prompt'); // Always prompt mode for queued commands
    setCursorOffset(result.cursorOffset);

    // Restore images from queued commands to pastedContents
    if (result.images.length > 0) {
      setPastedContents(prev => {
        const newContents = {
          ...prev
        };
        for (const image of result.images) {
          newContents[image.id] = image;
        }
        return newContents;
      });
    }
    return true;
  }, [trackAndSetInput, onModeChange, input, cursorOffset, setPastedContents]);

  // Insert the at-mentioned reference (the file and, optionally, a line range) when
  // we receive an at-mentioned notification the IDE.
  const onIdeAtMentioned = function (atMentioned: IDEAtMentioned) {
    logEvent('tengu_ext_at_mentioned', {});
    let atMentionedText: string;
    const relativePath = path.relative(getCwd(), atMentioned.filePath);
    if (atMentioned.lineStart && atMentioned.lineEnd) {
      atMentionedText = atMentioned.lineStart === atMentioned.lineEnd ? `@${relativePath}#L${atMentioned.lineStart} ` : `@${relativePath}#L${atMentioned.lineStart}-${atMentioned.lineEnd} `;
    } else {
      atMentionedText = `@${relativePath} `;
    }
    const cursorChar = input[cursorOffset - 1] ?? ' ';
    if (!/\s/.test(cursorChar)) {
      atMentionedText = ` ${atMentionedText}`;
    }
    insertTextAtCursor(atMentionedText);
  };
  useIdeAtMentioned(mcpClients, onIdeAtMentioned);

  // Handler for chat:undo - undo last edit
  const handleUndo = useCallback(() => {
    if (canUndo) {
      const previousState = undo();
      if (previousState) {
        trackAndSetInput(previousState.text);
        setCursorOffset(previousState.cursorOffset);
        setPastedContents(previousState.pastedContents);
      }
    }
  }, [canUndo, undo, trackAndSetInput, setPastedContents]);

  // Handler for chat:newline - insert a newline at the cursor position
  const handleNewline = useCallback(() => {
    pushToBuffer(input, cursorOffset, pastedContents);
    const newInput = input.slice(0, cursorOffset) + '\n' + input.slice(cursorOffset);
    trackAndSetInput(newInput);
    setCursorOffset(cursorOffset + 1);
  }, [input, cursorOffset, trackAndSetInput, setCursorOffset, pushToBuffer, pastedContents]);

  // Handler for chat:externalEditor - edit in $EDITOR
  const handleExternalEditor = useCallback(async () => {
    logEvent('tengu_external_editor_used', {});
    setIsExternalEditorActive(true);
    try {
      // Pass pastedContents to expand collapsed text references
      const result = await editPromptInEditor(input, pastedContents);
      if (result.error) {
        addNotification({
          key: 'external-editor-error',
          text: result.error,
          color: 'warning',
          priority: 'high'
        });
      }
      if (result.content !== null && result.content !== input) {
        // Push current state to buffer before making changes
        pushToBuffer(input, cursorOffset, pastedContents);
        trackAndSetInput(result.content);
        setCursorOffset(result.content.length);
      }
    } catch (err) {
      if (err instanceof Error) {
        logError(err);
      }
      addNotification({
        key: 'external-editor-error',
        text: `External editor failed: ${errorMessage(err)}`,
        color: 'warning',
        priority: 'high'
      });
    } finally {
      setIsExternalEditorActive(false);
    }
  }, [input, cursorOffset, pastedContents, pushToBuffer, trackAndSetInput, addNotification]);

  // Handler for chat:stash - stash/unstash prompt
  const handleStash = useCallback(() => {
    if (input.trim() === '' && stashedPrompt !== undefined) {
      // Pop stash when input is empty
      trackAndSetInput(stashedPrompt.text);
      setCursorOffset(stashedPrompt.cursorOffset);
      setPastedContents(stashedPrompt.pastedContents);
      setStashedPrompt(undefined);
    } else if (input.trim() !== '') {
      // Push to stash (save text, cursor position, and pasted contents)
      setStashedPrompt({
        text: input,
        cursorOffset,
        pastedContents
      });
      trackAndSetInput('');
      setCursorOffset(0);
      setPastedContents({});
      // Track usage for /discover and stop showing hint
      saveGlobalConfig(c => {
        if (c.hasUsedStash) return c;
        return {
          ...c,
          hasUsedStash: true
        };
      });
    }
  }, [input, cursorOffset, stashedPrompt, trackAndSetInput, setStashedPrompt, pastedContents, setPastedContents]);

  // Handler for chat:modelPicker - toggle model picker
  const handleModelPicker = useCallback(() => {
    setShowModelPicker(prev => !prev);
    if (helpOpen) {
      setHelpOpen(false);
    }
  }, [helpOpen]);

  // Handler for chat:fastMode - toggle fast mode picker
  const handleFastModePicker = useCallback(() => {
    setShowFastModePicker(prev => !prev);
    if (helpOpen) {
      setHelpOpen(false);
    }
  }, [helpOpen]);

  // Handler for chat:thinkingToggle - toggle thinking mode
  const handleThinkingToggle = useCallback(() => {
    setShowThinkingToggle(prev => !prev);
    if (helpOpen) {
      setHelpOpen(false);
    }
  }, [helpOpen]);

  // Handler for chat:cycleMode - cycle through permission modes
  const handleCycleMode = useCallback(() => {
    // When viewing a teammate, cycle their mode instead of the leader's
    if (isAgentSwarmsEnabled() && viewedTeammate && viewingAgentTaskId) {
      const teammateContext: ToolPermissionContext = {
        ...toolPermissionContext,
        mode: viewedTeammate.permissionMode
      };
      // Pass undefined for teamContext (unused but kept for API compatibility)
      const nextMode = getNextPermissionMode(teammateContext, undefined);
      logEvent('tengu_mode_cycle', {
        to: nextMode as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
      });
      const teammateTaskId = viewingAgentTaskId;
      setAppState(prev => {
        const task = prev.tasks[teammateTaskId];
        if (!task || task.type !== 'in_process_teammate') {
          return prev;
        }
        if (task.permissionMode === nextMode) {
          return prev;
        }
        return {
          ...prev,
          tasks: {
            ...prev.tasks,
            [teammateTaskId]: {
              ...task,
              permissionMode: nextMode
            }
          }
        };
      });
      if (helpOpen) {
        setHelpOpen(false);
      }
      return;
    }

    // Compute the next mode without triggering side effects first
    logForDebugging(`[auto-mode] handleCycleMode: currentMode=${toolPermissionContext.mode} isAutoModeAvailable=${toolPermissionContext.isAutoModeAvailable} showAutoModeOptIn=${showAutoModeOptIn} timeoutPending=${!!autoModeOptInTimeoutRef.current}`);
    const nextMode = getNextPermissionMode(toolPermissionContext, teamContext);

    // Check if user is entering auto mode for the first time. Gated on the
    // persistent settings flag (hasAutoModeOptIn) rather than the broader
    // hasAutoModeOptInAnySource so that --enable-auto-mode users still see
    // the warning dialog once — the CLI flag should grant carousel access,
    // not bypass the safety text.
    let isEnteringAutoModeFirstTime = false;
    if (feature('TRANSCRIPT_CLASSIFIER')) {
      isEnteringAutoModeFirstTime = nextMode === 'auto' && toolPermissionContext.mode !== 'auto' && !hasAutoModeOptIn() && !viewingAgentTaskId; // Only show for primary agent, not subagents
    }
    if (feature('TRANSCRIPT_CLASSIFIER')) {
      if (isEnteringAutoModeFirstTime) {
        // Store previous mode so we can revert if user declines
        setPreviousModeBeforeAuto(toolPermissionContext.mode);

        // Only update the UI mode label — do NOT call transitionPermissionMode
        // or cyclePermissionMode yet; we haven't confirmed with the user.
        setAppState(prev => ({
          ...prev,
          toolPermissionContext: {
            ...prev.toolPermissionContext,
            mode: 'auto'
          }
        }));
        setToolPermissionContext({
          ...toolPermissionContext,
          mode: 'auto'
        });

        // Show opt-in dialog after 400ms debounce
        if (autoModeOptInTimeoutRef.current) {
          clearTimeout(autoModeOptInTimeoutRef.current);
        }
        autoModeOptInTimeoutRef.current = setTimeout((setShowAutoModeOptIn, autoModeOptInTimeoutRef) => {
          setShowAutoModeOptIn(true);
          autoModeOptInTimeoutRef.current = null;
        }, 400, setShowAutoModeOptIn, autoModeOptInTimeoutRef);
        if (helpOpen) {
          setHelpOpen(false);
        }
        return;
      }
    }

    // Dismiss auto mode opt-in dialog if showing or pending (user is cycling away).
    // Do NOT revert to previousModeBeforeAuto here — shift+tab means "advance the
    // carousel", not "decline". Reverting causes a ping-pong loop: auto reverts to
    // the prior mode, whose next mode is auto again, forever.
    // The dialog's own decline button (handleAutoModeOptInDecline) handles revert.
    if (feature('TRANSCRIPT_CLASSIFIER')) {
      if (showAutoModeOptIn || autoModeOptInTimeoutRef.current) {
        if (showAutoModeOptIn) {
          logEvent('tengu_auto_mode_opt_in_dialog_decline', {});
        }
        setShowAutoModeOptIn(false);
        if (autoModeOptInTimeoutRef.current) {
          clearTimeout(autoModeOptInTimeoutRef.current);
          autoModeOptInTimeoutRef.current = null;
        }
        setPreviousModeBeforeAuto(null);
        // Fall through — mode is 'auto', cyclePermissionMode below goes to 'default'.
      }
    }

    // Now that we know this is NOT the first-time auto mode path,
    // call cyclePermissionMode to apply side effects (e.g. strip
    // dangerous permissions, activate classifier)
    const {
      context: preparedContext
    } = cyclePermissionMode(toolPermissionContext, teamContext);
    logEvent('tengu_mode_cycle', {
      to: nextMode as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
    });

    // Track when user enters plan mode
    if (nextMode === 'plan') {
      saveGlobalConfig(current => ({
        ...current,
        lastPlanModeUse: Date.now()
      }));
    }

    // Set the mode via setAppState directly because setToolPermissionContext
    // intentionally preserves the existing mode (to prevent coordinator mode
    // corruption from workers). Then call setToolPermissionContext to trigger
    // recheck of queued permission prompts.
    setAppState(prev => ({
      ...prev,
      toolPermissionContext: {
        ...preparedContext,
        mode: nextMode
      }
    }));
    setToolPermissionContext({
      ...preparedContext,
      mode: nextMode
    });

    // If this is a teammate, update config.json so team lead sees the change
    syncTeammateMode(nextMode, teamContext?.teamName);

    // Close help tips if they're open when mode is cycled
    if (helpOpen) {
      setHelpOpen(false);
    }
  }, [toolPermissionContext, teamContext, viewingAgentTaskId, viewedTeammate, setAppState, setToolPermissionContext, helpOpen, showAutoModeOptIn]);

  // Handler for auto mode opt-in dialog acceptance
  const handleAutoModeOptInAccept = useCallback(() => {
    if (feature('TRANSCRIPT_CLASSIFIER')) {
      setShowAutoModeOptIn(false);
      setPreviousModeBeforeAuto(null);

      // Now that the user accepted, apply the full transition: activate the
      // auto mode backend (classifier, beta headers) and strip dangerous
      // permissions (e.g. Bash(*) always-allow rules).
      const strippedContext = transitionPermissionMode(previousModeBeforeAuto ?? toolPermissionContext.mode, 'auto', toolPermissionContext);
      setAppState(prev => ({
        ...prev,
        toolPermissionContext: {
          ...strippedContext,
          mode: 'auto'
        }
      }));
      setToolPermissionContext({
        ...strippedContext,
        mode: 'auto'
      });

      // Close help tips if they're open when auto mode is enabled
      if (helpOpen) {
        setHelpOpen(false);
      }
    }
  }, [helpOpen, setHelpOpen, previousModeBeforeAuto, toolPermissionContext, setAppState, setToolPermissionContext]);

  // Handler for auto mode opt-in dialog decline
  const handleAutoModeOptInDecline = useCallback(() => {
    if (feature('TRANSCRIPT_CLASSIFIER')) {
      logForDebugging(`[auto-mode] handleAutoModeOptInDecline: reverting to ${previousModeBeforeAuto}, setting isAutoModeAvailable=false`);
      setShowAutoModeOptIn(false);
      if (autoModeOptInTimeoutRef.current) {
        clearTimeout(autoModeOptInTimeoutRef.current);
        autoModeOptInTimeoutRef.current = null;
      }

      // Revert to previous mode and remove auto from the carousel
      // for the rest of this session
      if (previousModeBeforeAuto) {
        setAutoModeActive(false);
        setAppState(prev => ({
          ...prev,
          toolPermissionContext: {
            ...prev.toolPermissionContext,
            mode: previousModeBeforeAuto,
            isAutoModeAvailable: false
          }
        }));
        setToolPermissionContext({
          ...toolPermissionContext,
          mode: previousModeBeforeAuto,
          isAutoModeAvailable: false
        });
        setPreviousModeBeforeAuto(null);
      }
    }
  }, [previousModeBeforeAuto, toolPermissionContext, setAppState, setToolPermissionContext]);

  // Handler for chat:imagePaste - paste image from clipboard
  const handleImagePaste = useCallback(() => {
    void getImageFromClipboard().then(imageData => {
      if (imageData) {
        onImagePaste(imageData.base64, imageData.mediaType);
      } else {
        const shortcutDisplay = getShortcutDisplay('chat:imagePaste', 'Chat', 'ctrl+v');
        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.`;
        addNotification({
          key: 'no-image-in-clipboard',
          text: message,
          priority: 'immediate',
          timeoutMs: 1000
        });
      }
    });
  }, [addNotification, onImagePaste]);

  // Register chat:submit handler directly in the handler registry (not via
  // useKeybindings) so that only the ChordInterceptor can invoke it for chord
  // completions (e.g., "ctrl+e s"). The default Enter binding for submit is
  // handled by TextInput directly (via onSubmit prop) and useTypeahead (for
  // autocomplete acceptance). Using useKeybindings would cause
  // stopImmediatePropagation on Enter, blocking autocomplete from seeing the key.
  const keybindingContext = useOptionalKeybindingContext();
  useEffect(() => {
    if (!keybindingContext || isModalOverlayActive) return;
    return keybindingContext.registerHandler({
      action: 'chat:submit',
      context: 'Chat',
      handler: () => {
        void onSubmit(input);
      }
    });
  }, [keybindingContext, isModalOverlayActive, onSubmit, input]);

  // Chat context keybindings for editing shortcuts
  // Note: history:previous/history:next are NOT handled here. They are passed as
  // onHistoryUp/onHistoryDown props to TextInput, so that useTextInput's
  // upOrHistoryUp/downOrHistoryDown can try cursor movement first and only
  // fall through to history when the cursor can't move further.
  const chatHandlers = useMemo(() => ({
    'chat:undo': handleUndo,
    'chat:newline': handleNewline,
    'chat:externalEditor': handleExternalEditor,
    'chat:stash': handleStash,
    'chat:modelPicker': handleModelPicker,
    'chat:thinkingToggle': handleThinkingToggle,
    'chat:cycleMode': handleCycleMode,
    'chat:imagePaste': handleImagePaste
  }), [handleUndo, handleNewline, handleExternalEditor, handleStash, handleModelPicker, handleThinkingToggle, handleCycleMode, handleImagePaste]);
  useKeybindings(chatHandlers, {
    context: 'Chat',
    isActive: !isModalOverlayActive
  });

  // Shift+↑ enters message-actions cursor. Separate isActive so ctrl+r search
  // doesn't leave stale isSearchingHistory on cursor-exit remount.
  useKeybinding('chat:messageActions', () => onMessageActionsEnter?.(), {
    context: 'Chat',
    isActive: !isModalOverlayActive && !isSearchingHistory
  });

  // Fast mode keybinding is only active when fast mode is enabled and available
  useKeybinding('chat:fastMode', handleFastModePicker, {
    context: 'Chat',
    isActive: !isModalOverlayActive && isFastModeEnabled() && isFastModeAvailable()
  });

  // Handle help:dismiss keybinding (ESC closes help menu)
  // This is registered separately from Chat context so it has priority over
  // CancelRequestHandler when help menu is open
  useKeybinding('help:dismiss', () => {
    setHelpOpen(false);
  }, {
    context: 'Help',
    isActive: helpOpen
  });

  // Quick Open / Global Search. Hook calls are unconditional (Rules of Hooks);
  // the handler body is feature()-gated so the setState calls and component
  // references get tree-shaken in external builds.
  const quickSearchActive = feature('QUICK_SEARCH') ? !isModalOverlayActive : false;
  useKeybinding('app:quickOpen', () => {
    if (feature('QUICK_SEARCH')) {
      setShowQuickOpen(true);
      setHelpOpen(false);
    }
  }, {
    context: 'Global',
    isActive: quickSearchActive
  });
  useKeybinding('app:globalSearch', () => {
    if (feature('QUICK_SEARCH')) {
      setShowGlobalSearch(true);
      setHelpOpen(false);
    }
  }, {
    context: 'Global',
    isActive: quickSearchActive
  });
  useKeybinding('history:search', () => {
    if (feature('HISTORY_PICKER')) {
      setShowHistoryPicker(true);
      setHelpOpen(false);
    }
  }, {
    context: 'Global',
    isActive: feature('HISTORY_PICKER') ? !isModalOverlayActive : false
  });

  // Handle Ctrl+C to abort speculation when idle (not loading)
  // CancelRequestHandler only handles Ctrl+C during active tasks
  useKeybinding('app:interrupt', () => {
    abortSpeculation(setAppState);
  }, {
    context: 'Global',
    isActive: !isLoading && speculation.status === 'active'
  });

  // Footer indicator navigation keybindings. ↑/↓ live here (not in
  // handleHistoryUp/Down) because TextInput focus=false when a pill is
  // selected — its useInput is inactive, so this is the only path.
  useKeybindings({
    'footer:up': () => {
      // ↑ scrolls within the coordinator task list before leaving the pill
      if (tasksSelected && ("external" as string) === 'ant' && coordinatorTaskCount > 0 && coordinatorTaskIndex > minCoordinatorIndex) {
        setCoordinatorTaskIndex(prev => prev - 1);
        return;
      }
      navigateFooter(-1, true);
    },
    'footer:down': () => {
      // ↓ scrolls within the coordinator task list, never leaves the pill
      if (tasksSelected && ("external" as string) === 'ant' && coordinatorTaskCount > 0) {
        if (coordinatorTaskIndex < coordinatorTaskCount - 1) {
          setCoordinatorTaskIndex(prev => prev + 1);
        }
        return;
      }
      if (tasksSelected && !isTeammateMode) {
        setShowBashesDialog(true);
        selectFooterItem(null);
        return;
      }
      navigateFooter(1);
    },
    'footer:next': () => {
      // Teammate mode: ←/→ cycles within the team member list
      if (tasksSelected && isTeammateMode) {
        const totalAgents = 1 + inProcessTeammates.length;
        setTeammateFooterIndex(prev => (prev + 1) % totalAgents);
        return;
      }
      navigateFooter(1);
    },
    'footer:previous': () => {
      if (tasksSelected && isTeammateMode) {
        const totalAgents = 1 + inProcessTeammates.length;
        setTeammateFooterIndex(prev => (prev - 1 + totalAgents) % totalAgents);
        return;
      }
      navigateFooter(-1);
    },
    'footer:openSelected': () => {
      if (viewSelectionMode === 'selecting-agent') {
        return;
      }
      switch (footerItemSelected) {
        case 'companion':
          if (feature('BUDDY')) {
            selectFooterItem(null);
            void onSubmit('/buddy');
          }
          break;
        case 'tasks':
          if (isTeammateMode) {
            // Enter switches to the selected agent's view
            if (teammateFooterIndex === 0) {
              exitTeammateView(setAppState);
            } else {
              const teammate = inProcessTeammates[teammateFooterIndex - 1];
              if (teammate) enterTeammateView(teammate.id, setAppState);
            }
          } else if (coordinatorTaskIndex === 0 && coordinatorTaskCount > 0) {
            exitTeammateView(setAppState);
          } else {
            const selectedTaskId = getVisibleAgentTasks(tasks)[coordinatorTaskIndex - 1]?.id;
            if (selectedTaskId) {
              enterTeammateView(selectedTaskId, setAppState);
            } else {
              setShowBashesDialog(true);
              selectFooterItem(null);
            }
          }
          break;
        case 'tmux':
          if (("external" as string) === 'ant') {
            setAppState(prev => prev.tungstenPanelAutoHidden ? {
              ...prev,
              tungstenPanelAutoHidden: false
            } : {
              ...prev,
              tungstenPanelVisible: !(prev.tungstenPanelVisible ?? true)
            });
          }
          break;
        case 'bagel':
          break;
        case 'teams':
          setShowTeamsDialog(true);
          selectFooterItem(null);
          break;
        case 'bridge':
          setShowBridgeDialog(true);
          selectFooterItem(null);
          break;
      }
    },
    'footer:clearSelection': () => {
      selectFooterItem(null);
    },
    'footer:close': () => {
      if (tasksSelected && coordinatorTaskIndex >= 1) {
        const task = getVisibleAgentTasks(tasks)[coordinatorTaskIndex - 1];
        if (!task) return false;
        // When the selected row IS the viewed agent, 'x' types into the
        // steering input. Any other row — dismiss it.
        if (viewSelectionMode === 'viewing-agent' && task.id === viewingAgentTaskId) {
          onChange(input.slice(0, cursorOffset) + 'x' + input.slice(cursorOffset));
          setCursorOffset(cursorOffset + 1);
          return;
        }
        stopOrDismissAgent(task.id, setAppState);
        if (task.status !== 'running') {
          setCoordinatorTaskIndex(i => Math.max(minCoordinatorIndex, i - 1));
        }
        return;
      }
      // Not handled — let 'x' fall through to type-to-exit
      return false;
    }
  }, {
    context: 'Footer',
    isActive: !!footerItemSelected && !isModalOverlayActive
  });
  useInput((char, key) => {
    // Skip all input handling when a full-screen dialog is open. These dialogs
    // render via early return, but hooks run unconditionally — so without this
    // guard, Escape inside a dialog leaks to the double-press message-selector.
    if (showTeamsDialog || showQuickOpen || showGlobalSearch || showHistoryPicker) {
      return;
    }

    // Detect failed Alt shortcuts on macOS (Option key produces special characters)
    if (getPlatform() === 'macos' && isMacosOptionChar(char)) {
      const shortcut = MACOS_OPTION_SPECIAL_CHARS[char];
      const terminalName = getNativeCSIuTerminalDisplayName();
      const jsx = terminalName ? <Text dimColor>
          To enable {shortcut}, set <Text bold>Option as Meta</Text> in{' '}
          {terminalName} preferences (⌘,)
        </Text> : <Text dimColor>To enable {shortcut}, run /terminal-setup</Text>;
      addNotification({
        key: 'option-meta-hint',
        jsx,
        priority: 'immediate',
        timeoutMs: 5000
      });
      // Don't return - let the character be typed so user sees the issue
    }

    // Footer navigation is handled via useKeybindings above (Footer context)

    // NOTE: ctrl+_, ctrl+g, ctrl+s are handled via Chat context keybindings above

    // Type-to-exit footer: printable chars while a pill is selected refocus
    // the input and type the char. Nav keys are captured by useKeybindings
    // above, so anything reaching here is genuinely not a footer action.
    // onChange clears footerSelection, so no explicit deselect.
    if (footerItemSelected && char && !key.ctrl && !key.meta && !key.escape && !key.return) {
      onChange(input.slice(0, cursorOffset) + char + input.slice(cursorOffset));
      setCursorOffset(cursorOffset + char.length);
      return;
    }

    // Exit special modes when backspace/escape/delete/ctrl+u is pressed at cursor position 0
    if (cursorOffset === 0 && (key.escape || key.backspace || key.delete || key.ctrl && char === 'u')) {
      onModeChange('prompt');
      setHelpOpen(false);
    }

    // Exit help mode when backspace is pressed and input is empty
    if (helpOpen && input === '' && (key.backspace || key.delete)) {
      setHelpOpen(false);
    }

    // esc is a little overloaded:
    // - when we're loading a response, it's used to cancel the request
    // - otherwise, it's used to show the message selector
    // - when double pressed, it's used to clear the input
    // - when input is empty, pop from command queue

    // Handle ESC key press
    if (key.escape) {
      // Abort active speculation
      if (speculation.status === 'active') {
        abortSpeculation(setAppState);
        return;
      }

      // Dismiss side question response if visible
      if (isSideQuestionVisible && onDismissSideQuestion) {
        onDismissSideQuestion();
        return;
      }

      // Close help menu if open
      if (helpOpen) {
        setHelpOpen(false);
        return;
      }

      // Footer selection clearing is now handled via Footer context keybindings
      // (footer:clearSelection action bound to escape)
      // If a footer item is selected, let the Footer keybinding handle it
      if (footerItemSelected) {
        return;
      }

      // If there's an editable queued command, move it to the input for editing when ESC is pressed
      const hasEditableCommand = queuedCommands.some(isQueuedCommandEditable);
      if (hasEditableCommand) {
        void popAllCommandsFromQueue();
        return;
      }
      if (messages.length > 0 && !input && !isLoading) {
        doublePressEscFromEmpty();
      }
    }
    if (key.return && helpOpen) {
      setHelpOpen(false);
    }
  });
  const swarmBanner = useSwarmBanner();
  const fastModeCooldown = isFastModeEnabled() ? isFastModeCooldown() : false;
  const showFastIcon = isFastModeEnabled() ? isFastMode && (isFastModeAvailable() || fastModeCooldown) : false;
  const showFastIconHint = useShowFastIconHint(showFastIcon ?? false);

  // Show effort notification on startup and when effort changes.
  // Suppressed in brief/assistant mode — the value reflects the local
  // client's effort, not the connected agent's.
  const effortNotificationText = briefOwnsGap ? undefined : getEffortNotificationText(effortValue, mainLoopModel);
  useEffect(() => {
    if (!effortNotificationText) {
      removeNotification('effort-level');
      return;
    }
    addNotification({
      key: 'effort-level',
      text: effortNotificationText,
      priority: 'high',
      timeoutMs: 12_000
    });
  }, [effortNotificationText, addNotification, removeNotification]);
  useBuddyNotification();
  const companionSpeaking = feature('BUDDY') ?
  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
  useAppState(s => s.companionReaction !== undefined) : false;
  const {
    columns,
    rows
  } = useTerminalSize();
  const textInputColumns = columns - 3 - companionReservedColumns(columns, companionSpeaking);

  // POC: click-to-position-cursor. Mouse tracking is only enabled inside
  // <AlternateScreen>, so this is dormant in the normal main-screen REPL.
  // localCol/localRow are relative to the onClick Box's top-left; the Box
  // tightly wraps the text input so they map directly to (column, line)
  // in the Cursor wrap model. MeasuredText.getOffsetFromPosition handles
  // wide chars, wrapped lines, and clamps past-end clicks to line end.
  const maxVisibleLines = isFullscreenEnvEnabled() ? Math.max(MIN_INPUT_VIEWPORT_LINES, Math.floor(rows / 2) - PROMPT_FOOTER_LINES) : undefined;
  const handleInputClick = useCallback((e: ClickEvent) => {
    // During history search the displayed text is historyMatch, not
    // input, and showCursor is false anyway — skip rather than
    // compute an offset against the wrong string.
    if (!input || isSearchingHistory) return;
    const c = Cursor.fromText(input, textInputColumns, cursorOffset);
    const viewportStart = c.getViewportStartLine(maxVisibleLines);
    const offset = c.measuredText.getOffsetFromPosition({
      line: e.localRow + viewportStart,
      column: e.localCol
    });
    setCursorOffset(offset);
  }, [input, textInputColumns, isSearchingHistory, cursorOffset, maxVisibleLines]);
  const handleOpenTasksDialog = useCallback((taskId?: string) => setShowBashesDialog(taskId ?? true), [setShowBashesDialog]);
  const placeholder = showPromptSuggestion && promptSuggestion ? promptSuggestion : defaultPlaceholder;

  // Calculate if input has multiple lines
  const isInputWrapped = useMemo(() => input.includes('\n'), [input]);

  // Memoized callbacks for model picker to prevent re-renders when unrelated
  // state (like notifications) changes. This prevents the inline model picker
  // from visually "jumping" when notifications arrive.
  const handleModelSelect = useCallback((model: string | null, _effort: EffortLevel | undefined) => {
    let wasFastModeDisabled = false;
    setAppState(prev => {
      wasFastModeDisabled = isFastModeEnabled() && !isFastModeSupportedByModel(model) && !!prev.fastMode;
      return {
        ...prev,
        mainLoopModel: model,
        mainLoopModelForSession: null,
        // Turn off fast mode if switching to a model that doesn't support it
        ...(wasFastModeDisabled && {
          fastMode: false
        })
      };
    });
    setShowModelPicker(false);
    const effectiveFastMode = (isFastMode ?? false) && !wasFastModeDisabled;
    let message = `Model set to ${modelDisplayString(model)}`;
    if (isBilledAsExtraUsage(model, effectiveFastMode, isOpus1mMergeEnabled())) {
      message += ' · Billed as extra usage';
    }
    if (wasFastModeDisabled) {
      message += ' · Fast mode OFF';
    }
    addNotification({
      key: 'model-switched',
      jsx: <Text>{message}</Text>,
      priority: 'immediate',
      timeoutMs: 3000
    });
    logEvent('tengu_model_picker_hotkey', {
      model: model as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
    });
  }, [setAppState, addNotification, isFastMode]);
  const handleModelCancel = useCallback(() => {
    setShowModelPicker(false);
  }, []);

  // Memoize the model picker element to prevent unnecessary re-renders
  // when AppState changes for unrelated reasons (e.g., notifications arriving)
  const modelPickerElement = useMemo(() => {
    if (!showModelPicker) return null;
    return <Box flexDirection="column" marginTop={1}>
        <ModelPicker initial={mainLoopModel_} sessionModel={mainLoopModelForSession} onSelect={handleModelSelect} onCancel={handleModelCancel} isStandaloneCommand showFastModeNotice={isFastModeEnabled() && isFastMode && isFastModeSupportedByModel(mainLoopModel_) && isFastModeAvailable()} />
      </Box>;
  }, [showModelPicker, mainLoopModel_, mainLoopModelForSession, handleModelSelect, handleModelCancel]);
  const handleFastModeSelect = useCallback((result?: string) => {
    setShowFastModePicker(false);
    if (result) {
      addNotification({
        key: 'fast-mode-toggled',
        jsx: <Text>{result}</Text>,
        priority: 'immediate',
        timeoutMs: 3000
      });
    }
  }, [addNotification]);

  // Memoize the fast mode picker element
  const fastModePickerElement = useMemo(() => {
    if (!showFastModePicker) return null;
    return <Box flexDirection="column" marginTop={1}>
        <FastModePicker onDone={handleFastModeSelect} unavailableReason={getFastModeUnavailableReason()} />
      </Box>;
  }, [showFastModePicker, handleFastModeSelect]);

  // Memoized callbacks for thinking toggle
  const handleThinkingSelect = useCallback((enabled: boolean) => {
    setAppState(prev => ({
      ...prev,
      thinkingEnabled: enabled
    }));
    setShowThinkingToggle(false);
    logEvent('tengu_thinking_toggled_hotkey', {
      enabled
    });
    addNotification({
      key: 'thinking-toggled-hotkey',
      jsx: <Text color={enabled ? 'suggestion' : undefined} dimColor={!enabled}>
            Thinking {enabled ? 'on' : 'off'}
          </Text>,
      priority: 'immediate',
      timeoutMs: 3000
    });
  }, [setAppState, addNotification]);
  const handleThinkingCancel = useCallback(() => {
    setShowThinkingToggle(false);
  }, []);

  // Memoize the thinking toggle element
  const thinkingToggleElement = useMemo(() => {
    if (!showThinkingToggle) return null;
    return <Box flexDirection="column" marginTop={1}>
        <ThinkingToggle currentValue={thinkingEnabled ?? true} onSelect={handleThinkingSelect} onCancel={handleThinkingCancel} isMidConversation={messages.some(m => m.type === 'assistant')} />
      </Box>;
  }, [showThinkingToggle, thinkingEnabled, handleThinkingSelect, handleThinkingCancel, messages.length]);

  // Portal dialog to DialogOverlay in fullscreen so it escapes the bottom
  // slot's overflowY:hidden clip (same pattern as SuggestionsOverlay).
  // Must be called before early returns below to satisfy rules-of-hooks.
  // Memoized so the portal useEffect doesn't churn on every PromptInput render.
  const autoModeOptInDialog = useMemo(() => feature('TRANSCRIPT_CLASSIFIER') && showAutoModeOptIn ? <AutoModeOptInDialog onAccept={handleAutoModeOptInAccept} onDecline={handleAutoModeOptInDecline} /> : null, [showAutoModeOptIn, handleAutoModeOptInAccept, handleAutoModeOptInDecline]);
  useSetPromptOverlayDialog(isFullscreenEnvEnabled() ? autoModeOptInDialog : null);
  if (showBashesDialog) {
    return <BackgroundTasksDialog onDone={() => setShowBashesDialog(false)} toolUseContext={getToolUseContext(messages, [], new AbortController(), mainLoopModel)} initialDetailTaskId={typeof showBashesDialog === 'string' ? showBashesDialog : undefined} />;
  }
  if (isAgentSwarmsEnabled() && showTeamsDialog) {
    return <TeamsDialog initialTeams={cachedTeams} onDone={() => {
      setShowTeamsDialog(false);
    }} />;
  }
  if (feature('QUICK_SEARCH')) {
    const insertWithSpacing = (text: string) => {
      const cursorChar = input[cursorOffset - 1] ?? ' ';
      insertTextAtCursor(/\s/.test(cursorChar) ? text : ` ${text}`);
    };
    if (showQuickOpen) {
      return <QuickOpenDialog onDone={() => setShowQuickOpen(false)} onInsert={insertWithSpacing} />;
    }
    if (showGlobalSearch) {
      return <GlobalSearchDialog onDone={() => setShowGlobalSearch(false)} onInsert={insertWithSpacing} />;
    }
  }
  if (feature('HISTORY_PICKER') && showHistoryPicker) {
    return <HistorySearchDialog initialQuery={input} onSelect={entry => {
      const entryMode = getModeFromInput(entry.display);
      const value = getValueFromInput(entry.display);
      onModeChange(entryMode);
      trackAndSetInput(value);
      setPastedContents(entry.pastedContents);
      setCursorOffset(value.length);
      setShowHistoryPicker(false);
    }} onCancel={() => setShowHistoryPicker(false)} />;
  }

  // Show loop mode menu when requested (ant-only, eliminated from external builds)
  if (modelPickerElement) {
    return modelPickerElement;
  }
  if (fastModePickerElement) {
    return fastModePickerElement;
  }
  if (thinkingToggleElement) {
    return thinkingToggleElement;
  }
  if (showBridgeDialog) {
    return <BridgeDialog onDone={() => {
      setShowBridgeDialog(false);
      selectFooterItem(null);
    }} />;
  }
  const baseProps: BaseTextInputProps = {
    multiline: true,
    onSubmit,
    onChange,
    value: historyMatch ? getValueFromInput(typeof historyMatch === 'string' ? historyMatch : historyMatch.display) : input,
    // History navigation is handled via TextInput props (onHistoryUp/onHistoryDown),
    // NOT via useKeybindings. This allows useTextInput's upOrHistoryUp/downOrHistoryDown
    // to try cursor movement first and only fall through to history navigation when the
    // cursor can't move further (important for wrapped text and multi-line input).
    onHistoryUp: handleHistoryUp,
    onHistoryDown: handleHistoryDown,
    onHistoryReset: resetHistory,
    placeholder,
    onExit,
    onExitMessage: (show, key) => setExitMessage({
      show,
      key
    }),
    onImagePaste,
    columns: textInputColumns,
    maxVisibleLines,
    disableCursorMovementForUpDownKeys: suggestions.length > 0 || !!footerItemSelected,
    disableEscapeDoublePress: suggestions.length > 0,
    cursorOffset,
    onChangeCursorOffset: setCursorOffset,
    onPaste: onTextPaste,
    onIsPastingChange: setIsPasting,
    focus: !isSearchingHistory && !isModalOverlayActive && !footerItemSelected,
    showCursor: !footerItemSelected && !isSearchingHistory && !cursorAtImageChip,
    argumentHint: commandArgumentHint,
    onUndo: canUndo ? () => {
      const previousState = undo();
      if (previousState) {
        trackAndSetInput(previousState.text);
        setCursorOffset(previousState.cursorOffset);
        setPastedContents(previousState.pastedContents);
      }
    } : undefined,
    highlights: combinedHighlights,
    inlineGhostText,
    inputFilter: lazySpaceInputFilter
  };
  const getBorderColor = (): keyof Theme => {
    const modeColors: Record<string, keyof Theme> = {
      bash: 'bashBorder'
    };

    // Mode colors take priority, then teammate color, then default
    if (modeColors[mode]) {
      return modeColors[mode];
    }

    // In-process teammates run headless - don't apply teammate colors to leader UI
    if (isInProcessTeammate()) {
      return 'promptBorder';
    }

    // Check for teammate color from environment
    const teammateColorName = getTeammateColor();
    if (teammateColorName && AGENT_COLORS.includes(teammateColorName as AgentColorName)) {
      return AGENT_COLOR_TO_THEME_COLOR[teammateColorName as AgentColorName];
    }
    return 'promptBorder';
  };
  if (isExternalEditorActive) {
    return <Box flexDirection="row" alignItems="center" justifyContent="center" borderColor={getBorderColor()} borderStyle="round" borderLeft={false} borderRight={false} borderBottom width="100%">
        <Text dimColor italic>
          Save and close editor to continue...
        </Text>
      </Box>;
  }
  const textInputElement = isVimModeEnabled() ? <VimTextInput {...baseProps} initialMode={vimMode} onModeChange={setVimMode} /> : <TextInput {...baseProps} />;
  return <Box flexDirection="column" marginTop={briefOwnsGap ? 0 : 1}>
      {!isFullscreenEnvEnabled() && <PromptInputQueuedCommands />}
      {hasSuppressedDialogs && <Box marginTop={1} marginLeft={2}>
          <Text dimColor>Waiting for permission…</Text>
        </Box>}
      <PromptInputStashNotice hasStash={stashedPrompt !== undefined} />
      {swarmBanner ? <>
          <Text color={swarmBanner.bgColor}>
            {swarmBanner.text ? <>
                {'─'.repeat(Math.max(0, columns - stringWidth(swarmBanner.text) - 4))}
                <Text backgroundColor={swarmBanner.bgColor} color="inverseText">
                  {' '}
                  {swarmBanner.text}{' '}
                </Text>
                {'──'}
              </> : '─'.repeat(columns)}
          </Text>
          <Box flexDirection="row" width="100%">
            <PromptInputModeIndicator mode={mode} isLoading={isLoading} viewingAgentName={viewingAgentName} viewingAgentColor={viewingAgentColor} />
            <Box flexGrow={1} flexShrink={1} onClick={handleInputClick}>
              {textInputElement}
            </Box>
          </Box>
          <Text color={swarmBanner.bgColor}>{'─'.repeat(columns)}</Text>
        </> : <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)}>
          <PromptInputModeIndicator mode={mode} isLoading={isLoading} viewingAgentName={viewingAgentName} viewingAgentColor={viewingAgentColor} />
          <Box flexGrow={1} flexShrink={1} onClick={handleInputClick}>
            {textInputElement}
          </Box>
        </Box>}
      <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} />
      {isFullscreenEnvEnabled() ? null : autoModeOptInDialog}
      {isFullscreenEnvEnabled() ?
    // position=absolute takes zero layout height so the spinner
    // doesn't shift when a notification appears/disappears. Yoga
    // anchors absolute children at the parent's content-box origin;
    // marginTop=-1 pulls it into the marginTop=1 gap row above the
    // prompt border. In brief mode there is no such gap (briefOwnsGap
    // strips our marginTop) and BriefSpinner sits flush against the
    // border — marginTop=-2 skips over the spinner content into
    // BriefSpinner's own marginTop=1 blank row. height=1 +
    // overflow=hidden clips multi-line notifications to a single row.
    // flex-end anchors the bottom line so the visible row is always
    // the most recent. Suppressed while the slash overlay or
    // auto-mode opt-in dialog is up by height=0 (NOT unmount) — this
    // Box renders later in tree order so it would paint over their
    // bottom row. Keeping Notifications mounted prevents AutoUpdater's
    // initial-check effect from re-firing on every slash-completion
    // toggle (PR#22413).
    <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">
          <Notifications apiKeyStatus={apiKeyStatus} autoUpdaterResult={autoUpdaterResult} debug={debug} isAutoUpdating={isAutoUpdating} verbose={verbose} messages={messages} onAutoUpdaterResult={onAutoUpdaterResult} onChangeIsUpdating={setIsAutoUpdating} ideSelection={ideSelection} mcpClients={mcpClients} isInputWrapped={isInputWrapped} />
        </Box> : null}
    </Box>;
}

/**
 * Compute the initial paste ID by finding the max ID used in existing messages.
 * This handles --continue/--resume scenarios where we need to avoid ID collisions.
 */
function getInitialPasteId(messages: Message[]): number {
  let maxId = 0;
  for (const message of messages) {
    if (message.type === 'user') {
      // Check image paste IDs
      if (message.imagePasteIds) {
        for (const id of message.imagePasteIds as number[]) {
          if (id > maxId) maxId = id;
        }
      }
      // Check text paste references in message content
      if (Array.isArray(message.message.content)) {
        for (const block of message.message.content) {
          if (block.type === 'text') {
            const refs = parseReferences(block.text);
            for (const ref of refs) {
              if (ref.id > maxId) maxId = ref.id;
            }
          }
        }
      }
    }
  }
  return maxId + 1;
}
function buildBorderText(showFastIcon: boolean, showFastIconHint: boolean, fastModeCooldown: boolean): BorderTextOptions | undefined {
  if (!showFastIcon) return undefined;
  const fastSeg = showFastIconHint ? `${getFastIconString(true, fastModeCooldown)} ${chalk.dim('/fast')}` : getFastIconString(true, fastModeCooldown);
  return {
    content: ` ${fastSeg} `,
    position: 'top',
    align: 'end',
    offset: 0
  };
}
export default React.memo(PromptInput);
//# 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":[]}