@xelauvas/xela-cli 0.1.0

package/src/hooks/useTypeahead.tsx

@@ -0,0 +1,1385 @@
+import * as React from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useNotifications } from 'src/context/notifications.js';
+import { Text } from 'src/ink.js';
+import { logEvent } from 'src/services/analytics/index.js';
+import { useDebounceCallback } from 'usehooks-ts';
+import { type Command, getCommandName } from '../commands.js';
+import { getModeFromInput, getValueFromInput } from '../components/PromptInput/inputModes.js';
+import type { SuggestionItem, SuggestionType } from '../components/PromptInput/PromptInputFooterSuggestions.js';
+import { useIsModalOverlayActive, useRegisterOverlay } from '../context/overlayContext.js';
+import { KeyboardEvent } from '../ink/events/keyboard-event.js';
+// eslint-disable-next-line custom-rules/prefer-use-keybindings -- backward-compat bridge until consumers wire handleKeyDown to <Box onKeyDown>
+import { useInput } from '../ink.js';
+import { useOptionalKeybindingContext, useRegisterKeybindingContext } from '../keybindings/KeybindingContext.js';
+import { useKeybindings } from '../keybindings/useKeybinding.js';
+import { useShortcutDisplay } from '../keybindings/useShortcutDisplay.js';
+import { useAppState, useAppStateStore } from '../state/AppState.js';
+import type { AgentDefinition } from '../tools/AgentTool/loadAgentsDir.js';
+import type { InlineGhostText, PromptInputMode } from '../types/textInputTypes.js';
+import { isAgentSwarmsEnabled } from '../utils/agentSwarmsEnabled.js';
+import { generateProgressiveArgumentHint, parseArguments } from '../utils/argumentSubstitution.js';
+import { getShellCompletions, type ShellCompletionType } from '../utils/bash/shellCompletion.js';
+import { formatLogMetadata } from '../utils/format.js';
+import { getSessionIdFromLog, searchSessionsByCustomTitle } from '../utils/sessionStorage.js';
+import { applyCommandSuggestion, findMidInputSlashCommand, generateCommandSuggestions, getBestCommandMatch, isCommandInput } from '../utils/suggestions/commandSuggestions.js';
+import { getDirectoryCompletions, getPathCompletions, isPathLikeToken } from '../utils/suggestions/directoryCompletion.js';
+import { getShellHistoryCompletion } from '../utils/suggestions/shellHistoryCompletion.js';
+import { getSlackChannelSuggestions, hasSlackMcpServer } from '../utils/suggestions/slackChannelSuggestions.js';
+import { TEAM_LEAD_NAME } from '../utils/swarm/constants.js';
+import { applyFileSuggestion, findLongestCommonPrefix, onIndexBuildComplete, startBackgroundCacheRefresh } from './fileSuggestions.js';
+import { generateUnifiedSuggestions } from './unifiedSuggestions.js';
+
+// Unicode-aware character class for file path tokens:
+// \p{L} = letters (CJK, Latin, Cyrillic, etc.)
+// \p{N} = numbers (incl. fullwidth)
+// \p{M} = combining marks (macOS NFD accents, Devanagari vowel signs)
+const AT_TOKEN_HEAD_RE = /^@[\p{L}\p{N}\p{M}_\-./\\()[\]~:]*/u;
+const PATH_CHAR_HEAD_RE = /^[\p{L}\p{N}\p{M}_\-./\\()[\]~:]+/u;
+const TOKEN_WITH_AT_RE = /(@[\p{L}\p{N}\p{M}_\-./\\()[\]~:]*|[\p{L}\p{N}\p{M}_\-./\\()[\]~:]+)$/u;
+const TOKEN_WITHOUT_AT_RE = /[\p{L}\p{N}\p{M}_\-./\\()[\]~:]+$/u;
+const HAS_AT_SYMBOL_RE = /(^|\s)@([\p{L}\p{N}\p{M}_\-./\\()[\]~:]*|"[^"]*"?)$/u;
+const HASH_CHANNEL_RE = /(^|\s)#([a-z0-9][a-z0-9_-]*)$/;
+
+// Type guard for path completion metadata
+function isPathMetadata(metadata: unknown): metadata is {
+  type: 'directory' | 'file';
+} {
+  return typeof metadata === 'object' && metadata !== null && 'type' in metadata && (metadata.type === 'directory' || metadata.type === 'file');
+}
+
+// Helper to determine selectedSuggestion when updating suggestions
+function getPreservedSelection(prevSuggestions: SuggestionItem[], prevSelection: number, newSuggestions: SuggestionItem[]): number {
+  // No new suggestions
+  if (newSuggestions.length === 0) {
+    return -1;
+  }
+
+  // No previous selection
+  if (prevSelection < 0) {
+    return 0;
+  }
+
+  // Get the previously selected item
+  const prevSelectedItem = prevSuggestions[prevSelection];
+  if (!prevSelectedItem) {
+    return 0;
+  }
+
+  // Try to find the same item in the new list by ID
+  const newIndex = newSuggestions.findIndex(item => item.id === prevSelectedItem.id);
+
+  // Return the new index if found, otherwise default to 0
+  return newIndex >= 0 ? newIndex : 0;
+}
+function buildResumeInputFromSuggestion(suggestion: SuggestionItem): string {
+  const metadata = suggestion.metadata as {
+    sessionId: string;
+  } | undefined;
+  return metadata?.sessionId ? `/resume ${metadata.sessionId}` : `/resume ${suggestion.displayText}`;
+}
+type Props = {
+  onInputChange: (value: string) => void;
+  onSubmit: (value: string, isSubmittingSlashCommand?: boolean) => void;
+  setCursorOffset: (offset: number) => void;
+  input: string;
+  cursorOffset: number;
+  commands: Command[];
+  mode: string;
+  agents: AgentDefinition[];
+  setSuggestionsState: (f: (previousSuggestionsState: {
+    suggestions: SuggestionItem[];
+    selectedSuggestion: number;
+    commandArgumentHint?: string;
+  }) => {
+    suggestions: SuggestionItem[];
+    selectedSuggestion: number;
+    commandArgumentHint?: string;
+  }) => void;
+  suggestionsState: {
+    suggestions: SuggestionItem[];
+    selectedSuggestion: number;
+    commandArgumentHint?: string;
+  };
+  suppressSuggestions?: boolean;
+  markAccepted: () => void;
+  onModeChange?: (mode: PromptInputMode) => void;
+};
+type UseTypeaheadResult = {
+  suggestions: SuggestionItem[];
+  selectedSuggestion: number;
+  suggestionType: SuggestionType;
+  maxColumnWidth?: number;
+  commandArgumentHint?: string;
+  inlineGhostText?: InlineGhostText;
+  handleKeyDown: (e: KeyboardEvent) => void;
+};
+
+/**
+ * Extract search token from a completion token by removing @ prefix and quotes
+ * @param completionToken The completion token
+ * @returns The search token with @ and quotes removed
+ */
+export function extractSearchToken(completionToken: {
+  token: string;
+  isQuoted?: boolean;
+}): string {
+  if (completionToken.isQuoted) {
+    // Remove @" prefix and optional closing "
+    return completionToken.token.slice(2).replace(/"$/, '');
+  } else if (completionToken.token.startsWith('@')) {
+    return completionToken.token.substring(1);
+  } else {
+    return completionToken.token;
+  }
+}
+
+/**
+ * Format a replacement value with proper @ prefix and quotes based on context
+ * @param options Configuration for formatting
+ * @param options.displayText The text to display
+ * @param options.mode The current mode (bash or prompt)
+ * @param options.hasAtPrefix Whether the original token has @ prefix
+ * @param options.needsQuotes Whether the text needs quotes (contains spaces)
+ * @param options.isQuoted Whether the original token was already quoted (user typed @"...)
+ * @param options.isComplete Whether this is a complete suggestion (adds trailing space)
+ * @returns The formatted replacement value
+ */
+export function formatReplacementValue(options: {
+  displayText: string;
+  mode: string;
+  hasAtPrefix: boolean;
+  needsQuotes: boolean;
+  isQuoted?: boolean;
+  isComplete: boolean;
+}): string {
+  const {
+    displayText,
+    mode,
+    hasAtPrefix,
+    needsQuotes,
+    isQuoted,
+    isComplete
+  } = options;
+  const space = isComplete ? ' ' : '';
+  if (isQuoted || needsQuotes) {
+    // Use quoted format
+    return mode === 'bash' ? `"${displayText}"${space}` : `@"${displayText}"${space}`;
+  } else if (hasAtPrefix) {
+    return mode === 'bash' ? `${displayText}${space}` : `@${displayText}${space}`;
+  } else {
+    return displayText;
+  }
+}
+
+/**
+ * Apply a shell completion suggestion by replacing the current word
+ */
+export function applyShellSuggestion(suggestion: SuggestionItem, input: string, cursorOffset: number, onInputChange: (value: string) => void, setCursorOffset: (offset: number) => void, completionType: ShellCompletionType | undefined): void {
+  const beforeCursor = input.slice(0, cursorOffset);
+  const lastSpaceIndex = beforeCursor.lastIndexOf(' ');
+  const wordStart = lastSpaceIndex + 1;
+
+  // Prepare the replacement text based on completion type
+  let replacementText: string;
+  if (completionType === 'variable') {
+    replacementText = '$' + suggestion.displayText + ' ';
+  } else if (completionType === 'command') {
+    replacementText = suggestion.displayText + ' ';
+  } else {
+    replacementText = suggestion.displayText;
+  }
+  const newInput = input.slice(0, wordStart) + replacementText + input.slice(cursorOffset);
+  onInputChange(newInput);
+  setCursorOffset(wordStart + replacementText.length);
+}
+const DM_MEMBER_RE = /(^|\s)@[\w-]*$/;
+function applyTriggerSuggestion(suggestion: SuggestionItem, input: string, cursorOffset: number, triggerRe: RegExp, onInputChange: (value: string) => void, setCursorOffset: (offset: number) => void): void {
+  const m = input.slice(0, cursorOffset).match(triggerRe);
+  if (!m || m.index === undefined) return;
+  const prefixStart = m.index + (m[1]?.length ?? 0);
+  const before = input.slice(0, prefixStart);
+  const newInput = before + suggestion.displayText + ' ' + input.slice(cursorOffset);
+  onInputChange(newInput);
+  setCursorOffset(before.length + suggestion.displayText.length + 1);
+}
+let currentShellCompletionAbortController: AbortController | null = null;
+
+/**
+ * Generate bash shell completion suggestions
+ */
+async function generateBashSuggestions(input: string, cursorOffset: number): Promise<SuggestionItem[]> {
+  try {
+    if (currentShellCompletionAbortController) {
+      currentShellCompletionAbortController.abort();
+    }
+    currentShellCompletionAbortController = new AbortController();
+    const suggestions = await getShellCompletions(input, cursorOffset, currentShellCompletionAbortController.signal);
+    return suggestions;
+  } catch {
+    // Silent failure - don't break UX
+    logEvent('tengu_shell_completion_failed', {});
+    return [];
+  }
+}
+
+/**
+ * Apply a directory/path completion suggestion to the input
+ * Always adds @ prefix since we're replacing the entire token (including any existing @)
+ *
+ * @param input The current input text
+ * @param suggestionId The ID of the suggestion to apply
+ * @param tokenStartPos The start position of the token being replaced
+ * @param tokenLength The length of the token being replaced
+ * @param isDirectory Whether the suggestion is a directory (adds / suffix) or file (adds space)
+ * @returns Object with the new input text and cursor position
+ */
+export function applyDirectorySuggestion(input: string, suggestionId: string, tokenStartPos: number, tokenLength: number, isDirectory: boolean): {
+  newInput: string;
+  cursorPos: number;
+} {
+  const suffix = isDirectory ? '/' : ' ';
+  const before = input.slice(0, tokenStartPos);
+  const after = input.slice(tokenStartPos + tokenLength);
+  // Always add @ prefix - if token already has it, we're replacing
+  // the whole token (including @) with @suggestion.id
+  const replacement = '@' + suggestionId + suffix;
+  const newInput = before + replacement + after;
+  return {
+    newInput,
+    cursorPos: before.length + replacement.length
+  };
+}
+
+/**
+ * Extract a completable token at the cursor position
+ * @param text The input text
+ * @param cursorPos The cursor position
+ * @param includeAtSymbol Whether to consider @ symbol as part of the token
+ * @returns The completable token and its start position, or null if not found
+ */
+export function extractCompletionToken(text: string, cursorPos: number, includeAtSymbol = false): {
+  token: string;
+  startPos: number;
+  isQuoted?: boolean;
+} | null {
+  // Empty input check
+  if (!text) return null;
+
+  // Get text up to cursor
+  const textBeforeCursor = text.substring(0, cursorPos);
+
+  // Check for quoted @ mention first (e.g., @"my file with spaces")
+  if (includeAtSymbol) {
+    const quotedAtRegex = /@"([^"]*)"?$/;
+    const quotedMatch = textBeforeCursor.match(quotedAtRegex);
+    if (quotedMatch && quotedMatch.index !== undefined) {
+      // Include any remaining quoted content after cursor until closing quote or end
+      const textAfterCursor = text.substring(cursorPos);
+      const afterQuotedMatch = textAfterCursor.match(/^[^"]*"?/);
+      const quotedSuffix = afterQuotedMatch ? afterQuotedMatch[0] : '';
+      return {
+        token: quotedMatch[0] + quotedSuffix,
+        startPos: quotedMatch.index,
+        isQuoted: true
+      };
+    }
+  }
+
+  // Fast path for @ tokens: use lastIndexOf to avoid expensive $ anchor scan
+  if (includeAtSymbol) {
+    const atIdx = textBeforeCursor.lastIndexOf('@');
+    if (atIdx >= 0 && (atIdx === 0 || /\s/.test(textBeforeCursor[atIdx - 1]!))) {
+      const fromAt = textBeforeCursor.substring(atIdx);
+      const atHeadMatch = fromAt.match(AT_TOKEN_HEAD_RE);
+      if (atHeadMatch && atHeadMatch[0].length === fromAt.length) {
+        const textAfterCursor = text.substring(cursorPos);
+        const afterMatch = textAfterCursor.match(PATH_CHAR_HEAD_RE);
+        const tokenSuffix = afterMatch ? afterMatch[0] : '';
+        return {
+          token: atHeadMatch[0] + tokenSuffix,
+          startPos: atIdx,
+          isQuoted: false
+        };
+      }
+    }
+  }
+
+  // Non-@ token or cursor outside @ token — use $ anchor on (short) tail
+  const tokenRegex = includeAtSymbol ? TOKEN_WITH_AT_RE : TOKEN_WITHOUT_AT_RE;
+  const match = textBeforeCursor.match(tokenRegex);
+  if (!match || match.index === undefined) {
+    return null;
+  }
+
+  // Check if cursor is in the MIDDLE of a token (more word characters after cursor)
+  // If so, extend the token to include all characters until whitespace or end of string
+  const textAfterCursor = text.substring(cursorPos);
+  const afterMatch = textAfterCursor.match(PATH_CHAR_HEAD_RE);
+  const tokenSuffix = afterMatch ? afterMatch[0] : '';
+  return {
+    token: match[0] + tokenSuffix,
+    startPos: match.index,
+    isQuoted: false
+  };
+}
+function extractCommandNameAndArgs(value: string): {
+  commandName: string;
+  args: string;
+} | null {
+  if (isCommandInput(value)) {
+    const spaceIndex = value.indexOf(' ');
+    if (spaceIndex === -1) return {
+      commandName: value.slice(1),
+      args: ''
+    };
+    return {
+      commandName: value.slice(1, spaceIndex),
+      args: value.slice(spaceIndex + 1)
+    };
+  }
+  return null;
+}
+function hasCommandWithArguments(isAtEndWithWhitespace: boolean, value: string) {
+  // If value.endsWith(' ') but the user is not at the end, then the user has
+  // potentially gone back to the command in an effort to edit the command name
+  // (but preserve the arguments).
+  return !isAtEndWithWhitespace && value.includes(' ') && !value.endsWith(' ');
+}
+
+/**
+ * Hook for handling typeahead functionality for both commands and file paths
+ */
+export function useTypeahead({
+  commands,
+  onInputChange,
+  onSubmit,
+  setCursorOffset,
+  input,
+  cursorOffset,
+  mode,
+  agents,
+  setSuggestionsState,
+  suggestionsState: {
+    suggestions,
+    selectedSuggestion,
+    commandArgumentHint
+  },
+  suppressSuggestions = false,
+  markAccepted,
+  onModeChange
+}: Props): UseTypeaheadResult {
+  const {
+    addNotification
+  } = useNotifications();
+  const thinkingToggleShortcut = useShortcutDisplay('chat:thinkingToggle', 'Chat', 'alt+t');
+  const [suggestionType, setSuggestionType] = useState<SuggestionType>('none');
+
+  // Compute max column width from ALL commands once (not filtered results)
+  // This prevents layout shift when filtering
+  const allCommandsMaxWidth = useMemo(() => {
+    const visibleCommands = commands.filter(cmd => !cmd.isHidden);
+    if (visibleCommands.length === 0) return undefined;
+    const maxLen = Math.max(...visibleCommands.map(cmd => getCommandName(cmd).length));
+    return maxLen + 6; // +1 for "/" prefix, +5 for padding
+  }, [commands]);
+  const [maxColumnWidth, setMaxColumnWidth] = useState<number | undefined>(undefined);
+  const mcpResources = useAppState(s => s.mcp.resources);
+  const store = useAppStateStore();
+  const promptSuggestion = useAppState(s => s.promptSuggestion);
+  // PromptInput hides suggestion ghost text in teammate view — mirror that
+  // gate here so Tab/rightArrow can't accept what isn't displayed.
+  const isViewingTeammate = useAppState(s => !!s.viewingAgentTaskId);
+
+  // Access keybinding context to check for pending chord sequences
+  const keybindingContext = useOptionalKeybindingContext();
+
+  // State for inline ghost text (bash history completion - async)
+  const [inlineGhostText, setInlineGhostText] = useState<InlineGhostText | undefined>(undefined);
+
+  // Synchronous ghost text for prompt mode mid-input slash commands.
+  // Computed during render via useMemo to eliminate the one-frame flicker
+  // that occurs when using useState + useEffect (effect runs after render).
+  const syncPromptGhostText = useMemo((): InlineGhostText | undefined => {
+    if (mode !== 'prompt' || suppressSuggestions) return undefined;
+    const midInputCommand = findMidInputSlashCommand(input, cursorOffset);
+    if (!midInputCommand) return undefined;
+    const match = getBestCommandMatch(midInputCommand.partialCommand, commands);
+    if (!match) return undefined;
+    return {
+      text: match.suffix,
+      fullCommand: match.fullCommand,
+      insertPosition: midInputCommand.startPos + 1 + midInputCommand.partialCommand.length
+    };
+  }, [input, cursorOffset, mode, commands, suppressSuggestions]);
+
+  // Merged ghost text: prompt mode uses synchronous useMemo, bash mode uses async useState
+  const effectiveGhostText = suppressSuggestions ? undefined : mode === 'prompt' ? syncPromptGhostText : inlineGhostText;
+
+  // Use a ref for cursorOffset to avoid re-triggering suggestions on cursor movement alone
+  // We only want to re-fetch suggestions when the actual search token changes
+  const cursorOffsetRef = useRef(cursorOffset);
+  cursorOffsetRef.current = cursorOffset;
+
+  // Track the latest search token to discard stale results from slow async operations
+  const latestSearchTokenRef = useRef<string | null>(null);
+  // Track previous input to detect actual text changes vs. callback recreations
+  const prevInputRef = useRef('');
+  // Track the latest path token to discard stale results from path completion
+  const latestPathTokenRef = useRef('');
+  // Track the latest bash input to discard stale results from history completion
+  const latestBashInputRef = useRef('');
+  // Track the latest slack channel token to discard stale results from MCP
+  const latestSlackTokenRef = useRef('');
+  // Track suggestions via ref to avoid updateSuggestions being recreated on selection changes
+  const suggestionsRef = useRef(suggestions);
+  suggestionsRef.current = suggestions;
+  // Track the input value when suggestions were manually dismissed to prevent re-triggering
+  const dismissedForInputRef = useRef<string | null>(null);
+
+  // Clear all suggestions
+  const clearSuggestions = useCallback(() => {
+    setSuggestionsState(() => ({
+      commandArgumentHint: undefined,
+      suggestions: [],
+      selectedSuggestion: -1
+    }));
+    setSuggestionType('none');
+    setMaxColumnWidth(undefined);
+    setInlineGhostText(undefined);
+  }, [setSuggestionsState]);
+
+  // Expensive async operation to fetch file/resource suggestions
+  const fetchFileSuggestions = useCallback(async (searchToken: string, isAtSymbol = false): Promise<void> => {
+    latestSearchTokenRef.current = searchToken;
+    const combinedItems = await generateUnifiedSuggestions(searchToken, mcpResources, agents, isAtSymbol);
+    // Discard stale results if a newer query was initiated while waiting
+    if (latestSearchTokenRef.current !== searchToken) {
+      return;
+    }
+    if (combinedItems.length === 0) {
+      // Inline clearSuggestions logic to avoid needing debouncedFetchFileSuggestions
+      setSuggestionsState(() => ({
+        commandArgumentHint: undefined,
+        suggestions: [],
+        selectedSuggestion: -1
+      }));
+      setSuggestionType('none');
+      setMaxColumnWidth(undefined);
+      return;
+    }
+    setSuggestionsState(prev => ({
+      commandArgumentHint: undefined,
+      suggestions: combinedItems,
+      selectedSuggestion: getPreservedSelection(prev.suggestions, prev.selectedSuggestion, combinedItems)
+    }));
+    setSuggestionType(combinedItems.length > 0 ? 'file' : 'none');
+    setMaxColumnWidth(undefined); // No fixed width for file suggestions
+  }, [mcpResources, setSuggestionsState, setSuggestionType, setMaxColumnWidth, agents]);
+
+  // Pre-warm the file index on mount so the first @-mention doesn't block.
+  // The build runs in background with ~4ms event-loop yields, so it doesn't
+  // delay first render — it just races the user's first @ keystroke.
+  //
+  // If the user types before the build finishes, they get partial results
+  // from the ready chunks; when the build completes, re-fire the last
+  // search so partial upgrades to full. Clears the token ref so the same
+  // query isn't discarded as stale.
+  //
+  // Skipped under NODE_ENV=test: REPL-mounting tests would spawn git ls-files
+  // against the real CI workspace (270k+ files on Windows runners), and the
+  // background build outlives the test — its setImmediate chain leaks into
+  // subsequent tests in the shard. The subscriber still registers so
+  // fileSuggestions tests that trigger a refresh directly work correctly.
+  useEffect(() => {
+    if ("production" !== 'test') {
+      startBackgroundCacheRefresh();
+    }
+    return onIndexBuildComplete(() => {
+      const token = latestSearchTokenRef.current;
+      if (token !== null) {
+        latestSearchTokenRef.current = null;
+        void fetchFileSuggestions(token, token === '');
+      }
+    });
+  }, [fetchFileSuggestions]);
+
+  // Debounce the file fetch operation. 50ms sits just above macOS default
+  // key-repeat (~33ms) so held-delete/backspace coalesces into one search
+  // instead of stuttering on each repeated key. The search itself is ~8–15ms
+  // on a 270k-file index.
+  const debouncedFetchFileSuggestions = useDebounceCallback(fetchFileSuggestions, 50);
+  const fetchSlackChannels = useCallback(async (partial: string): Promise<void> => {
+    latestSlackTokenRef.current = partial;
+    const channels = await getSlackChannelSuggestions(store.getState().mcp.clients, partial);
+    if (latestSlackTokenRef.current !== partial) return;
+    setSuggestionsState(prev => ({
+      commandArgumentHint: undefined,
+      suggestions: channels,
+      selectedSuggestion: getPreservedSelection(prev.suggestions, prev.selectedSuggestion, channels)
+    }));
+    setSuggestionType(channels.length > 0 ? 'slack-channel' : 'none');
+    setMaxColumnWidth(undefined);
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps -- store is a stable context ref
+  [setSuggestionsState]);
+
+  // First keystroke after # needs the MCP round-trip; subsequent keystrokes
+  // that share the same first-word segment hit the cache synchronously.
+  const debouncedFetchSlackChannels = useDebounceCallback(fetchSlackChannels, 150);
+
+  // Handle immediate suggestion logic (cheap operations)
+  // biome-ignore lint/correctness/useExhaustiveDependencies: store is a stable context ref, read imperatively at call-time
+  const updateSuggestions = useCallback(async (value: string, inputCursorOffset?: number): Promise<void> => {
+    // Use provided cursor offset or fall back to ref (avoids dependency on cursorOffset)
+    const effectiveCursorOffset = inputCursorOffset ?? cursorOffsetRef.current;
+    if (suppressSuggestions) {
+      debouncedFetchFileSuggestions.cancel();
+      clearSuggestions();
+      return;
+    }
+
+    // Check for mid-input slash command (e.g., "help me /com")
+    // Only in prompt mode, not when input starts with "/" (handled separately)
+    // Note: ghost text for prompt mode is computed synchronously via syncPromptGhostText useMemo.
+    // We only need to clear dropdown suggestions here when ghost text is active.
+    if (mode === 'prompt') {
+      const midInputCommand = findMidInputSlashCommand(value, effectiveCursorOffset);
+      if (midInputCommand) {
+        const match = getBestCommandMatch(midInputCommand.partialCommand, commands);
+        if (match) {
+          // Clear dropdown suggestions when showing ghost text
+          setSuggestionsState(() => ({
+            commandArgumentHint: undefined,
+            suggestions: [],
+            selectedSuggestion: -1
+          }));
+          setSuggestionType('none');
+          setMaxColumnWidth(undefined);
+          return;
+        }
+      }
+    }
+
+    // Bash mode: check for history-based ghost text completion
+    if (mode === 'bash' && value.trim()) {
+      latestBashInputRef.current = value;
+      const historyMatch = await getShellHistoryCompletion(value);
+      // Discard stale results if input changed while waiting
+      if (latestBashInputRef.current !== value) {
+        return;
+      }
+      if (historyMatch) {
+        setInlineGhostText({
+          text: historyMatch.suffix,
+          fullCommand: historyMatch.fullCommand,
+          insertPosition: value.length
+        });
+        // Clear dropdown suggestions when showing ghost text
+        setSuggestionsState(() => ({
+          commandArgumentHint: undefined,
+          suggestions: [],
+          selectedSuggestion: -1
+        }));
+        setSuggestionType('none');
+        setMaxColumnWidth(undefined);
+        return;
+      } else {
+        // No history match, clear ghost text
+        setInlineGhostText(undefined);
+      }
+    }
+
+    // Check for @ to trigger team member / named subagent suggestions
+    // Must check before @ file symbol to prevent conflict
+    // Skip in bash mode - @ has no special meaning in shell commands
+    const atMatch = mode !== 'bash' ? value.substring(0, effectiveCursorOffset).match(/(^|\s)@([\w-]*)$/) : null;
+    if (atMatch) {
+      const partialName = (atMatch[2] ?? '').toLowerCase();
+      // Imperative read — reading at call-time fixes staleness for
+      // teammates/subagents added mid-session.
+      const state = store.getState();
+      const members: SuggestionItem[] = [];
+      const seen = new Set<string>();
+      if (isAgentSwarmsEnabled() && state.teamContext) {
+        for (const t of Object.values(state.teamContext.teammates ?? {})) {
+          if (t.name === TEAM_LEAD_NAME) continue;
+          if (!t.name.toLowerCase().startsWith(partialName)) continue;
+          seen.add(t.name);
+          members.push({
+            id: `dm-${t.name}`,
+            displayText: `@${t.name}`,
+            description: 'send message'
+          });
+        }
+      }
+      for (const [name, agentId] of state.agentNameRegistry) {
+        if (seen.has(name)) continue;
+        if (!name.toLowerCase().startsWith(partialName)) continue;
+        const status = state.tasks[agentId]?.status;
+        members.push({
+          id: `dm-${name}`,
+          displayText: `@${name}`,
+          description: status ? `send message · ${status}` : 'send message'
+        });
+      }
+      if (members.length > 0) {
+        debouncedFetchFileSuggestions.cancel();
+        setSuggestionsState(prev => ({
+          commandArgumentHint: undefined,
+          suggestions: members,
+          selectedSuggestion: getPreservedSelection(prev.suggestions, prev.selectedSuggestion, members)
+        }));
+        setSuggestionType('agent');
+        setMaxColumnWidth(undefined);
+        return;
+      }
+    }
+
+    // Check for # to trigger Slack channel suggestions (requires Slack MCP server)
+    if (mode === 'prompt') {
+      const hashMatch = value.substring(0, effectiveCursorOffset).match(HASH_CHANNEL_RE);
+      if (hashMatch && hasSlackMcpServer(store.getState().mcp.clients)) {
+        debouncedFetchSlackChannels(hashMatch[2]!);
+        return;
+      } else if (suggestionType === 'slack-channel') {
+        debouncedFetchSlackChannels.cancel();
+        clearSuggestions();
+      }
+    }
+
+    // Check for @ symbol to trigger file suggestions (including quoted paths)
+    // Includes colon for MCP resources (e.g., server:resource/path)
+    const hasAtSymbol = value.substring(0, effectiveCursorOffset).match(HAS_AT_SYMBOL_RE);
+
+    // First, check for slash command suggestions (higher priority than @ symbol)
+    // Only show slash command selector if cursor is not on the "/" character itself
+    // Also don't show if cursor is at end of line with whitespace before it
+    // Don't show slash commands in bash mode
+    const isAtEndWithWhitespace = effectiveCursorOffset === value.length && effectiveCursorOffset > 0 && value.length > 0 && value[effectiveCursorOffset - 1] === ' ';
+
+    // Handle directory completion for commands
+    if (mode === 'prompt' && isCommandInput(value) && effectiveCursorOffset > 0) {
+      const parsedCommand = extractCommandNameAndArgs(value);
+      if (parsedCommand && parsedCommand.commandName === 'add-dir' && parsedCommand.args) {
+        const {
+          args
+        } = parsedCommand;
+
+        // Clear suggestions if args end with whitespace (user is done with path)
+        if (args.match(/\s+$/)) {
+          debouncedFetchFileSuggestions.cancel();
+          clearSuggestions();
+          return;
+        }
+        const dirSuggestions = await getDirectoryCompletions(args);
+        if (dirSuggestions.length > 0) {
+          setSuggestionsState(prev => ({
+            suggestions: dirSuggestions,
+            selectedSuggestion: getPreservedSelection(prev.suggestions, prev.selectedSuggestion, dirSuggestions),
+            commandArgumentHint: undefined
+          }));
+          setSuggestionType('directory');
+          return;
+        }
+
+        // No suggestions found - clear and return
+        debouncedFetchFileSuggestions.cancel();
+        clearSuggestions();
+        return;
+      }
+
+      // Handle custom title completion for /resume command
+      if (parsedCommand && parsedCommand.commandName === 'resume' && parsedCommand.args !== undefined && value.includes(' ')) {
+        const {
+          args
+        } = parsedCommand;
+
+        // Get custom title suggestions using partial match
+        const matches = await searchSessionsByCustomTitle(args, {
+          limit: 10
+        });
+        const suggestions = matches.map(log => {
+          const sessionId = getSessionIdFromLog(log);
+          return {
+            id: `resume-title-${sessionId}`,
+            displayText: log.customTitle!,
+            description: formatLogMetadata(log),
+            metadata: {
+              sessionId
+            }
+          };
+        });
+        if (suggestions.length > 0) {
+          setSuggestionsState(prev => ({
+            suggestions,
+            selectedSuggestion: getPreservedSelection(prev.suggestions, prev.selectedSuggestion, suggestions),
+            commandArgumentHint: undefined
+          }));
+          setSuggestionType('custom-title');
+          return;
+        }
+
+        // No suggestions found - clear and return
+        clearSuggestions();
+        return;
+      }
+    }
+
+    // Determine whether to display the argument hint and command suggestions.
+    if (mode === 'prompt' && isCommandInput(value) && effectiveCursorOffset > 0 && !hasCommandWithArguments(isAtEndWithWhitespace, value)) {
+      let commandArgumentHint: string | undefined = undefined;
+      if (value.length > 1) {
+        // We have a partial or complete command without arguments
+        // Check if it matches a command exactly and has an argument hint
+
+        // Extract command name: everything after / until the first space (or end)
+        const spaceIndex = value.indexOf(' ');
+        const commandName = spaceIndex === -1 ? value.slice(1) : value.slice(1, spaceIndex);
+
+        // Check if there are real arguments (non-whitespace after the command)
+        const hasRealArguments = spaceIndex !== -1 && value.slice(spaceIndex + 1).trim().length > 0;
+
+        // Check if input is exactly "command + single space" (ready for arguments)
+        const hasExactlyOneTrailingSpace = spaceIndex !== -1 && value.length === spaceIndex + 1;
+
+        // If input has a space after the command, don't show suggestions
+        // This prevents Enter from selecting a different command after Tab completion
+        if (spaceIndex !== -1) {
+          const exactMatch = commands.find(cmd => getCommandName(cmd) === commandName);
+          if (exactMatch || hasRealArguments) {
+            // Priority 1: Static argumentHint (only on first trailing space for backwards compat)
+            if (exactMatch?.argumentHint && hasExactlyOneTrailingSpace) {
+              commandArgumentHint = exactMatch.argumentHint;
+            }
+            // Priority 2: Progressive hint from argNames (show when trailing space)
+            else if (exactMatch?.type === 'prompt' && exactMatch.argNames?.length && value.endsWith(' ')) {
+              const argsText = value.slice(spaceIndex + 1);
+              const typedArgs = parseArguments(argsText);
+              commandArgumentHint = generateProgressiveArgumentHint(exactMatch.argNames, typedArgs);
+            }
+            setSuggestionsState(() => ({
+              commandArgumentHint,
+              suggestions: [],
+              selectedSuggestion: -1
+            }));
+            setSuggestionType('none');
+            setMaxColumnWidth(undefined);
+            return;
+          }
+        }
+
+        // Note: argument hint is only shown when there's exactly one trailing space
+        // (set above when hasExactlyOneTrailingSpace is true)
+      }
+      const commandItems = generateCommandSuggestions(value, commands);
+      setSuggestionsState(() => ({
+        commandArgumentHint,
+        suggestions: commandItems,
+        selectedSuggestion: commandItems.length > 0 ? 0 : -1
+      }));
+      setSuggestionType(commandItems.length > 0 ? 'command' : 'none');
+
+      // Use stable width from all commands (prevents layout shift when filtering)
+      if (commandItems.length > 0) {
+        setMaxColumnWidth(allCommandsMaxWidth);
+      }
+      return;
+    }
+    if (suggestionType === 'command') {
+      // If we had command suggestions but the input no longer starts with '/'
+      // we need to clear the suggestions. However, we should not return
+      // because there may be relevant @ symbol and file suggestions.
+      debouncedFetchFileSuggestions.cancel();
+      clearSuggestions();
+    } else if (isCommandInput(value) && hasCommandWithArguments(isAtEndWithWhitespace, value)) {
+      // If we have a command with arguments (no trailing space), clear any stale hint
+      // This prevents the hint from flashing when transitioning between states
+      setSuggestionsState(prev => prev.commandArgumentHint ? {
+        ...prev,
+        commandArgumentHint: undefined
+      } : prev);
+    }
+    if (suggestionType === 'custom-title') {
+      // If we had custom-title suggestions but the input is no longer /resume
+      // we need to clear the suggestions.
+      clearSuggestions();
+    }
+    if (suggestionType === 'agent' && suggestionsRef.current.some((s: SuggestionItem) => s.id?.startsWith('dm-'))) {
+      // If we had team member suggestions but the input no longer has @
+      // we need to clear the suggestions.
+      const hasAt = value.substring(0, effectiveCursorOffset).match(/(^|\s)@([\w-]*)$/);
+      if (!hasAt) {
+        clearSuggestions();
+      }
+    }
+
+    // Check for @ symbol to trigger file and MCP resource suggestions
+    // Skip @ autocomplete in bash mode - @ has no special meaning in shell commands
+    if (hasAtSymbol && mode !== 'bash') {
+      // Get the @ token (including the @ symbol)
+      const completionToken = extractCompletionToken(value, effectiveCursorOffset, true);
+      if (completionToken && completionToken.token.startsWith('@')) {
+        const searchToken = extractSearchToken(completionToken);
+
+        // If the token after @ is path-like, use path completion instead of fuzzy search
+        // This handles cases like @~/path, @./path, @/path for directory traversal
+        if (isPathLikeToken(searchToken)) {
+          latestPathTokenRef.current = searchToken;
+          const pathSuggestions = await getPathCompletions(searchToken, {
+            maxResults: 10
+          });
+          // Discard stale results if a newer query was initiated while waiting
+          if (latestPathTokenRef.current !== searchToken) {
+            return;
+          }
+          if (pathSuggestions.length > 0) {
+            setSuggestionsState(prev => ({
+              suggestions: pathSuggestions,
+              selectedSuggestion: getPreservedSelection(prev.suggestions, prev.selectedSuggestion, pathSuggestions),
+              commandArgumentHint: undefined
+            }));
+            setSuggestionType('directory');
+            return;
+          }
+        }
+
+        // Skip if we already fetched for this exact token (prevents loop from
+        // suggestions dependency causing updateSuggestions to be recreated)
+        if (latestSearchTokenRef.current === searchToken) {
+          return;
+        }
+        void debouncedFetchFileSuggestions(searchToken, true);
+        return;
+      }
+    }
+
+    // If we have active file suggestions or the input changed, check for file suggestions
+    if (suggestionType === 'file') {
+      const completionToken = extractCompletionToken(value, effectiveCursorOffset, true);
+      if (completionToken) {
+        const searchToken = extractSearchToken(completionToken);
+        // Skip if we already fetched for this exact token
+        if (latestSearchTokenRef.current === searchToken) {
+          return;
+        }
+        void debouncedFetchFileSuggestions(searchToken, false);
+      } else {
+        // If we had file suggestions but now there's no completion token
+        debouncedFetchFileSuggestions.cancel();
+        clearSuggestions();
+      }
+    }
+
+    // Clear shell suggestions if not in bash mode OR if input has changed
+    if (suggestionType === 'shell') {
+      const inputSnapshot = (suggestionsRef.current[0]?.metadata as {
+        inputSnapshot?: string;
+      })?.inputSnapshot;
+      if (mode !== 'bash' || value !== inputSnapshot) {
+        debouncedFetchFileSuggestions.cancel();
+        clearSuggestions();
+      }
+    }
+  }, [suggestionType, commands, setSuggestionsState, clearSuggestions, debouncedFetchFileSuggestions, debouncedFetchSlackChannels, mode, suppressSuggestions,
+  // Note: using suggestionsRef instead of suggestions to avoid recreating
+  // this callback when only selectedSuggestion changes (not the suggestions list)
+  allCommandsMaxWidth]);
+
+  // Update suggestions when input changes
+  // Note: We intentionally don't depend on cursorOffset here - cursor movement alone
+  // shouldn't re-trigger suggestions. The cursorOffsetRef is used to get the current
+  // position when needed without causing re-renders.
+  useEffect(() => {
+    // If suggestions were dismissed for this exact input, don't re-trigger
+    if (dismissedForInputRef.current === input) {
+      return;
+    }
+    // When the actual input text changes (not just updateSuggestions being recreated),
+    // reset the search token ref so the same query can be re-fetched.
+    // This fixes: type @readme.md, clear, retype @readme.md → no suggestions.
+    if (prevInputRef.current !== input) {
+      prevInputRef.current = input;
+      latestSearchTokenRef.current = null;
+    }
+    // Clear the dismissed state when input changes
+    dismissedForInputRef.current = null;
+    void updateSuggestions(input);
+  }, [input, updateSuggestions]);
+
+  // Handle tab key press - complete suggestions or trigger file suggestions
+  const handleTab = useCallback(async () => {
+    // If we have inline ghost text, apply it
+    if (effectiveGhostText) {
+      // Check for bash mode history completion first
+      if (mode === 'bash') {
+        // Replace the input with the full command from history
+        onInputChange(effectiveGhostText.fullCommand);
+        setCursorOffset(effectiveGhostText.fullCommand.length);
+        setInlineGhostText(undefined);
+        return;
+      }
+
+      // Find the mid-input command to get its position (for prompt mode)
+      const midInputCommand = findMidInputSlashCommand(input, cursorOffset);
+      if (midInputCommand) {
+        // Replace the partial command with the full command + space
+        const before = input.slice(0, midInputCommand.startPos);
+        const after = input.slice(midInputCommand.startPos + midInputCommand.token.length);
+        const newInput = before + '/' + effectiveGhostText.fullCommand + ' ' + after;
+        const newCursorOffset = midInputCommand.startPos + 1 + effectiveGhostText.fullCommand.length + 1;
+        onInputChange(newInput);
+        setCursorOffset(newCursorOffset);
+        return;
+      }
+    }
+
+    // If we have active suggestions, select one
+    if (suggestions.length > 0) {
+      // Cancel any pending debounced fetches to prevent flicker when accepting
+      debouncedFetchFileSuggestions.cancel();
+      debouncedFetchSlackChannels.cancel();
+      const index = selectedSuggestion === -1 ? 0 : selectedSuggestion;
+      const suggestion = suggestions[index];
+      if (suggestionType === 'command' && index < suggestions.length) {
+        if (suggestion) {
+          applyCommandSuggestion(suggestion, false,
+          // don't execute on tab
+          commands, onInputChange, setCursorOffset, onSubmit);
+          clearSuggestions();
+        }
+      } else if (suggestionType === 'custom-title' && suggestions.length > 0) {
+        // Apply custom title to /resume command with sessionId
+        if (suggestion) {
+          const newInput = buildResumeInputFromSuggestion(suggestion);
+          onInputChange(newInput);
+          setCursorOffset(newInput.length);
+          clearSuggestions();
+        }
+      } else if (suggestionType === 'directory' && suggestions.length > 0) {
+        const suggestion = suggestions[index];
+        if (suggestion) {
+          // Check if this is a command context (e.g., /add-dir) or general path completion
+          const isInCommandContext = isCommandInput(input);
+          let newInput: string;
+          if (isInCommandContext) {
+            // Command context: replace just the argument portion
+            const spaceIndex = input.indexOf(' ');
+            const commandPart = input.slice(0, spaceIndex + 1); // Include the space
+            const cmdSuffix = isPathMetadata(suggestion.metadata) && suggestion.metadata.type === 'directory' ? '/' : ' ';
+            newInput = commandPart + suggestion.id + cmdSuffix;
+            onInputChange(newInput);
+            setCursorOffset(newInput.length);
+            if (isPathMetadata(suggestion.metadata) && suggestion.metadata.type === 'directory') {
+              // For directories, fetch new suggestions for the updated path
+              setSuggestionsState(prev => ({
+                ...prev,
+                commandArgumentHint: undefined
+              }));
+              void updateSuggestions(newInput, newInput.length);
+            } else {
+              clearSuggestions();
+            }
+          } else {
+            // General path completion: replace the path token in input with @-prefixed path
+            // Try to get token with @ prefix first to check if already prefixed
+            const completionTokenWithAt = extractCompletionToken(input, cursorOffset, true);
+            const completionToken = completionTokenWithAt ?? extractCompletionToken(input, cursorOffset, false);
+            if (completionToken) {
+              const isDir = isPathMetadata(suggestion.metadata) && suggestion.metadata.type === 'directory';
+              const result = applyDirectorySuggestion(input, suggestion.id, completionToken.startPos, completionToken.token.length, isDir);
+              newInput = result.newInput;
+              onInputChange(newInput);
+              setCursorOffset(result.cursorPos);
+              if (isDir) {
+                // For directories, fetch new suggestions for the updated path
+                setSuggestionsState(prev => ({
+                  ...prev,
+                  commandArgumentHint: undefined
+                }));
+                void updateSuggestions(newInput, result.cursorPos);
+              } else {
+                // For files, clear suggestions
+                clearSuggestions();
+              }
+            } else {
+              // No completion token found (e.g., cursor after space) - just clear suggestions
+              // without modifying input to avoid data loss
+              clearSuggestions();
+            }
+          }
+        }
+      } else if (suggestionType === 'shell' && suggestions.length > 0) {
+        const suggestion = suggestions[index];
+        if (suggestion) {
+          const metadata = suggestion.metadata as {
+            completionType: ShellCompletionType;
+          } | undefined;
+          applyShellSuggestion(suggestion, input, cursorOffset, onInputChange, setCursorOffset, metadata?.completionType);
+          clearSuggestions();
+        }
+      } else if (suggestionType === 'agent' && suggestions.length > 0 && suggestions[index]?.id?.startsWith('dm-')) {
+        const suggestion = suggestions[index];
+        if (suggestion) {
+          applyTriggerSuggestion(suggestion, input, cursorOffset, DM_MEMBER_RE, onInputChange, setCursorOffset);
+          clearSuggestions();
+        }
+      } else if (suggestionType === 'slack-channel' && suggestions.length > 0) {
+        const suggestion = suggestions[index];
+        if (suggestion) {
+          applyTriggerSuggestion(suggestion, input, cursorOffset, HASH_CHANNEL_RE, onInputChange, setCursorOffset);
+          clearSuggestions();
+        }
+      } else if (suggestionType === 'file' && suggestions.length > 0) {
+        const completionToken = extractCompletionToken(input, cursorOffset, true);
+        if (!completionToken) {
+          clearSuggestions();
+          return;
+        }
+
+        // Check if all suggestions share a common prefix longer than the current input
+        const commonPrefix = findLongestCommonPrefix(suggestions);
+
+        // Determine if token starts with @ to preserve it during replacement
+        const hasAtPrefix = completionToken.token.startsWith('@');
+        // The effective token length excludes the @ and quotes if present
+        let effectiveTokenLength: number;
+        if (completionToken.isQuoted) {
+          // Remove @" prefix and optional closing " to get effective length
+          effectiveTokenLength = completionToken.token.slice(2).replace(/"$/, '').length;
+        } else if (hasAtPrefix) {
+          effectiveTokenLength = completionToken.token.length - 1;
+        } else {
+          effectiveTokenLength = completionToken.token.length;
+        }
+
+        // If there's a common prefix longer than what the user has typed,
+        // replace the current input with the common prefix
+        if (commonPrefix.length > effectiveTokenLength) {
+          const replacementValue = formatReplacementValue({
+            displayText: commonPrefix,
+            mode,
+            hasAtPrefix,
+            needsQuotes: false,
+            // common prefix doesn't need quotes unless already quoted
+            isQuoted: completionToken.isQuoted,
+            isComplete: false // partial completion
+          });
+          applyFileSuggestion(replacementValue, input, completionToken.token, completionToken.startPos, onInputChange, setCursorOffset);
+          // Don't clear suggestions so user can continue typing or select a specific option
+          // Instead, update for the new prefix
+          void updateSuggestions(input.replace(completionToken.token, replacementValue), cursorOffset);
+        } else if (index < suggestions.length) {
+          // Otherwise, apply the selected suggestion
+          const suggestion = suggestions[index];
+          if (suggestion) {
+            const needsQuotes = suggestion.displayText.includes(' ');
+            const replacementValue = formatReplacementValue({
+              displayText: suggestion.displayText,
+              mode,
+              hasAtPrefix,
+              needsQuotes,
+              isQuoted: completionToken.isQuoted,
+              isComplete: true // complete suggestion
+            });
+            applyFileSuggestion(replacementValue, input, completionToken.token, completionToken.startPos, onInputChange, setCursorOffset);
+            clearSuggestions();
+          }
+        }
+      }
+    } else if (input.trim() !== '') {
+      let suggestionType: SuggestionType;
+      let suggestionItems: SuggestionItem[];
+      if (mode === 'bash') {
+        suggestionType = 'shell';
+        // This should be very fast, taking <10ms
+        const bashSuggestions = await generateBashSuggestions(input, cursorOffset);
+        if (bashSuggestions.length === 1) {
+          // If single suggestion, apply it immediately
+          const suggestion = bashSuggestions[0];
+          if (suggestion) {
+            const metadata = suggestion.metadata as {
+              completionType: ShellCompletionType;
+            } | undefined;
+            applyShellSuggestion(suggestion, input, cursorOffset, onInputChange, setCursorOffset, metadata?.completionType);
+          }
+          suggestionItems = [];
+        } else {
+          suggestionItems = bashSuggestions;
+        }
+      } else {
+        suggestionType = 'file';
+        // If no suggestions, fetch file and MCP resource suggestions
+        const completionInfo = extractCompletionToken(input, cursorOffset, true);
+        if (completionInfo) {
+          // If token starts with @, search without the @ prefix
+          const isAtSymbol = completionInfo.token.startsWith('@');
+          const searchToken = isAtSymbol ? completionInfo.token.substring(1) : completionInfo.token;
+          suggestionItems = await generateUnifiedSuggestions(searchToken, mcpResources, agents, isAtSymbol);
+        } else {
+          suggestionItems = [];
+        }
+      }
+      if (suggestionItems.length > 0) {
+        // Multiple suggestions or not bash mode: show list
+        setSuggestionsState(prev => ({
+          commandArgumentHint: undefined,
+          suggestions: suggestionItems,
+          selectedSuggestion: getPreservedSelection(prev.suggestions, prev.selectedSuggestion, suggestionItems)
+        }));
+        setSuggestionType(suggestionType);
+        setMaxColumnWidth(undefined);
+      }
+    }
+  }, [suggestions, selectedSuggestion, input, suggestionType, commands, mode, onInputChange, setCursorOffset, onSubmit, clearSuggestions, cursorOffset, updateSuggestions, mcpResources, setSuggestionsState, agents, debouncedFetchFileSuggestions, debouncedFetchSlackChannels, effectiveGhostText]);
+
+  // Handle enter key press - apply and execute suggestions
+  const handleEnter = useCallback(() => {
+    if (selectedSuggestion < 0 || suggestions.length === 0) return;
+    const suggestion = suggestions[selectedSuggestion];
+    if (suggestionType === 'command' && selectedSuggestion < suggestions.length) {
+      if (suggestion) {
+        applyCommandSuggestion(suggestion, true,
+        // execute on return
+        commands, onInputChange, setCursorOffset, onSubmit);
+        debouncedFetchFileSuggestions.cancel();
+        clearSuggestions();
+      }
+    } else if (suggestionType === 'custom-title' && selectedSuggestion < suggestions.length) {
+      // Apply custom title and execute /resume command with sessionId
+      if (suggestion) {
+        const newInput = buildResumeInputFromSuggestion(suggestion);
+        onInputChange(newInput);
+        setCursorOffset(newInput.length);
+        onSubmit(newInput, /* isSubmittingSlashCommand */true);
+        debouncedFetchFileSuggestions.cancel();
+        clearSuggestions();
+      }
+    } else if (suggestionType === 'shell' && selectedSuggestion < suggestions.length) {
+      const suggestion = suggestions[selectedSuggestion];
+      if (suggestion) {
+        const metadata = suggestion.metadata as {
+          completionType: ShellCompletionType;
+        } | undefined;
+        applyShellSuggestion(suggestion, input, cursorOffset, onInputChange, setCursorOffset, metadata?.completionType);
+        debouncedFetchFileSuggestions.cancel();
+        clearSuggestions();
+      }
+    } else if (suggestionType === 'agent' && selectedSuggestion < suggestions.length && suggestion?.id?.startsWith('dm-')) {
+      applyTriggerSuggestion(suggestion, input, cursorOffset, DM_MEMBER_RE, onInputChange, setCursorOffset);
+      debouncedFetchFileSuggestions.cancel();
+      clearSuggestions();
+    } else if (suggestionType === 'slack-channel' && selectedSuggestion < suggestions.length) {
+      if (suggestion) {
+        applyTriggerSuggestion(suggestion, input, cursorOffset, HASH_CHANNEL_RE, onInputChange, setCursorOffset);
+        debouncedFetchSlackChannels.cancel();
+        clearSuggestions();
+      }
+    } else if (suggestionType === 'file' && selectedSuggestion < suggestions.length) {
+      // Extract completion token directly when needed
+      const completionInfo = extractCompletionToken(input, cursorOffset, true);
+      if (completionInfo) {
+        if (suggestion) {
+          const hasAtPrefix = completionInfo.token.startsWith('@');
+          const needsQuotes = suggestion.displayText.includes(' ');
+          const replacementValue = formatReplacementValue({
+            displayText: suggestion.displayText,
+            mode,
+            hasAtPrefix,
+            needsQuotes,
+            isQuoted: completionInfo.isQuoted,
+            isComplete: true // complete suggestion
+          });
+          applyFileSuggestion(replacementValue, input, completionInfo.token, completionInfo.startPos, onInputChange, setCursorOffset);
+          debouncedFetchFileSuggestions.cancel();
+          clearSuggestions();
+        }
+      }
+    } else if (suggestionType === 'directory' && selectedSuggestion < suggestions.length) {
+      if (suggestion) {
+        // In command context (e.g., /add-dir), Enter submits the command
+        // rather than applying the directory suggestion. Just clear
+        // suggestions and let the submit handler process the current input.
+        if (isCommandInput(input)) {
+          debouncedFetchFileSuggestions.cancel();
+          clearSuggestions();
+          return;
+        }
+
+        // General path completion: replace the path token
+        const completionTokenWithAt = extractCompletionToken(input, cursorOffset, true);
+        const completionToken = completionTokenWithAt ?? extractCompletionToken(input, cursorOffset, false);
+        if (completionToken) {
+          const isDir = isPathMetadata(suggestion.metadata) && suggestion.metadata.type === 'directory';
+          const result = applyDirectorySuggestion(input, suggestion.id, completionToken.startPos, completionToken.token.length, isDir);
+          onInputChange(result.newInput);
+          setCursorOffset(result.cursorPos);
+        }
+        // If no completion token found (e.g., cursor after space), don't modify input
+        // to avoid data loss - just clear suggestions
+
+        debouncedFetchFileSuggestions.cancel();
+        clearSuggestions();
+      }
+    }
+  }, [suggestions, selectedSuggestion, suggestionType, commands, input, cursorOffset, mode, onInputChange, setCursorOffset, onSubmit, clearSuggestions, debouncedFetchFileSuggestions, debouncedFetchSlackChannels]);
+
+  // Handler for autocomplete:accept - accepts current suggestion via Tab or Right Arrow
+  const handleAutocompleteAccept = useCallback(() => {
+    void handleTab();
+  }, [handleTab]);
+
+  // Handler for autocomplete:dismiss - clears suggestions and prevents re-triggering
+  const handleAutocompleteDismiss = useCallback(() => {
+    debouncedFetchFileSuggestions.cancel();
+    debouncedFetchSlackChannels.cancel();
+    clearSuggestions();
+    // Remember the input when dismissed to prevent immediate re-triggering
+    dismissedForInputRef.current = input;
+  }, [debouncedFetchFileSuggestions, debouncedFetchSlackChannels, clearSuggestions, input]);
+
+  // Handler for autocomplete:previous - selects previous suggestion
+  const handleAutocompletePrevious = useCallback(() => {
+    setSuggestionsState(prev => ({
+      ...prev,
+      selectedSuggestion: prev.selectedSuggestion <= 0 ? suggestions.length - 1 : prev.selectedSuggestion - 1
+    }));
+  }, [suggestions.length, setSuggestionsState]);
+
+  // Handler for autocomplete:next - selects next suggestion
+  const handleAutocompleteNext = useCallback(() => {
+    setSuggestionsState(prev => ({
+      ...prev,
+      selectedSuggestion: prev.selectedSuggestion >= suggestions.length - 1 ? 0 : prev.selectedSuggestion + 1
+    }));
+  }, [suggestions.length, setSuggestionsState]);
+
+  // Autocomplete context keybindings - only active when suggestions are visible
+  const autocompleteHandlers = useMemo(() => ({
+    'autocomplete:accept': handleAutocompleteAccept,
+    'autocomplete:dismiss': handleAutocompleteDismiss,
+    'autocomplete:previous': handleAutocompletePrevious,
+    'autocomplete:next': handleAutocompleteNext
+  }), [handleAutocompleteAccept, handleAutocompleteDismiss, handleAutocompletePrevious, handleAutocompleteNext]);
+
+  // Register autocomplete as an overlay so CancelRequestHandler defers ESC handling
+  // This ensures ESC dismisses autocomplete before canceling running tasks
+  const isAutocompleteActive = suggestions.length > 0 || !!effectiveGhostText;
+  const isModalOverlayActive = useIsModalOverlayActive();
+  useRegisterOverlay('autocomplete', isAutocompleteActive);
+  // Register Autocomplete context so it appears in activeContexts for other handlers.
+  // This allows Chat's resolver to see Autocomplete and defer to its bindings for up/down.
+  useRegisterKeybindingContext('Autocomplete', isAutocompleteActive);
+
+  // Disable autocomplete keybindings when a modal overlay (e.g., DiffDialog) is active,
+  // so escape reaches the overlay's handler instead of dismissing autocomplete
+  useKeybindings(autocompleteHandlers, {
+    context: 'Autocomplete',
+    isActive: isAutocompleteActive && !isModalOverlayActive
+  });
+  function acceptSuggestionText(text: string): void {
+    const detectedMode = getModeFromInput(text);
+    if (detectedMode !== 'prompt' && onModeChange) {
+      onModeChange(detectedMode);
+      const stripped = getValueFromInput(text);
+      onInputChange(stripped);
+      setCursorOffset(stripped.length);
+    } else {
+      onInputChange(text);
+      setCursorOffset(text.length);
+    }
+  }
+
+  // Handle keyboard input for behaviors not covered by keybindings
+  const handleKeyDown = (e: KeyboardEvent): void => {
+    // Handle right arrow to accept prompt suggestion ghost text
+    if (e.key === 'right' && !isViewingTeammate) {
+      const suggestionText = promptSuggestion.text;
+      const suggestionShownAt = promptSuggestion.shownAt;
+      if (suggestionText && suggestionShownAt > 0 && input === '') {
+        markAccepted();
+        acceptSuggestionText(suggestionText);
+        e.stopImmediatePropagation();
+        return;
+      }
+    }
+
+    // Handle Tab key fallback behaviors when no autocomplete suggestions
+    // Don't handle tab if shift is pressed (used for mode cycle)
+    if (e.key === 'tab' && !e.shift) {
+      // Skip if autocomplete is handling this (suggestions or ghost text exist)
+      if (suggestions.length > 0 || effectiveGhostText) {
+        return;
+      }
+      // Accept prompt suggestion if it exists in AppState
+      const suggestionText = promptSuggestion.text;
+      const suggestionShownAt = promptSuggestion.shownAt;
+      if (suggestionText && suggestionShownAt > 0 && input === '' && !isViewingTeammate) {
+        e.preventDefault();
+        markAccepted();
+        acceptSuggestionText(suggestionText);
+        return;
+      }
+      // Remind user about thinking toggle shortcut if empty input
+      if (input.trim() === '') {
+        e.preventDefault();
+        addNotification({
+          key: 'thinking-toggle-hint',
+          jsx: <Text dimColor>
+              Use {thinkingToggleShortcut} to toggle thinking
+            </Text>,
+          priority: 'immediate',
+          timeoutMs: 3000
+        });
+      }
+      return;
+    }
+
+    // Only continue with navigation if we have suggestions
+    if (suggestions.length === 0) return;
+
+    // Handle Ctrl-N/P for navigation (arrows handled by keybindings)
+    // Skip if we're in the middle of a chord sequence to allow chords like ctrl+f n
+    const hasPendingChord = keybindingContext?.pendingChord != null;
+    if (e.ctrl && e.key === 'n' && !hasPendingChord) {
+      e.preventDefault();
+      handleAutocompleteNext();
+      return;
+    }
+    if (e.ctrl && e.key === 'p' && !hasPendingChord) {
+      e.preventDefault();
+      handleAutocompletePrevious();
+      return;
+    }
+
+    // Handle selection and execution via return/enter
+    // Shift+Enter and Meta+Enter insert newlines (handled by useTextInput),
+    // so don't accept the suggestion for those.
+    if (e.key === 'return' && !e.shift && !e.meta) {
+      e.preventDefault();
+      handleEnter();
+    }
+  };
+
+  // Backward-compat bridge: PromptInput doesn't yet wire handleKeyDown to
+  // <Box onKeyDown>. Subscribe via useInput and adapt InputEvent →
+  // KeyboardEvent until the consumer is migrated (separate PR).
+  // TODO(onKeyDown-migration): remove once PromptInput passes handleKeyDown.
+  useInput((_input, _key, event) => {
+    const kbEvent = new KeyboardEvent(event.keypress);
+    handleKeyDown(kbEvent);
+    if (kbEvent.didStopImmediatePropagation()) {
+      event.stopImmediatePropagation();
+    }
+  });
+  return {
+    suggestions,
+    selectedSuggestion,
+    suggestionType,
+    maxColumnWidth,
+    commandArgumentHint,
+    inlineGhostText: effectiveGhostText,
+    handleKeyDown
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useMemo","useRef","useState","useNotifications","Text","logEvent","useDebounceCallback","Command","getCommandName","getModeFromInput","getValueFromInput","SuggestionItem","SuggestionType","useIsModalOverlayActive","useRegisterOverlay","KeyboardEvent","useInput","useOptionalKeybindingContext","useRegisterKeybindingContext","useKeybindings","useShortcutDisplay","useAppState","useAppStateStore","AgentDefinition","InlineGhostText","PromptInputMode","isAgentSwarmsEnabled","generateProgressiveArgumentHint","parseArguments","getShellCompletions","ShellCompletionType","formatLogMetadata","getSessionIdFromLog","searchSessionsByCustomTitle","applyCommandSuggestion","findMidInputSlashCommand","generateCommandSuggestions","getBestCommandMatch","isCommandInput","getDirectoryCompletions","getPathCompletions","isPathLikeToken","getShellHistoryCompletion","getSlackChannelSuggestions","hasSlackMcpServer","TEAM_LEAD_NAME","applyFileSuggestion","findLongestCommonPrefix","onIndexBuildComplete","startBackgroundCacheRefresh","generateUnifiedSuggestions","AT_TOKEN_HEAD_RE","PATH_CHAR_HEAD_RE","TOKEN_WITH_AT_RE","TOKEN_WITHOUT_AT_RE","HAS_AT_SYMBOL_RE","HASH_CHANNEL_RE","isPathMetadata","metadata","type","getPreservedSelection","prevSuggestions","prevSelection","newSuggestions","length","prevSelectedItem","newIndex","findIndex","item","id","buildResumeInputFromSuggestion","suggestion","sessionId","displayText","Props","onInputChange","value","onSubmit","isSubmittingSlashCommand","setCursorOffset","offset","input","cursorOffset","commands","mode","agents","setSuggestionsState","f","previousSuggestionsState","suggestions","selectedSuggestion","commandArgumentHint","suggestionsState","suppressSuggestions","markAccepted","onModeChange","UseTypeaheadResult","suggestionType","maxColumnWidth","inlineGhostText","handleKeyDown","e","extractSearchToken","completionToken","token","isQuoted","slice","replace","startsWith","substring","formatReplacementValue","options","hasAtPrefix","needsQuotes","isComplete","space","applyShellSuggestion","completionType","beforeCursor","lastSpaceIndex","lastIndexOf","wordStart","replacementText","newInput","DM_MEMBER_RE","applyTriggerSuggestion","triggerRe","RegExp","m","match","index","undefined","prefixStart","before","currentShellCompletionAbortController","AbortController","generateBashSuggestions","Promise","abort","signal","applyDirectorySuggestion","suggestionId","tokenStartPos","tokenLength","isDirectory","cursorPos","suffix","after","replacement","extractCompletionToken","text","includeAtSymbol","startPos","textBeforeCursor","quotedAtRegex","quotedMatch","textAfterCursor","afterQuotedMatch","quotedSuffix","atIdx","test","fromAt","atHeadMatch","afterMatch","tokenSuffix","tokenRegex","extractCommandNameAndArgs","commandName","args","spaceIndex","indexOf","hasCommandWithArguments","isAtEndWithWhitespace","includes","endsWith","useTypeahead","addNotification","thinkingToggleShortcut","setSuggestionType","allCommandsMaxWidth","visibleCommands","filter","cmd","isHidden","maxLen","Math","max","map","setMaxColumnWidth","mcpResources","s","mcp","resources","store","promptSuggestion","isViewingTeammate","viewingAgentTaskId","keybindingContext","setInlineGhostText","syncPromptGhostText","midInputCommand","partialCommand","fullCommand","insertPosition","effectiveGhostText","cursorOffsetRef","current","latestSearchTokenRef","prevInputRef","latestPathTokenRef","latestBashInputRef","latestSlackTokenRef","suggestionsRef","dismissedForInputRef","clearSuggestions","fetchFileSuggestions","searchToken","isAtSymbol","combinedItems","prev","debouncedFetchFileSuggestions","fetchSlackChannels","partial","channels","getState","clients","debouncedFetchSlackChannels","updateSuggestions","inputCursorOffset","effectiveCursorOffset","cancel","trim","historyMatch","atMatch","partialName","toLowerCase","state","members","seen","Set","teamContext","t","Object","values","teammates","name","add","push","description","agentId","agentNameRegistry","has","status","tasks","hashMatch","hasAtSymbol","parsedCommand","dirSuggestions","matches","limit","log","customTitle","hasRealArguments","hasExactlyOneTrailingSpace","exactMatch","find","argumentHint","argNames","argsText","typedArgs","commandItems","some","hasAt","pathSuggestions","maxResults","inputSnapshot","handleTab","newCursorOffset","isInCommandContext","commandPart","cmdSuffix","completionTokenWithAt","isDir","result","commonPrefix","effectiveTokenLength","replacementValue","suggestionItems","bashSuggestions","completionInfo","handleEnter","handleAutocompleteAccept","handleAutocompleteDismiss","handleAutocompletePrevious","handleAutocompleteNext","autocompleteHandlers","isAutocompleteActive","isModalOverlayActive","context","isActive","acceptSuggestionText","detectedMode","stripped","key","suggestionText","suggestionShownAt","shownAt","stopImmediatePropagation","shift","preventDefault","jsx","priority","timeoutMs","hasPendingChord","pendingChord","ctrl","meta","_input","_key","event","kbEvent","keypress","didStopImmediatePropagation"],"sources":["useTypeahead.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react'\nimport { useNotifications } from 'src/context/notifications.js'\nimport { Text } from 'src/ink.js'\nimport { logEvent } from 'src/services/analytics/index.js'\nimport { useDebounceCallback } from 'usehooks-ts'\nimport { type Command, getCommandName } from '../commands.js'\nimport {\n  getModeFromInput,\n  getValueFromInput,\n} from '../components/PromptInput/inputModes.js'\nimport type {\n  SuggestionItem,\n  SuggestionType,\n} from '../components/PromptInput/PromptInputFooterSuggestions.js'\nimport {\n  useIsModalOverlayActive,\n  useRegisterOverlay,\n} from '../context/overlayContext.js'\nimport { KeyboardEvent } from '../ink/events/keyboard-event.js'\n// eslint-disable-next-line custom-rules/prefer-use-keybindings -- backward-compat bridge until consumers wire handleKeyDown to <Box onKeyDown>\nimport { useInput } from '../ink.js'\nimport {\n  useOptionalKeybindingContext,\n  useRegisterKeybindingContext,\n} from '../keybindings/KeybindingContext.js'\nimport { useKeybindings } from '../keybindings/useKeybinding.js'\nimport { useShortcutDisplay } from '../keybindings/useShortcutDisplay.js'\nimport { useAppState, useAppStateStore } from '../state/AppState.js'\nimport type { AgentDefinition } from '../tools/AgentTool/loadAgentsDir.js'\nimport type {\n  InlineGhostText,\n  PromptInputMode,\n} from '../types/textInputTypes.js'\nimport { isAgentSwarmsEnabled } from '../utils/agentSwarmsEnabled.js'\nimport {\n  generateProgressiveArgumentHint,\n  parseArguments,\n} from '../utils/argumentSubstitution.js'\nimport {\n  getShellCompletions,\n  type ShellCompletionType,\n} from '../utils/bash/shellCompletion.js'\nimport { formatLogMetadata } from '../utils/format.js'\nimport {\n  getSessionIdFromLog,\n  searchSessionsByCustomTitle,\n} from '../utils/sessionStorage.js'\nimport {\n  applyCommandSuggestion,\n  findMidInputSlashCommand,\n  generateCommandSuggestions,\n  getBestCommandMatch,\n  isCommandInput,\n} from '../utils/suggestions/commandSuggestions.js'\nimport {\n  getDirectoryCompletions,\n  getPathCompletions,\n  isPathLikeToken,\n} from '../utils/suggestions/directoryCompletion.js'\nimport { getShellHistoryCompletion } from '../utils/suggestions/shellHistoryCompletion.js'\nimport {\n  getSlackChannelSuggestions,\n  hasSlackMcpServer,\n} from '../utils/suggestions/slackChannelSuggestions.js'\nimport { TEAM_LEAD_NAME } from '../utils/swarm/constants.js'\nimport {\n  applyFileSuggestion,\n  findLongestCommonPrefix,\n  onIndexBuildComplete,\n  startBackgroundCacheRefresh,\n} from './fileSuggestions.js'\nimport { generateUnifiedSuggestions } from './unifiedSuggestions.js'\n\n// Unicode-aware character class for file path tokens:\n// \\p{L} = letters (CJK, Latin, Cyrillic, etc.)\n// \\p{N} = numbers (incl. fullwidth)\n// \\p{M} = combining marks (macOS NFD accents, Devanagari vowel signs)\nconst AT_TOKEN_HEAD_RE = /^@[\\p{L}\\p{N}\\p{M}_\\-./\\\\()[\\]~:]*/u\nconst PATH_CHAR_HEAD_RE = /^[\\p{L}\\p{N}\\p{M}_\\-./\\\\()[\\]~:]+/u\nconst TOKEN_WITH_AT_RE =\n  /(@[\\p{L}\\p{N}\\p{M}_\\-./\\\\()[\\]~:]*|[\\p{L}\\p{N}\\p{M}_\\-./\\\\()[\\]~:]+)$/u\nconst TOKEN_WITHOUT_AT_RE = /[\\p{L}\\p{N}\\p{M}_\\-./\\\\()[\\]~:]+$/u\nconst HAS_AT_SYMBOL_RE = /(^|\\s)@([\\p{L}\\p{N}\\p{M}_\\-./\\\\()[\\]~:]*|\"[^\"]*\"?)$/u\nconst HASH_CHANNEL_RE = /(^|\\s)#([a-z0-9][a-z0-9_-]*)$/\n\n// Type guard for path completion metadata\nfunction isPathMetadata(\n  metadata: unknown,\n): metadata is { type: 'directory' | 'file' } {\n  return (\n    typeof metadata === 'object' &&\n    metadata !== null &&\n    'type' in metadata &&\n    (metadata.type === 'directory' || metadata.type === 'file')\n  )\n}\n\n// Helper to determine selectedSuggestion when updating suggestions\nfunction getPreservedSelection(\n  prevSuggestions: SuggestionItem[],\n  prevSelection: number,\n  newSuggestions: SuggestionItem[],\n): number {\n  // No new suggestions\n  if (newSuggestions.length === 0) {\n    return -1\n  }\n\n  // No previous selection\n  if (prevSelection < 0) {\n    return 0\n  }\n\n  // Get the previously selected item\n  const prevSelectedItem = prevSuggestions[prevSelection]\n  if (!prevSelectedItem) {\n    return 0\n  }\n\n  // Try to find the same item in the new list by ID\n  const newIndex = newSuggestions.findIndex(\n    item => item.id === prevSelectedItem.id,\n  )\n\n  // Return the new index if found, otherwise default to 0\n  return newIndex >= 0 ? newIndex : 0\n}\n\nfunction buildResumeInputFromSuggestion(suggestion: SuggestionItem): string {\n  const metadata = suggestion.metadata as { sessionId: string } | undefined\n  return metadata?.sessionId\n    ? `/resume ${metadata.sessionId}`\n    : `/resume ${suggestion.displayText}`\n}\n\ntype Props = {\n  onInputChange: (value: string) => void\n  onSubmit: (value: string, isSubmittingSlashCommand?: boolean) => void\n  setCursorOffset: (offset: number) => void\n  input: string\n  cursorOffset: number\n  commands: Command[]\n  mode: string\n  agents: AgentDefinition[]\n  setSuggestionsState: (\n    f: (previousSuggestionsState: {\n      suggestions: SuggestionItem[]\n      selectedSuggestion: number\n      commandArgumentHint?: string\n    }) => {\n      suggestions: SuggestionItem[]\n      selectedSuggestion: number\n      commandArgumentHint?: string\n    },\n  ) => void\n  suggestionsState: {\n    suggestions: SuggestionItem[]\n    selectedSuggestion: number\n    commandArgumentHint?: string\n  }\n  suppressSuggestions?: boolean\n  markAccepted: () => void\n  onModeChange?: (mode: PromptInputMode) => void\n}\n\ntype UseTypeaheadResult = {\n  suggestions: SuggestionItem[]\n  selectedSuggestion: number\n  suggestionType: SuggestionType\n  maxColumnWidth?: number\n  commandArgumentHint?: string\n  inlineGhostText?: InlineGhostText\n  handleKeyDown: (e: KeyboardEvent) => void\n}\n\n/**\n * Extract search token from a completion token by removing @ prefix and quotes\n * @param completionToken The completion token\n * @returns The search token with @ and quotes removed\n */\nexport function extractSearchToken(completionToken: {\n  token: string\n  isQuoted?: boolean\n}): string {\n  if (completionToken.isQuoted) {\n    // Remove @\" prefix and optional closing \"\n    return completionToken.token.slice(2).replace(/\"$/, '')\n  } else if (completionToken.token.startsWith('@')) {\n    return completionToken.token.substring(1)\n  } else {\n    return completionToken.token\n  }\n}\n\n/**\n * Format a replacement value with proper @ prefix and quotes based on context\n * @param options Configuration for formatting\n * @param options.displayText The text to display\n * @param options.mode The current mode (bash or prompt)\n * @param options.hasAtPrefix Whether the original token has @ prefix\n * @param options.needsQuotes Whether the text needs quotes (contains spaces)\n * @param options.isQuoted Whether the original token was already quoted (user typed @\"...)\n * @param options.isComplete Whether this is a complete suggestion (adds trailing space)\n * @returns The formatted replacement value\n */\nexport function formatReplacementValue(options: {\n  displayText: string\n  mode: string\n  hasAtPrefix: boolean\n  needsQuotes: boolean\n  isQuoted?: boolean\n  isComplete: boolean\n}): string {\n  const { displayText, mode, hasAtPrefix, needsQuotes, isQuoted, isComplete } =\n    options\n  const space = isComplete ? ' ' : ''\n\n  if (isQuoted || needsQuotes) {\n    // Use quoted format\n    return mode === 'bash'\n      ? `\"${displayText}\"${space}`\n      : `@\"${displayText}\"${space}`\n  } else if (hasAtPrefix) {\n    return mode === 'bash'\n      ? `${displayText}${space}`\n      : `@${displayText}${space}`\n  } else {\n    return displayText\n  }\n}\n\n/**\n * Apply a shell completion suggestion by replacing the current word\n */\nexport function applyShellSuggestion(\n  suggestion: SuggestionItem,\n  input: string,\n  cursorOffset: number,\n  onInputChange: (value: string) => void,\n  setCursorOffset: (offset: number) => void,\n  completionType: ShellCompletionType | undefined,\n): void {\n  const beforeCursor = input.slice(0, cursorOffset)\n  const lastSpaceIndex = beforeCursor.lastIndexOf(' ')\n  const wordStart = lastSpaceIndex + 1\n\n  // Prepare the replacement text based on completion type\n  let replacementText: string\n  if (completionType === 'variable') {\n    replacementText = '$' + suggestion.displayText + ' '\n  } else if (completionType === 'command') {\n    replacementText = suggestion.displayText + ' '\n  } else {\n    replacementText = suggestion.displayText\n  }\n\n  const newInput =\n    input.slice(0, wordStart) + replacementText + input.slice(cursorOffset)\n\n  onInputChange(newInput)\n  setCursorOffset(wordStart + replacementText.length)\n}\n\nconst DM_MEMBER_RE = /(^|\\s)@[\\w-]*$/\n\nfunction applyTriggerSuggestion(\n  suggestion: SuggestionItem,\n  input: string,\n  cursorOffset: number,\n  triggerRe: RegExp,\n  onInputChange: (value: string) => void,\n  setCursorOffset: (offset: number) => void,\n): void {\n  const m = input.slice(0, cursorOffset).match(triggerRe)\n  if (!m || m.index === undefined) return\n  const prefixStart = m.index + (m[1]?.length ?? 0)\n  const before = input.slice(0, prefixStart)\n  const newInput =\n    before + suggestion.displayText + ' ' + input.slice(cursorOffset)\n  onInputChange(newInput)\n  setCursorOffset(before.length + suggestion.displayText.length + 1)\n}\n\nlet currentShellCompletionAbortController: AbortController | null = null\n\n/**\n * Generate bash shell completion suggestions\n */\nasync function generateBashSuggestions(\n  input: string,\n  cursorOffset: number,\n): Promise<SuggestionItem[]> {\n  try {\n    if (currentShellCompletionAbortController) {\n      currentShellCompletionAbortController.abort()\n    }\n\n    currentShellCompletionAbortController = new AbortController()\n    const suggestions = await getShellCompletions(\n      input,\n      cursorOffset,\n      currentShellCompletionAbortController.signal,\n    )\n\n    return suggestions\n  } catch {\n    // Silent failure - don't break UX\n    logEvent('tengu_shell_completion_failed', {})\n    return []\n  }\n}\n\n/**\n * Apply a directory/path completion suggestion to the input\n * Always adds @ prefix since we're replacing the entire token (including any existing @)\n *\n * @param input The current input text\n * @param suggestionId The ID of the suggestion to apply\n * @param tokenStartPos The start position of the token being replaced\n * @param tokenLength The length of the token being replaced\n * @param isDirectory Whether the suggestion is a directory (adds / suffix) or file (adds space)\n * @returns Object with the new input text and cursor position\n */\nexport function applyDirectorySuggestion(\n  input: string,\n  suggestionId: string,\n  tokenStartPos: number,\n  tokenLength: number,\n  isDirectory: boolean,\n): { newInput: string; cursorPos: number } {\n  const suffix = isDirectory ? '/' : ' '\n  const before = input.slice(0, tokenStartPos)\n  const after = input.slice(tokenStartPos + tokenLength)\n  // Always add @ prefix - if token already has it, we're replacing\n  // the whole token (including @) with @suggestion.id\n  const replacement = '@' + suggestionId + suffix\n  const newInput = before + replacement + after\n\n  return {\n    newInput,\n    cursorPos: before.length + replacement.length,\n  }\n}\n\n/**\n * Extract a completable token at the cursor position\n * @param text The input text\n * @param cursorPos The cursor position\n * @param includeAtSymbol Whether to consider @ symbol as part of the token\n * @returns The completable token and its start position, or null if not found\n */\nexport function extractCompletionToken(\n  text: string,\n  cursorPos: number,\n  includeAtSymbol = false,\n): { token: string; startPos: number; isQuoted?: boolean } | null {\n  // Empty input check\n  if (!text) return null\n\n  // Get text up to cursor\n  const textBeforeCursor = text.substring(0, cursorPos)\n\n  // Check for quoted @ mention first (e.g., @\"my file with spaces\")\n  if (includeAtSymbol) {\n    const quotedAtRegex = /@\"([^\"]*)\"?$/\n    const quotedMatch = textBeforeCursor.match(quotedAtRegex)\n    if (quotedMatch && quotedMatch.index !== undefined) {\n      // Include any remaining quoted content after cursor until closing quote or end\n      const textAfterCursor = text.substring(cursorPos)\n      const afterQuotedMatch = textAfterCursor.match(/^[^\"]*\"?/)\n      const quotedSuffix = afterQuotedMatch ? afterQuotedMatch[0] : ''\n\n      return {\n        token: quotedMatch[0] + quotedSuffix,\n        startPos: quotedMatch.index,\n        isQuoted: true,\n      }\n    }\n  }\n\n  // Fast path for @ tokens: use lastIndexOf to avoid expensive $ anchor scan\n  if (includeAtSymbol) {\n    const atIdx = textBeforeCursor.lastIndexOf('@')\n    if (\n      atIdx >= 0 &&\n      (atIdx === 0 || /\\s/.test(textBeforeCursor[atIdx - 1]!))\n    ) {\n      const fromAt = textBeforeCursor.substring(atIdx)\n      const atHeadMatch = fromAt.match(AT_TOKEN_HEAD_RE)\n      if (atHeadMatch && atHeadMatch[0].length === fromAt.length) {\n        const textAfterCursor = text.substring(cursorPos)\n        const afterMatch = textAfterCursor.match(PATH_CHAR_HEAD_RE)\n        const tokenSuffix = afterMatch ? afterMatch[0] : ''\n        return {\n          token: atHeadMatch[0] + tokenSuffix,\n          startPos: atIdx,\n          isQuoted: false,\n        }\n      }\n    }\n  }\n\n  // Non-@ token or cursor outside @ token — use $ anchor on (short) tail\n  const tokenRegex = includeAtSymbol ? TOKEN_WITH_AT_RE : TOKEN_WITHOUT_AT_RE\n  const match = textBeforeCursor.match(tokenRegex)\n  if (!match || match.index === undefined) {\n    return null\n  }\n\n  // Check if cursor is in the MIDDLE of a token (more word characters after cursor)\n  // If so, extend the token to include all characters until whitespace or end of string\n  const textAfterCursor = text.substring(cursorPos)\n  const afterMatch = textAfterCursor.match(PATH_CHAR_HEAD_RE)\n  const tokenSuffix = afterMatch ? afterMatch[0] : ''\n\n  return {\n    token: match[0] + tokenSuffix,\n    startPos: match.index,\n    isQuoted: false,\n  }\n}\n\nfunction extractCommandNameAndArgs(value: string): {\n  commandName: string\n  args: string\n} | null {\n  if (isCommandInput(value)) {\n    const spaceIndex = value.indexOf(' ')\n    if (spaceIndex === -1)\n      return {\n        commandName: value.slice(1),\n        args: '',\n      }\n    return {\n      commandName: value.slice(1, spaceIndex),\n      args: value.slice(spaceIndex + 1),\n    }\n  }\n  return null\n}\n\nfunction hasCommandWithArguments(\n  isAtEndWithWhitespace: boolean,\n  value: string,\n) {\n  // If value.endsWith(' ') but the user is not at the end, then the user has\n  // potentially gone back to the command in an effort to edit the command name\n  // (but preserve the arguments).\n  return !isAtEndWithWhitespace && value.includes(' ') && !value.endsWith(' ')\n}\n\n/**\n * Hook for handling typeahead functionality for both commands and file paths\n */\nexport function useTypeahead({\n  commands,\n  onInputChange,\n  onSubmit,\n  setCursorOffset,\n  input,\n  cursorOffset,\n  mode,\n  agents,\n  setSuggestionsState,\n  suggestionsState: { suggestions, selectedSuggestion, commandArgumentHint },\n  suppressSuggestions = false,\n  markAccepted,\n  onModeChange,\n}: Props): UseTypeaheadResult {\n  const { addNotification } = useNotifications()\n  const thinkingToggleShortcut = useShortcutDisplay(\n    'chat:thinkingToggle',\n    'Chat',\n    'alt+t',\n  )\n  const [suggestionType, setSuggestionType] = useState<SuggestionType>('none')\n\n  // Compute max column width from ALL commands once (not filtered results)\n  // This prevents layout shift when filtering\n  const allCommandsMaxWidth = useMemo(() => {\n    const visibleCommands = commands.filter(cmd => !cmd.isHidden)\n    if (visibleCommands.length === 0) return undefined\n    const maxLen = Math.max(\n      ...visibleCommands.map(cmd => getCommandName(cmd).length),\n    )\n    return maxLen + 6 // +1 for \"/\" prefix, +5 for padding\n  }, [commands])\n\n  const [maxColumnWidth, setMaxColumnWidth] = useState<number | undefined>(\n    undefined,\n  )\n  const mcpResources = useAppState(s => s.mcp.resources)\n  const store = useAppStateStore()\n  const promptSuggestion = useAppState(s => s.promptSuggestion)\n  // PromptInput hides suggestion ghost text in teammate view — mirror that\n  // gate here so Tab/rightArrow can't accept what isn't displayed.\n  const isViewingTeammate = useAppState(s => !!s.viewingAgentTaskId)\n\n  // Access keybinding context to check for pending chord sequences\n  const keybindingContext = useOptionalKeybindingContext()\n\n  // State for inline ghost text (bash history completion - async)\n  const [inlineGhostText, setInlineGhostText] = useState<\n    InlineGhostText | undefined\n  >(undefined)\n\n  // Synchronous ghost text for prompt mode mid-input slash commands.\n  // Computed during render via useMemo to eliminate the one-frame flicker\n  // that occurs when using useState + useEffect (effect runs after render).\n  const syncPromptGhostText = useMemo((): InlineGhostText | undefined => {\n    if (mode !== 'prompt' || suppressSuggestions) return undefined\n    const midInputCommand = findMidInputSlashCommand(input, cursorOffset)\n    if (!midInputCommand) return undefined\n    const match = getBestCommandMatch(midInputCommand.partialCommand, commands)\n    if (!match) return undefined\n    return {\n      text: match.suffix,\n      fullCommand: match.fullCommand,\n      insertPosition:\n        midInputCommand.startPos + 1 + midInputCommand.partialCommand.length,\n    }\n  }, [input, cursorOffset, mode, commands, suppressSuggestions])\n\n  // Merged ghost text: prompt mode uses synchronous useMemo, bash mode uses async useState\n  const effectiveGhostText = suppressSuggestions\n    ? undefined\n    : mode === 'prompt'\n      ? syncPromptGhostText\n      : inlineGhostText\n\n  // Use a ref for cursorOffset to avoid re-triggering suggestions on cursor movement alone\n  // We only want to re-fetch suggestions when the actual search token changes\n  const cursorOffsetRef = useRef(cursorOffset)\n  cursorOffsetRef.current = cursorOffset\n\n  // Track the latest search token to discard stale results from slow async operations\n  const latestSearchTokenRef = useRef<string | null>(null)\n  // Track previous input to detect actual text changes vs. callback recreations\n  const prevInputRef = useRef('')\n  // Track the latest path token to discard stale results from path completion\n  const latestPathTokenRef = useRef('')\n  // Track the latest bash input to discard stale results from history completion\n  const latestBashInputRef = useRef('')\n  // Track the latest slack channel token to discard stale results from MCP\n  const latestSlackTokenRef = useRef('')\n  // Track suggestions via ref to avoid updateSuggestions being recreated on selection changes\n  const suggestionsRef = useRef(suggestions)\n  suggestionsRef.current = suggestions\n  // Track the input value when suggestions were manually dismissed to prevent re-triggering\n  const dismissedForInputRef = useRef<string | null>(null)\n\n  // Clear all suggestions\n  const clearSuggestions = useCallback(() => {\n    setSuggestionsState(() => ({\n      commandArgumentHint: undefined,\n      suggestions: [],\n      selectedSuggestion: -1,\n    }))\n    setSuggestionType('none')\n    setMaxColumnWidth(undefined)\n    setInlineGhostText(undefined)\n  }, [setSuggestionsState])\n\n  // Expensive async operation to fetch file/resource suggestions\n  const fetchFileSuggestions = useCallback(\n    async (searchToken: string, isAtSymbol = false): Promise<void> => {\n      latestSearchTokenRef.current = searchToken\n      const combinedItems = await generateUnifiedSuggestions(\n        searchToken,\n        mcpResources,\n        agents,\n        isAtSymbol,\n      )\n      // Discard stale results if a newer query was initiated while waiting\n      if (latestSearchTokenRef.current !== searchToken) {\n        return\n      }\n      if (combinedItems.length === 0) {\n        // Inline clearSuggestions logic to avoid needing debouncedFetchFileSuggestions\n        setSuggestionsState(() => ({\n          commandArgumentHint: undefined,\n          suggestions: [],\n          selectedSuggestion: -1,\n        }))\n        setSuggestionType('none')\n        setMaxColumnWidth(undefined)\n        return\n      }\n      setSuggestionsState(prev => ({\n        commandArgumentHint: undefined,\n        suggestions: combinedItems,\n        selectedSuggestion: getPreservedSelection(\n          prev.suggestions,\n          prev.selectedSuggestion,\n          combinedItems,\n        ),\n      }))\n      setSuggestionType(combinedItems.length > 0 ? 'file' : 'none')\n      setMaxColumnWidth(undefined) // No fixed width for file suggestions\n    },\n    [\n      mcpResources,\n      setSuggestionsState,\n      setSuggestionType,\n      setMaxColumnWidth,\n      agents,\n    ],\n  )\n\n  // Pre-warm the file index on mount so the first @-mention doesn't block.\n  // The build runs in background with ~4ms event-loop yields, so it doesn't\n  // delay first render — it just races the user's first @ keystroke.\n  //\n  // If the user types before the build finishes, they get partial results\n  // from the ready chunks; when the build completes, re-fire the last\n  // search so partial upgrades to full. Clears the token ref so the same\n  // query isn't discarded as stale.\n  //\n  // Skipped under NODE_ENV=test: REPL-mounting tests would spawn git ls-files\n  // against the real CI workspace (270k+ files on Windows runners), and the\n  // background build outlives the test — its setImmediate chain leaks into\n  // subsequent tests in the shard. The subscriber still registers so\n  // fileSuggestions tests that trigger a refresh directly work correctly.\n  useEffect(() => {\n    if (\"production\" !== 'test') {\n      startBackgroundCacheRefresh()\n    }\n    return onIndexBuildComplete(() => {\n      const token = latestSearchTokenRef.current\n      if (token !== null) {\n        latestSearchTokenRef.current = null\n        void fetchFileSuggestions(token, token === '')\n      }\n    })\n  }, [fetchFileSuggestions])\n\n  // Debounce the file fetch operation. 50ms sits just above macOS default\n  // key-repeat (~33ms) so held-delete/backspace coalesces into one search\n  // instead of stuttering on each repeated key. The search itself is ~8–15ms\n  // on a 270k-file index.\n  const debouncedFetchFileSuggestions = useDebounceCallback(\n    fetchFileSuggestions,\n    50,\n  )\n\n  const fetchSlackChannels = useCallback(\n    async (partial: string): Promise<void> => {\n      latestSlackTokenRef.current = partial\n      const channels = await getSlackChannelSuggestions(\n        store.getState().mcp.clients,\n        partial,\n      )\n      if (latestSlackTokenRef.current !== partial) return\n      setSuggestionsState(prev => ({\n        commandArgumentHint: undefined,\n        suggestions: channels,\n        selectedSuggestion: getPreservedSelection(\n          prev.suggestions,\n          prev.selectedSuggestion,\n          channels,\n        ),\n      }))\n      setSuggestionType(channels.length > 0 ? 'slack-channel' : 'none')\n      setMaxColumnWidth(undefined)\n    },\n    // eslint-disable-next-line react-hooks/exhaustive-deps -- store is a stable context ref\n    [setSuggestionsState],\n  )\n\n  // First keystroke after # needs the MCP round-trip; subsequent keystrokes\n  // that share the same first-word segment hit the cache synchronously.\n  const debouncedFetchSlackChannels = useDebounceCallback(\n    fetchSlackChannels,\n    150,\n  )\n\n  // Handle immediate suggestion logic (cheap operations)\n  // biome-ignore lint/correctness/useExhaustiveDependencies: store is a stable context ref, read imperatively at call-time\n  const updateSuggestions = useCallback(\n    async (value: string, inputCursorOffset?: number): Promise<void> => {\n      // Use provided cursor offset or fall back to ref (avoids dependency on cursorOffset)\n      const effectiveCursorOffset = inputCursorOffset ?? cursorOffsetRef.current\n      if (suppressSuggestions) {\n        debouncedFetchFileSuggestions.cancel()\n        clearSuggestions()\n        return\n      }\n\n      // Check for mid-input slash command (e.g., \"help me /com\")\n      // Only in prompt mode, not when input starts with \"/\" (handled separately)\n      // Note: ghost text for prompt mode is computed synchronously via syncPromptGhostText useMemo.\n      // We only need to clear dropdown suggestions here when ghost text is active.\n      if (mode === 'prompt') {\n        const midInputCommand = findMidInputSlashCommand(\n          value,\n          effectiveCursorOffset,\n        )\n        if (midInputCommand) {\n          const match = getBestCommandMatch(\n            midInputCommand.partialCommand,\n            commands,\n          )\n          if (match) {\n            // Clear dropdown suggestions when showing ghost text\n            setSuggestionsState(() => ({\n              commandArgumentHint: undefined,\n              suggestions: [],\n              selectedSuggestion: -1,\n            }))\n            setSuggestionType('none')\n            setMaxColumnWidth(undefined)\n            return\n          }\n        }\n      }\n\n      // Bash mode: check for history-based ghost text completion\n      if (mode === 'bash' && value.trim()) {\n        latestBashInputRef.current = value\n        const historyMatch = await getShellHistoryCompletion(value)\n        // Discard stale results if input changed while waiting\n        if (latestBashInputRef.current !== value) {\n          return\n        }\n        if (historyMatch) {\n          setInlineGhostText({\n            text: historyMatch.suffix,\n            fullCommand: historyMatch.fullCommand,\n            insertPosition: value.length,\n          })\n          // Clear dropdown suggestions when showing ghost text\n          setSuggestionsState(() => ({\n            commandArgumentHint: undefined,\n            suggestions: [],\n            selectedSuggestion: -1,\n          }))\n          setSuggestionType('none')\n          setMaxColumnWidth(undefined)\n          return\n        } else {\n          // No history match, clear ghost text\n          setInlineGhostText(undefined)\n        }\n      }\n\n      // Check for @ to trigger team member / named subagent suggestions\n      // Must check before @ file symbol to prevent conflict\n      // Skip in bash mode - @ has no special meaning in shell commands\n      const atMatch =\n        mode !== 'bash'\n          ? value.substring(0, effectiveCursorOffset).match(/(^|\\s)@([\\w-]*)$/)\n          : null\n      if (atMatch) {\n        const partialName = (atMatch[2] ?? '').toLowerCase()\n        // Imperative read — reading at call-time fixes staleness for\n        // teammates/subagents added mid-session.\n        const state = store.getState()\n        const members: SuggestionItem[] = []\n        const seen = new Set<string>()\n\n        if (isAgentSwarmsEnabled() && state.teamContext) {\n          for (const t of Object.values(state.teamContext.teammates ?? {})) {\n            if (t.name === TEAM_LEAD_NAME) continue\n            if (!t.name.toLowerCase().startsWith(partialName)) continue\n            seen.add(t.name)\n            members.push({\n              id: `dm-${t.name}`,\n              displayText: `@${t.name}`,\n              description: 'send message',\n            })\n          }\n        }\n\n        for (const [name, agentId] of state.agentNameRegistry) {\n          if (seen.has(name)) continue\n          if (!name.toLowerCase().startsWith(partialName)) continue\n          const status = state.tasks[agentId]?.status\n          members.push({\n            id: `dm-${name}`,\n            displayText: `@${name}`,\n            description: status ? `send message · ${status}` : 'send message',\n          })\n        }\n\n        if (members.length > 0) {\n          debouncedFetchFileSuggestions.cancel()\n          setSuggestionsState(prev => ({\n            commandArgumentHint: undefined,\n            suggestions: members,\n            selectedSuggestion: getPreservedSelection(\n              prev.suggestions,\n              prev.selectedSuggestion,\n              members,\n            ),\n          }))\n          setSuggestionType('agent')\n          setMaxColumnWidth(undefined)\n          return\n        }\n      }\n\n      // Check for # to trigger Slack channel suggestions (requires Slack MCP server)\n      if (mode === 'prompt') {\n        const hashMatch = value\n          .substring(0, effectiveCursorOffset)\n          .match(HASH_CHANNEL_RE)\n        if (hashMatch && hasSlackMcpServer(store.getState().mcp.clients)) {\n          debouncedFetchSlackChannels(hashMatch[2]!)\n          return\n        } else if (suggestionType === 'slack-channel') {\n          debouncedFetchSlackChannels.cancel()\n          clearSuggestions()\n        }\n      }\n\n      // Check for @ symbol to trigger file suggestions (including quoted paths)\n      // Includes colon for MCP resources (e.g., server:resource/path)\n      const hasAtSymbol = value\n        .substring(0, effectiveCursorOffset)\n        .match(HAS_AT_SYMBOL_RE)\n\n      // First, check for slash command suggestions (higher priority than @ symbol)\n      // Only show slash command selector if cursor is not on the \"/\" character itself\n      // Also don't show if cursor is at end of line with whitespace before it\n      // Don't show slash commands in bash mode\n      const isAtEndWithWhitespace =\n        effectiveCursorOffset === value.length &&\n        effectiveCursorOffset > 0 &&\n        value.length > 0 &&\n        value[effectiveCursorOffset - 1] === ' '\n\n      // Handle directory completion for commands\n      if (\n        mode === 'prompt' &&\n        isCommandInput(value) &&\n        effectiveCursorOffset > 0\n      ) {\n        const parsedCommand = extractCommandNameAndArgs(value)\n\n        if (\n          parsedCommand &&\n          parsedCommand.commandName === 'add-dir' &&\n          parsedCommand.args\n        ) {\n          const { args } = parsedCommand\n\n          // Clear suggestions if args end with whitespace (user is done with path)\n          if (args.match(/\\s+$/)) {\n            debouncedFetchFileSuggestions.cancel()\n            clearSuggestions()\n            return\n          }\n\n          const dirSuggestions = await getDirectoryCompletions(args)\n          if (dirSuggestions.length > 0) {\n            setSuggestionsState(prev => ({\n              suggestions: dirSuggestions,\n              selectedSuggestion: getPreservedSelection(\n                prev.suggestions,\n                prev.selectedSuggestion,\n                dirSuggestions,\n              ),\n              commandArgumentHint: undefined,\n            }))\n            setSuggestionType('directory')\n            return\n          }\n\n          // No suggestions found - clear and return\n          debouncedFetchFileSuggestions.cancel()\n          clearSuggestions()\n          return\n        }\n\n        // Handle custom title completion for /resume command\n        if (\n          parsedCommand &&\n          parsedCommand.commandName === 'resume' &&\n          parsedCommand.args !== undefined &&\n          value.includes(' ')\n        ) {\n          const { args } = parsedCommand\n\n          // Get custom title suggestions using partial match\n          const matches = await searchSessionsByCustomTitle(args, {\n            limit: 10,\n          })\n\n          const suggestions = matches.map(log => {\n            const sessionId = getSessionIdFromLog(log)\n            return {\n              id: `resume-title-${sessionId}`,\n              displayText: log.customTitle!,\n              description: formatLogMetadata(log),\n              metadata: { sessionId },\n            }\n          })\n\n          if (suggestions.length > 0) {\n            setSuggestionsState(prev => ({\n              suggestions,\n              selectedSuggestion: getPreservedSelection(\n                prev.suggestions,\n                prev.selectedSuggestion,\n                suggestions,\n              ),\n              commandArgumentHint: undefined,\n            }))\n            setSuggestionType('custom-title')\n            return\n          }\n\n          // No suggestions found - clear and return\n          clearSuggestions()\n          return\n        }\n      }\n\n      // Determine whether to display the argument hint and command suggestions.\n      if (\n        mode === 'prompt' &&\n        isCommandInput(value) &&\n        effectiveCursorOffset > 0 &&\n        !hasCommandWithArguments(isAtEndWithWhitespace, value)\n      ) {\n        let commandArgumentHint: string | undefined = undefined\n        if (value.length > 1) {\n          // We have a partial or complete command without arguments\n          // Check if it matches a command exactly and has an argument hint\n\n          // Extract command name: everything after / until the first space (or end)\n          const spaceIndex = value.indexOf(' ')\n          const commandName =\n            spaceIndex === -1 ? value.slice(1) : value.slice(1, spaceIndex)\n\n          // Check if there are real arguments (non-whitespace after the command)\n          const hasRealArguments =\n            spaceIndex !== -1 && value.slice(spaceIndex + 1).trim().length > 0\n\n          // Check if input is exactly \"command + single space\" (ready for arguments)\n          const hasExactlyOneTrailingSpace =\n            spaceIndex !== -1 && value.length === spaceIndex + 1\n\n          // If input has a space after the command, don't show suggestions\n          // This prevents Enter from selecting a different command after Tab completion\n          if (spaceIndex !== -1) {\n            const exactMatch = commands.find(\n              cmd => getCommandName(cmd) === commandName,\n            )\n            if (exactMatch || hasRealArguments) {\n              // Priority 1: Static argumentHint (only on first trailing space for backwards compat)\n              if (exactMatch?.argumentHint && hasExactlyOneTrailingSpace) {\n                commandArgumentHint = exactMatch.argumentHint\n              }\n              // Priority 2: Progressive hint from argNames (show when trailing space)\n              else if (\n                exactMatch?.type === 'prompt' &&\n                exactMatch.argNames?.length &&\n                value.endsWith(' ')\n              ) {\n                const argsText = value.slice(spaceIndex + 1)\n                const typedArgs = parseArguments(argsText)\n                commandArgumentHint = generateProgressiveArgumentHint(\n                  exactMatch.argNames,\n                  typedArgs,\n                )\n              }\n              setSuggestionsState(() => ({\n                commandArgumentHint,\n                suggestions: [],\n                selectedSuggestion: -1,\n              }))\n              setSuggestionType('none')\n              setMaxColumnWidth(undefined)\n              return\n            }\n          }\n\n          // Note: argument hint is only shown when there's exactly one trailing space\n          // (set above when hasExactlyOneTrailingSpace is true)\n        }\n\n        const commandItems = generateCommandSuggestions(value, commands)\n        setSuggestionsState(() => ({\n          commandArgumentHint,\n          suggestions: commandItems,\n          selectedSuggestion: commandItems.length > 0 ? 0 : -1,\n        }))\n        setSuggestionType(commandItems.length > 0 ? 'command' : 'none')\n\n        // Use stable width from all commands (prevents layout shift when filtering)\n        if (commandItems.length > 0) {\n          setMaxColumnWidth(allCommandsMaxWidth)\n        }\n        return\n      }\n\n      if (suggestionType === 'command') {\n        // If we had command suggestions but the input no longer starts with '/'\n        // we need to clear the suggestions. However, we should not return\n        // because there may be relevant @ symbol and file suggestions.\n        debouncedFetchFileSuggestions.cancel()\n        clearSuggestions()\n      } else if (\n        isCommandInput(value) &&\n        hasCommandWithArguments(isAtEndWithWhitespace, value)\n      ) {\n        // If we have a command with arguments (no trailing space), clear any stale hint\n        // This prevents the hint from flashing when transitioning between states\n        setSuggestionsState(prev =>\n          prev.commandArgumentHint\n            ? { ...prev, commandArgumentHint: undefined }\n            : prev,\n        )\n      }\n\n      if (suggestionType === 'custom-title') {\n        // If we had custom-title suggestions but the input is no longer /resume\n        // we need to clear the suggestions.\n        clearSuggestions()\n      }\n\n      if (\n        suggestionType === 'agent' &&\n        suggestionsRef.current.some((s: SuggestionItem) =>\n          s.id?.startsWith('dm-'),\n        )\n      ) {\n        // If we had team member suggestions but the input no longer has @\n        // we need to clear the suggestions.\n        const hasAt = value\n          .substring(0, effectiveCursorOffset)\n          .match(/(^|\\s)@([\\w-]*)$/)\n        if (!hasAt) {\n          clearSuggestions()\n        }\n      }\n\n      // Check for @ symbol to trigger file and MCP resource suggestions\n      // Skip @ autocomplete in bash mode - @ has no special meaning in shell commands\n      if (hasAtSymbol && mode !== 'bash') {\n        // Get the @ token (including the @ symbol)\n        const completionToken = extractCompletionToken(\n          value,\n          effectiveCursorOffset,\n          true,\n        )\n        if (completionToken && completionToken.token.startsWith('@')) {\n          const searchToken = extractSearchToken(completionToken)\n\n          // If the token after @ is path-like, use path completion instead of fuzzy search\n          // This handles cases like @~/path, @./path, @/path for directory traversal\n          if (isPathLikeToken(searchToken)) {\n            latestPathTokenRef.current = searchToken\n            const pathSuggestions = await getPathCompletions(searchToken, {\n              maxResults: 10,\n            })\n            // Discard stale results if a newer query was initiated while waiting\n            if (latestPathTokenRef.current !== searchToken) {\n              return\n            }\n            if (pathSuggestions.length > 0) {\n              setSuggestionsState(prev => ({\n                suggestions: pathSuggestions,\n                selectedSuggestion: getPreservedSelection(\n                  prev.suggestions,\n                  prev.selectedSuggestion,\n                  pathSuggestions,\n                ),\n                commandArgumentHint: undefined,\n              }))\n              setSuggestionType('directory')\n              return\n            }\n          }\n\n          // Skip if we already fetched for this exact token (prevents loop from\n          // suggestions dependency causing updateSuggestions to be recreated)\n          if (latestSearchTokenRef.current === searchToken) {\n            return\n          }\n          void debouncedFetchFileSuggestions(searchToken, true)\n          return\n        }\n      }\n\n      // If we have active file suggestions or the input changed, check for file suggestions\n      if (suggestionType === 'file') {\n        const completionToken = extractCompletionToken(\n          value,\n          effectiveCursorOffset,\n          true,\n        )\n        if (completionToken) {\n          const searchToken = extractSearchToken(completionToken)\n          // Skip if we already fetched for this exact token\n          if (latestSearchTokenRef.current === searchToken) {\n            return\n          }\n          void debouncedFetchFileSuggestions(searchToken, false)\n        } else {\n          // If we had file suggestions but now there's no completion token\n          debouncedFetchFileSuggestions.cancel()\n          clearSuggestions()\n        }\n      }\n\n      // Clear shell suggestions if not in bash mode OR if input has changed\n      if (suggestionType === 'shell') {\n        const inputSnapshot = (\n          suggestionsRef.current[0]?.metadata as { inputSnapshot?: string }\n        )?.inputSnapshot\n\n        if (mode !== 'bash' || value !== inputSnapshot) {\n          debouncedFetchFileSuggestions.cancel()\n          clearSuggestions()\n        }\n      }\n    },\n    [\n      suggestionType,\n      commands,\n      setSuggestionsState,\n      clearSuggestions,\n      debouncedFetchFileSuggestions,\n      debouncedFetchSlackChannels,\n      mode,\n      suppressSuggestions,\n      // Note: using suggestionsRef instead of suggestions to avoid recreating\n      // this callback when only selectedSuggestion changes (not the suggestions list)\n      allCommandsMaxWidth,\n    ],\n  )\n\n  // Update suggestions when input changes\n  // Note: We intentionally don't depend on cursorOffset here - cursor movement alone\n  // shouldn't re-trigger suggestions. The cursorOffsetRef is used to get the current\n  // position when needed without causing re-renders.\n  useEffect(() => {\n    // If suggestions were dismissed for this exact input, don't re-trigger\n    if (dismissedForInputRef.current === input) {\n      return\n    }\n    // When the actual input text changes (not just updateSuggestions being recreated),\n    // reset the search token ref so the same query can be re-fetched.\n    // This fixes: type @readme.md, clear, retype @readme.md → no suggestions.\n    if (prevInputRef.current !== input) {\n      prevInputRef.current = input\n      latestSearchTokenRef.current = null\n    }\n    // Clear the dismissed state when input changes\n    dismissedForInputRef.current = null\n    void updateSuggestions(input)\n  }, [input, updateSuggestions])\n\n  // Handle tab key press - complete suggestions or trigger file suggestions\n  const handleTab = useCallback(async () => {\n    // If we have inline ghost text, apply it\n    if (effectiveGhostText) {\n      // Check for bash mode history completion first\n      if (mode === 'bash') {\n        // Replace the input with the full command from history\n        onInputChange(effectiveGhostText.fullCommand)\n        setCursorOffset(effectiveGhostText.fullCommand.length)\n        setInlineGhostText(undefined)\n        return\n      }\n\n      // Find the mid-input command to get its position (for prompt mode)\n      const midInputCommand = findMidInputSlashCommand(input, cursorOffset)\n      if (midInputCommand) {\n        // Replace the partial command with the full command + space\n        const before = input.slice(0, midInputCommand.startPos)\n        const after = input.slice(\n          midInputCommand.startPos + midInputCommand.token.length,\n        )\n        const newInput =\n          before + '/' + effectiveGhostText.fullCommand + ' ' + after\n        const newCursorOffset =\n          midInputCommand.startPos +\n          1 +\n          effectiveGhostText.fullCommand.length +\n          1\n\n        onInputChange(newInput)\n        setCursorOffset(newCursorOffset)\n        return\n      }\n    }\n\n    // If we have active suggestions, select one\n    if (suggestions.length > 0) {\n      // Cancel any pending debounced fetches to prevent flicker when accepting\n      debouncedFetchFileSuggestions.cancel()\n      debouncedFetchSlackChannels.cancel()\n\n      const index = selectedSuggestion === -1 ? 0 : selectedSuggestion\n      const suggestion = suggestions[index]\n\n      if (suggestionType === 'command' && index < suggestions.length) {\n        if (suggestion) {\n          applyCommandSuggestion(\n            suggestion,\n            false, // don't execute on tab\n            commands,\n            onInputChange,\n            setCursorOffset,\n            onSubmit,\n          )\n          clearSuggestions()\n        }\n      } else if (suggestionType === 'custom-title' && suggestions.length > 0) {\n        // Apply custom title to /resume command with sessionId\n        if (suggestion) {\n          const newInput = buildResumeInputFromSuggestion(suggestion)\n          onInputChange(newInput)\n          setCursorOffset(newInput.length)\n          clearSuggestions()\n        }\n      } else if (suggestionType === 'directory' && suggestions.length > 0) {\n        const suggestion = suggestions[index]\n        if (suggestion) {\n          // Check if this is a command context (e.g., /add-dir) or general path completion\n          const isInCommandContext = isCommandInput(input)\n\n          let newInput: string\n          if (isInCommandContext) {\n            // Command context: replace just the argument portion\n            const spaceIndex = input.indexOf(' ')\n            const commandPart = input.slice(0, spaceIndex + 1) // Include the space\n            const cmdSuffix =\n              isPathMetadata(suggestion.metadata) &&\n              suggestion.metadata.type === 'directory'\n                ? '/'\n                : ' '\n            newInput = commandPart + suggestion.id + cmdSuffix\n\n            onInputChange(newInput)\n            setCursorOffset(newInput.length)\n\n            if (\n              isPathMetadata(suggestion.metadata) &&\n              suggestion.metadata.type === 'directory'\n            ) {\n              // For directories, fetch new suggestions for the updated path\n              setSuggestionsState(prev => ({\n                ...prev,\n                commandArgumentHint: undefined,\n              }))\n              void updateSuggestions(newInput, newInput.length)\n            } else {\n              clearSuggestions()\n            }\n          } else {\n            // General path completion: replace the path token in input with @-prefixed path\n            // Try to get token with @ prefix first to check if already prefixed\n            const completionTokenWithAt = extractCompletionToken(\n              input,\n              cursorOffset,\n              true,\n            )\n            const completionToken =\n              completionTokenWithAt ??\n              extractCompletionToken(input, cursorOffset, false)\n\n            if (completionToken) {\n              const isDir =\n                isPathMetadata(suggestion.metadata) &&\n                suggestion.metadata.type === 'directory'\n              const result = applyDirectorySuggestion(\n                input,\n                suggestion.id,\n                completionToken.startPos,\n                completionToken.token.length,\n                isDir,\n              )\n              newInput = result.newInput\n\n              onInputChange(newInput)\n              setCursorOffset(result.cursorPos)\n\n              if (isDir) {\n                // For directories, fetch new suggestions for the updated path\n                setSuggestionsState(prev => ({\n                  ...prev,\n                  commandArgumentHint: undefined,\n                }))\n                void updateSuggestions(newInput, result.cursorPos)\n              } else {\n                // For files, clear suggestions\n                clearSuggestions()\n              }\n            } else {\n              // No completion token found (e.g., cursor after space) - just clear suggestions\n              // without modifying input to avoid data loss\n              clearSuggestions()\n            }\n          }\n        }\n      } else if (suggestionType === 'shell' && suggestions.length > 0) {\n        const suggestion = suggestions[index]\n        if (suggestion) {\n          const metadata = suggestion.metadata as\n            | { completionType: ShellCompletionType }\n            | undefined\n          applyShellSuggestion(\n            suggestion,\n            input,\n            cursorOffset,\n            onInputChange,\n            setCursorOffset,\n            metadata?.completionType,\n          )\n          clearSuggestions()\n        }\n      } else if (\n        suggestionType === 'agent' &&\n        suggestions.length > 0 &&\n        suggestions[index]?.id?.startsWith('dm-')\n      ) {\n        const suggestion = suggestions[index]\n        if (suggestion) {\n          applyTriggerSuggestion(\n            suggestion,\n            input,\n            cursorOffset,\n            DM_MEMBER_RE,\n            onInputChange,\n            setCursorOffset,\n          )\n          clearSuggestions()\n        }\n      } else if (suggestionType === 'slack-channel' && suggestions.length > 0) {\n        const suggestion = suggestions[index]\n        if (suggestion) {\n          applyTriggerSuggestion(\n            suggestion,\n            input,\n            cursorOffset,\n            HASH_CHANNEL_RE,\n            onInputChange,\n            setCursorOffset,\n          )\n          clearSuggestions()\n        }\n      } else if (suggestionType === 'file' && suggestions.length > 0) {\n        const completionToken = extractCompletionToken(\n          input,\n          cursorOffset,\n          true,\n        )\n        if (!completionToken) {\n          clearSuggestions()\n          return\n        }\n\n        // Check if all suggestions share a common prefix longer than the current input\n        const commonPrefix = findLongestCommonPrefix(suggestions)\n\n        // Determine if token starts with @ to preserve it during replacement\n        const hasAtPrefix = completionToken.token.startsWith('@')\n        // The effective token length excludes the @ and quotes if present\n        let effectiveTokenLength: number\n        if (completionToken.isQuoted) {\n          // Remove @\" prefix and optional closing \" to get effective length\n          effectiveTokenLength = completionToken.token\n            .slice(2)\n            .replace(/\"$/, '').length\n        } else if (hasAtPrefix) {\n          effectiveTokenLength = completionToken.token.length - 1\n        } else {\n          effectiveTokenLength = completionToken.token.length\n        }\n\n        // If there's a common prefix longer than what the user has typed,\n        // replace the current input with the common prefix\n        if (commonPrefix.length > effectiveTokenLength) {\n          const replacementValue = formatReplacementValue({\n            displayText: commonPrefix,\n            mode,\n            hasAtPrefix,\n            needsQuotes: false, // common prefix doesn't need quotes unless already quoted\n            isQuoted: completionToken.isQuoted,\n            isComplete: false, // partial completion\n          })\n\n          applyFileSuggestion(\n            replacementValue,\n            input,\n            completionToken.token,\n            completionToken.startPos,\n            onInputChange,\n            setCursorOffset,\n          )\n          // Don't clear suggestions so user can continue typing or select a specific option\n          // Instead, update for the new prefix\n          void updateSuggestions(\n            input.replace(completionToken.token, replacementValue),\n            cursorOffset,\n          )\n        } else if (index < suggestions.length) {\n          // Otherwise, apply the selected suggestion\n          const suggestion = suggestions[index]\n          if (suggestion) {\n            const needsQuotes = suggestion.displayText.includes(' ')\n            const replacementValue = formatReplacementValue({\n              displayText: suggestion.displayText,\n              mode,\n              hasAtPrefix,\n              needsQuotes,\n              isQuoted: completionToken.isQuoted,\n              isComplete: true, // complete suggestion\n            })\n\n            applyFileSuggestion(\n              replacementValue,\n              input,\n              completionToken.token,\n              completionToken.startPos,\n              onInputChange,\n              setCursorOffset,\n            )\n            clearSuggestions()\n          }\n        }\n      }\n    } else if (input.trim() !== '') {\n      let suggestionType: SuggestionType\n      let suggestionItems: SuggestionItem[]\n\n      if (mode === 'bash') {\n        suggestionType = 'shell'\n        // This should be very fast, taking <10ms\n        const bashSuggestions = await generateBashSuggestions(\n          input,\n          cursorOffset,\n        )\n        if (bashSuggestions.length === 1) {\n          // If single suggestion, apply it immediately\n          const suggestion = bashSuggestions[0]\n          if (suggestion) {\n            const metadata = suggestion.metadata as\n              | { completionType: ShellCompletionType }\n              | undefined\n            applyShellSuggestion(\n              suggestion,\n              input,\n              cursorOffset,\n              onInputChange,\n              setCursorOffset,\n              metadata?.completionType,\n            )\n          }\n          suggestionItems = []\n        } else {\n          suggestionItems = bashSuggestions\n        }\n      } else {\n        suggestionType = 'file'\n        // If no suggestions, fetch file and MCP resource suggestions\n        const completionInfo = extractCompletionToken(input, cursorOffset, true)\n        if (completionInfo) {\n          // If token starts with @, search without the @ prefix\n          const isAtSymbol = completionInfo.token.startsWith('@')\n          const searchToken = isAtSymbol\n            ? completionInfo.token.substring(1)\n            : completionInfo.token\n\n          suggestionItems = await generateUnifiedSuggestions(\n            searchToken,\n            mcpResources,\n            agents,\n            isAtSymbol,\n          )\n        } else {\n          suggestionItems = []\n        }\n      }\n\n      if (suggestionItems.length > 0) {\n        // Multiple suggestions or not bash mode: show list\n        setSuggestionsState(prev => ({\n          commandArgumentHint: undefined,\n          suggestions: suggestionItems,\n          selectedSuggestion: getPreservedSelection(\n            prev.suggestions,\n            prev.selectedSuggestion,\n            suggestionItems,\n          ),\n        }))\n        setSuggestionType(suggestionType)\n        setMaxColumnWidth(undefined)\n      }\n    }\n  }, [\n    suggestions,\n    selectedSuggestion,\n    input,\n    suggestionType,\n    commands,\n    mode,\n    onInputChange,\n    setCursorOffset,\n    onSubmit,\n    clearSuggestions,\n    cursorOffset,\n    updateSuggestions,\n    mcpResources,\n    setSuggestionsState,\n    agents,\n    debouncedFetchFileSuggestions,\n    debouncedFetchSlackChannels,\n    effectiveGhostText,\n  ])\n\n  // Handle enter key press - apply and execute suggestions\n  const handleEnter = useCallback(() => {\n    if (selectedSuggestion < 0 || suggestions.length === 0) return\n\n    const suggestion = suggestions[selectedSuggestion]\n\n    if (\n      suggestionType === 'command' &&\n      selectedSuggestion < suggestions.length\n    ) {\n      if (suggestion) {\n        applyCommandSuggestion(\n          suggestion,\n          true, // execute on return\n          commands,\n          onInputChange,\n          setCursorOffset,\n          onSubmit,\n        )\n        debouncedFetchFileSuggestions.cancel()\n        clearSuggestions()\n      }\n    } else if (\n      suggestionType === 'custom-title' &&\n      selectedSuggestion < suggestions.length\n    ) {\n      // Apply custom title and execute /resume command with sessionId\n      if (suggestion) {\n        const newInput = buildResumeInputFromSuggestion(suggestion)\n        onInputChange(newInput)\n        setCursorOffset(newInput.length)\n        onSubmit(newInput, /* isSubmittingSlashCommand */ true)\n        debouncedFetchFileSuggestions.cancel()\n        clearSuggestions()\n      }\n    } else if (\n      suggestionType === 'shell' &&\n      selectedSuggestion < suggestions.length\n    ) {\n      const suggestion = suggestions[selectedSuggestion]\n      if (suggestion) {\n        const metadata = suggestion.metadata as\n          | { completionType: ShellCompletionType }\n          | undefined\n        applyShellSuggestion(\n          suggestion,\n          input,\n          cursorOffset,\n          onInputChange,\n          setCursorOffset,\n          metadata?.completionType,\n        )\n        debouncedFetchFileSuggestions.cancel()\n        clearSuggestions()\n      }\n    } else if (\n      suggestionType === 'agent' &&\n      selectedSuggestion < suggestions.length &&\n      suggestion?.id?.startsWith('dm-')\n    ) {\n      applyTriggerSuggestion(\n        suggestion,\n        input,\n        cursorOffset,\n        DM_MEMBER_RE,\n        onInputChange,\n        setCursorOffset,\n      )\n      debouncedFetchFileSuggestions.cancel()\n      clearSuggestions()\n    } else if (\n      suggestionType === 'slack-channel' &&\n      selectedSuggestion < suggestions.length\n    ) {\n      if (suggestion) {\n        applyTriggerSuggestion(\n          suggestion,\n          input,\n          cursorOffset,\n          HASH_CHANNEL_RE,\n          onInputChange,\n          setCursorOffset,\n        )\n        debouncedFetchSlackChannels.cancel()\n        clearSuggestions()\n      }\n    } else if (\n      suggestionType === 'file' &&\n      selectedSuggestion < suggestions.length\n    ) {\n      // Extract completion token directly when needed\n      const completionInfo = extractCompletionToken(input, cursorOffset, true)\n      if (completionInfo) {\n        if (suggestion) {\n          const hasAtPrefix = completionInfo.token.startsWith('@')\n          const needsQuotes = suggestion.displayText.includes(' ')\n          const replacementValue = formatReplacementValue({\n            displayText: suggestion.displayText,\n            mode,\n            hasAtPrefix,\n            needsQuotes,\n            isQuoted: completionInfo.isQuoted,\n            isComplete: true, // complete suggestion\n          })\n\n          applyFileSuggestion(\n            replacementValue,\n            input,\n            completionInfo.token,\n            completionInfo.startPos,\n            onInputChange,\n            setCursorOffset,\n          )\n          debouncedFetchFileSuggestions.cancel()\n          clearSuggestions()\n        }\n      }\n    } else if (\n      suggestionType === 'directory' &&\n      selectedSuggestion < suggestions.length\n    ) {\n      if (suggestion) {\n        // In command context (e.g., /add-dir), Enter submits the command\n        // rather than applying the directory suggestion. Just clear\n        // suggestions and let the submit handler process the current input.\n        if (isCommandInput(input)) {\n          debouncedFetchFileSuggestions.cancel()\n          clearSuggestions()\n          return\n        }\n\n        // General path completion: replace the path token\n        const completionTokenWithAt = extractCompletionToken(\n          input,\n          cursorOffset,\n          true,\n        )\n        const completionToken =\n          completionTokenWithAt ??\n          extractCompletionToken(input, cursorOffset, false)\n\n        if (completionToken) {\n          const isDir =\n            isPathMetadata(suggestion.metadata) &&\n            suggestion.metadata.type === 'directory'\n          const result = applyDirectorySuggestion(\n            input,\n            suggestion.id,\n            completionToken.startPos,\n            completionToken.token.length,\n            isDir,\n          )\n          onInputChange(result.newInput)\n          setCursorOffset(result.cursorPos)\n        }\n        // If no completion token found (e.g., cursor after space), don't modify input\n        // to avoid data loss - just clear suggestions\n\n        debouncedFetchFileSuggestions.cancel()\n        clearSuggestions()\n      }\n    }\n  }, [\n    suggestions,\n    selectedSuggestion,\n    suggestionType,\n    commands,\n    input,\n    cursorOffset,\n    mode,\n    onInputChange,\n    setCursorOffset,\n    onSubmit,\n    clearSuggestions,\n    debouncedFetchFileSuggestions,\n    debouncedFetchSlackChannels,\n  ])\n\n  // Handler for autocomplete:accept - accepts current suggestion via Tab or Right Arrow\n  const handleAutocompleteAccept = useCallback(() => {\n    void handleTab()\n  }, [handleTab])\n\n  // Handler for autocomplete:dismiss - clears suggestions and prevents re-triggering\n  const handleAutocompleteDismiss = useCallback(() => {\n    debouncedFetchFileSuggestions.cancel()\n    debouncedFetchSlackChannels.cancel()\n    clearSuggestions()\n    // Remember the input when dismissed to prevent immediate re-triggering\n    dismissedForInputRef.current = input\n  }, [\n    debouncedFetchFileSuggestions,\n    debouncedFetchSlackChannels,\n    clearSuggestions,\n    input,\n  ])\n\n  // Handler for autocomplete:previous - selects previous suggestion\n  const handleAutocompletePrevious = useCallback(() => {\n    setSuggestionsState(prev => ({\n      ...prev,\n      selectedSuggestion:\n        prev.selectedSuggestion <= 0\n          ? suggestions.length - 1\n          : prev.selectedSuggestion - 1,\n    }))\n  }, [suggestions.length, setSuggestionsState])\n\n  // Handler for autocomplete:next - selects next suggestion\n  const handleAutocompleteNext = useCallback(() => {\n    setSuggestionsState(prev => ({\n      ...prev,\n      selectedSuggestion:\n        prev.selectedSuggestion >= suggestions.length - 1\n          ? 0\n          : prev.selectedSuggestion + 1,\n    }))\n  }, [suggestions.length, setSuggestionsState])\n\n  // Autocomplete context keybindings - only active when suggestions are visible\n  const autocompleteHandlers = useMemo(\n    () => ({\n      'autocomplete:accept': handleAutocompleteAccept,\n      'autocomplete:dismiss': handleAutocompleteDismiss,\n      'autocomplete:previous': handleAutocompletePrevious,\n      'autocomplete:next': handleAutocompleteNext,\n    }),\n    [\n      handleAutocompleteAccept,\n      handleAutocompleteDismiss,\n      handleAutocompletePrevious,\n      handleAutocompleteNext,\n    ],\n  )\n\n  // Register autocomplete as an overlay so CancelRequestHandler defers ESC handling\n  // This ensures ESC dismisses autocomplete before canceling running tasks\n  const isAutocompleteActive = suggestions.length > 0 || !!effectiveGhostText\n  const isModalOverlayActive = useIsModalOverlayActive()\n  useRegisterOverlay('autocomplete', isAutocompleteActive)\n  // Register Autocomplete context so it appears in activeContexts for other handlers.\n  // This allows Chat's resolver to see Autocomplete and defer to its bindings for up/down.\n  useRegisterKeybindingContext('Autocomplete', isAutocompleteActive)\n\n  // Disable autocomplete keybindings when a modal overlay (e.g., DiffDialog) is active,\n  // so escape reaches the overlay's handler instead of dismissing autocomplete\n  useKeybindings(autocompleteHandlers, {\n    context: 'Autocomplete',\n    isActive: isAutocompleteActive && !isModalOverlayActive,\n  })\n\n  function acceptSuggestionText(text: string): void {\n    const detectedMode = getModeFromInput(text)\n    if (detectedMode !== 'prompt' && onModeChange) {\n      onModeChange(detectedMode)\n      const stripped = getValueFromInput(text)\n      onInputChange(stripped)\n      setCursorOffset(stripped.length)\n    } else {\n      onInputChange(text)\n      setCursorOffset(text.length)\n    }\n  }\n\n  // Handle keyboard input for behaviors not covered by keybindings\n  const handleKeyDown = (e: KeyboardEvent): void => {\n    // Handle right arrow to accept prompt suggestion ghost text\n    if (e.key === 'right' && !isViewingTeammate) {\n      const suggestionText = promptSuggestion.text\n      const suggestionShownAt = promptSuggestion.shownAt\n      if (suggestionText && suggestionShownAt > 0 && input === '') {\n        markAccepted()\n        acceptSuggestionText(suggestionText)\n        e.stopImmediatePropagation()\n        return\n      }\n    }\n\n    // Handle Tab key fallback behaviors when no autocomplete suggestions\n    // Don't handle tab if shift is pressed (used for mode cycle)\n    if (e.key === 'tab' && !e.shift) {\n      // Skip if autocomplete is handling this (suggestions or ghost text exist)\n      if (suggestions.length > 0 || effectiveGhostText) {\n        return\n      }\n      // Accept prompt suggestion if it exists in AppState\n      const suggestionText = promptSuggestion.text\n      const suggestionShownAt = promptSuggestion.shownAt\n      if (\n        suggestionText &&\n        suggestionShownAt > 0 &&\n        input === '' &&\n        !isViewingTeammate\n      ) {\n        e.preventDefault()\n        markAccepted()\n        acceptSuggestionText(suggestionText)\n        return\n      }\n      // Remind user about thinking toggle shortcut if empty input\n      if (input.trim() === '') {\n        e.preventDefault()\n        addNotification({\n          key: 'thinking-toggle-hint',\n          jsx: (\n            <Text dimColor>\n              Use {thinkingToggleShortcut} to toggle thinking\n            </Text>\n          ),\n          priority: 'immediate',\n          timeoutMs: 3000,\n        })\n      }\n      return\n    }\n\n    // Only continue with navigation if we have suggestions\n    if (suggestions.length === 0) return\n\n    // Handle Ctrl-N/P for navigation (arrows handled by keybindings)\n    // Skip if we're in the middle of a chord sequence to allow chords like ctrl+f n\n    const hasPendingChord = keybindingContext?.pendingChord != null\n    if (e.ctrl && e.key === 'n' && !hasPendingChord) {\n      e.preventDefault()\n      handleAutocompleteNext()\n      return\n    }\n\n    if (e.ctrl && e.key === 'p' && !hasPendingChord) {\n      e.preventDefault()\n      handleAutocompletePrevious()\n      return\n    }\n\n    // Handle selection and execution via return/enter\n    // Shift+Enter and Meta+Enter insert newlines (handled by useTextInput),\n    // so don't accept the suggestion for those.\n    if (e.key === 'return' && !e.shift && !e.meta) {\n      e.preventDefault()\n      handleEnter()\n    }\n  }\n\n  // Backward-compat bridge: PromptInput doesn't yet wire handleKeyDown to\n  // <Box onKeyDown>. Subscribe via useInput and adapt InputEvent →\n  // KeyboardEvent until the consumer is migrated (separate PR).\n  // TODO(onKeyDown-migration): remove once PromptInput passes handleKeyDown.\n  useInput((_input, _key, event) => {\n    const kbEvent = new KeyboardEvent(event.keypress)\n    handleKeyDown(kbEvent)\n    if (kbEvent.didStopImmediatePropagation()) {\n      event.stopImmediatePropagation()\n    }\n  })\n\n  return {\n    suggestions,\n    selectedSuggestion,\n    suggestionType,\n    maxColumnWidth,\n    commandArgumentHint,\n    inlineGhostText: effectiveGhostText,\n    handleKeyDown,\n  }\n}\n"],"mappings":"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","ignoreList":[]}