@iaforged/context-code 1.0.63 → 1.0.67

package/dist/src/hooks/useTypeahead.js

@@ -1,1392 +0,0 @@
-import { jsxs as _jsxs } from "react/jsx-runtime";
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { useNotifications } from '../context/notifications.js';
-import { Text } from '../ink.js';
-import { logEvent } from '../services/analytics/index.js';
-import { useDebounceCallback } from 'usehooks-ts';
-import { getCommandName } from '../commands.js';
-import { getModeFromInput, getValueFromInput } from '../components/PromptInput/inputModes.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 { isAgentSwarmsEnabled } from '../utils/agentSwarmsEnabled.js';
-import { generateProgressiveArgumentHint, parseArguments } from '../utils/argumentSubstitution.js';
-import { getShellCompletions } 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 { listProviderProfiles, } from '../utils/model/providerProfiles.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_-]*)$/;
-const PROFILE_SUBCOMMANDS = ['list', 'current', 'use', 'rename', 'remove', 'model', 'agent'];
-const PROFILE_PROVIDER_OPTIONS = [{
-        provider: 'claude',
-        label: 'Context'
-    }, {
-        provider: 'openai',
-        label: 'OpenAI'
-    }, {
-        provider: 'openrouter',
-        label: 'OpenRouter'
-    }, {
-        provider: 'ollama',
-        label: 'Ollama Local'
-    }, {
-        provider: 'ollama-cloud',
-        label: 'Ollama Cloud'
-    }, {
-        provider: 'zai',
-        label: 'Z.AI'
-    }, {
-        provider: 'minimax',
-        label: 'MiniMax'
-    }];
-// Type guard for path completion metadata
-function isPathMetadata(metadata) {
-    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, prevSelection, newSuggestions) {
-    // 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 replaceProfileArgs(value, newArgs) {
-    const commandPrefix = '/profile';
-    return newArgs.length > 0 ? `${commandPrefix} ${newArgs}` : commandPrefix;
-}
-function buildProfileArgSuggestion(id, displayText, replacement, description) {
-    return {
-        id,
-        displayText,
-        description,
-        metadata: {
-            replacement
-        }
-    };
-}
-function getProfileCommandSuggestions(value) {
-    const parsed = extractCommandNameAndArgs(value);
-    if (!parsed || parsed.commandName !== 'profile') {
-        return null;
-    }
-    const rawArgs = parsed.args ?? '';
-    const endsWithSpace = /\s$/.test(rawArgs);
-    const baseTokens = rawArgs.trim().length > 0 ? rawArgs.trim().split(/\s+/) : [];
-    const tokens = endsWithSpace ? [...baseTokens, ''] : baseTokens;
-    const firstToken = tokens[0] ?? '';
-    const secondToken = tokens[1] ?? '';
-    const thirdToken = tokens[2] ?? '';
-    const normalizedFirst = firstToken.toLowerCase();
-    const makeProviderSuggestions = (partial, prefixTokens) => PROFILE_PROVIDER_OPTIONS.filter(option => option.provider.startsWith(partial.toLowerCase())).map(option => buildProfileArgSuggestion(`profile-provider-${option.provider}`, option.provider, replaceProfileArgs(value, [...prefixTokens, option.provider, ''].join(' ').trimEnd() + ' '), option.label));
-    const makeProfileSuggestions = (provider, partial, prefixTokens) => {
-        if (!provider || !PROFILE_PROVIDER_OPTIONS.some(option => option.provider === provider)) {
-            return [];
-        }
-        const profiles = listProviderProfiles(provider);
-        return profiles.filter(profile => profile.name.toLowerCase().startsWith(partial.toLowerCase())).map(profile => buildProfileArgSuggestion(`profile-name-${profile.id}`, profile.name, replaceProfileArgs(value, [...prefixTokens, profile.name, ''].join(' ').trimEnd() + ' '), `${profile.agentName}${profile.lastModel ? ` · ${profile.lastModel}` : ''}`));
-    };
-    if (tokens.length <= 1) {
-        const partial = firstToken.toLowerCase();
-        const suggestions = PROFILE_SUBCOMMANDS.filter(option => option.startsWith(partial)).map(option => buildProfileArgSuggestion(`profile-subcommand-${option}`, option, replaceProfileArgs(value, `${option} `)));
-        return {
-            suggestions,
-            commandArgumentHint: '<subcomando>'
-        };
-    }
-    if (normalizedFirst === 'list' || normalizedFirst === 'current') {
-        return {
-            suggestions: [],
-            commandArgumentHint: undefined
-        };
-    }
-    if (normalizedFirst === 'remove' && tokens.length <= 2) {
-        const partial = secondToken.toLowerCase();
-        const suggestions = [buildProfileArgSuggestion('profile-remove-all', 'all', replaceProfileArgs(value, 'remove all'), 'Eliminar todos los perfiles'), ...makeProviderSuggestions(partial, ['remove'])];
-        return {
-            suggestions: suggestions.filter(item => item.displayText.toLowerCase().startsWith(partial)),
-            commandArgumentHint: '<proveedor|all>'
-        };
-    }
-    if (['use', 'rename', 'remove', 'model', 'agent'].includes(normalizedFirst) && tokens.length <= 2) {
-        return {
-            suggestions: makeProviderSuggestions(secondToken, [normalizedFirst]),
-            commandArgumentHint: '<proveedor>'
-        };
-    }
-    if (['use', 'remove', 'model', 'agent'].includes(normalizedFirst) && tokens.length <= 3) {
-        return {
-            suggestions: makeProfileSuggestions(secondToken, thirdToken, [normalizedFirst, secondToken]),
-            commandArgumentHint: '<perfil>'
-        };
-    }
-    if (normalizedFirst === 'rename' && tokens.length <= 3) {
-        return {
-            suggestions: makeProfileSuggestions(secondToken, thirdToken, [normalizedFirst, secondToken]),
-            commandArgumentHint: '<perfil-actual>'
-        };
-    }
-    return {
-        suggestions: [],
-        commandArgumentHint: undefined
-    };
-}
-function applyCommandArgSuggestion(suggestion, onInputChange, setCursorOffset) {
-    const metadata = suggestion.metadata;
-    const newInput = metadata?.replacement ?? suggestion.displayText;
-    onInputChange(newInput);
-    setCursorOffset(newInput.length);
-}
-function buildResumeInputFromSuggestion(suggestion) {
-    const metadata = suggestion.metadata;
-    return metadata?.sessionId ? `/resume ${metadata.sessionId}` : `/resume ${suggestion.displayText}`;
-}
-/**
- * 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) {
-    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) {
-    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, input, cursorOffset, onInputChange, setCursorOffset, completionType) {
-    const beforeCursor = input.slice(0, cursorOffset);
-    const lastSpaceIndex = beforeCursor.lastIndexOf(' ');
-    const wordStart = lastSpaceIndex + 1;
-    // Prepare the replacement text based on completion type
-    let replacementText;
-    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, input, cursorOffset, triggerRe, onInputChange, setCursorOffset) {
-    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 = null;
-/**
- * Generate bash shell completion suggestions
- */
-async function generateBashSuggestions(input, cursorOffset) {
-    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, suggestionId, tokenStartPos, tokenLength, isDirectory) {
-    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, cursorPos, includeAtSymbol = false) {
-    // 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) {
-    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, value) {
-    // 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 }) {
-    const { addNotification } = useNotifications();
-    const thinkingToggleShortcut = useShortcutDisplay('chat:thinkingToggle', 'Chat', 'alt+t');
-    const [suggestionType, setSuggestionType] = useState('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(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(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(() => {
-        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(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(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, isAtSymbol = false) => {
-        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) => {
-        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, inputCursorOffset) => {
-        // 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 = [];
-            const seen = new Set();
-            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;
-            }
-        }
-        const profileSuggestions = mode === 'prompt' ? getProfileCommandSuggestions(value) : null;
-        if (profileSuggestions) {
-            const { suggestions: profileItems, commandArgumentHint } = profileSuggestions;
-            setSuggestionsState(() => ({
-                commandArgumentHint,
-                suggestions: profileItems,
-                selectedSuggestion: profileItems.length > 0 ? 0 : -1
-            }));
-            setSuggestionType(profileItems.length > 0 ? 'command-arg' : 'none');
-            setMaxColumnWidth(undefined);
-            return;
-        }
-        // Determine whether to display the argument hint and command suggestions.
-        if (mode === 'prompt' && isCommandInput(value) && effectiveCursorOffset > 0 && !hasCommandWithArguments(isAtEndWithWhitespace, value)) {
-            let commandArgumentHint = 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) => 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?.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 === 'command-arg' && index < suggestions.length) {
-                if (suggestion) {
-                    applyCommandArgSuggestion(suggestion, onInputChange, setCursorOffset);
-                    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;
-                    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;
-                    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;
-                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;
-            let suggestionItems;
-            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;
-                        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 === 'command-arg' && selectedSuggestion < suggestions.length) {
-            if (suggestion) {
-                const metadata = suggestion.metadata;
-                const nextValue = metadata?.replacement ?? suggestion.displayText;
-                if (nextValue.trim() === input.trim()) {
-                    debouncedFetchFileSuggestions.cancel();
-                    clearSuggestions();
-                    onSubmit(input, /* isSubmittingSlashCommand */ true);
-                    return;
-                }
-                applyCommandArgSuggestion(suggestion, onInputChange, setCursorOffset);
-                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;
-                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) {
-        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) => {
-        // 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: _jsxs(Text, { dimColor: true, children: ["Use ", thinkingToggleShortcut, " to toggle thinking"] }),
-                    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
-    };
-}