@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/hooks/useTypeahead.js

@@ -0,0 +1,1617 @@
+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 { getShellCompletions } from '../utils/bash/shellCompletion.js';
+import { formatLogMetadata } from '../utils/format.js';
+import { getSessionIdFromLog, searchSessionsByCustomTitle } from '../utils/sessionStorage.js';
+import { applyCommandSuggestion, findMidInputSlashCommand, getBestCommandMatch, isCommandInput } from '../utils/suggestions/commandSuggestions.js';
+import { getDirectoryCompletions } 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 WORKSPACE_SUBCOMMANDS = ['list', 'show', 'enable', 'disable', 'setup', 'orchestrator'];
+const TEAM_SUBCOMMANDS = ['list', 'create', 'show', 'orchestrator', 'domain', 'add-member'];
+const WORKSPACE_COMMON_DOMAINS = ['frontend', 'backend', 'docs', 'tests', 'review', 'database', 'devops'];
+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 replaceWorkspaceArgs(newArgs) {
+    const commandPrefix = '/workspace';
+    return newArgs.length > 0 ? `${commandPrefix} ${newArgs}` : commandPrefix;
+}
+function buildWorkspaceArgSuggestion(id, displayText, replacement, description) {
+    return {
+        id,
+        displayText,
+        description,
+        metadata: {
+            replacement
+        }
+    };
+}
+function replaceTeamArgs(newArgs) {
+    const commandPrefix = '/team';
+    return newArgs.length > 0 ? `${commandPrefix} ${newArgs}` : commandPrefix;
+}
+function buildTeamArgSuggestion(id, displayText, replacement, description) {
+    return {
+        id,
+        displayText,
+        description,
+        metadata: {
+            replacement
+        }
+    };
+}
+function getProviderCommandSuggestions(value) {
+    const parsed = extractCommandNameAndArgs(value);
+    if (!parsed || parsed.commandName !== 'provider') {
+        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 makeProviderSuggestions = (partial) => PROFILE_PROVIDER_OPTIONS.filter(option => option.provider.startsWith(partial.toLowerCase())).map(option => buildProfileArgSuggestion(`provider-choice-${option.provider}`, option.provider, `/provider ${option.provider} `, option.label));
+    const makeProfileSuggestions = (provider, partial) => {
+        const profiles = listProviderProfiles(provider);
+        return profiles
+            .filter(profile => profile.name.toLowerCase().startsWith(partial.toLowerCase()))
+            .map(profile => buildProfileArgSuggestion(`provider-profile-${profile.id}`, profile.name, `/provider ${provider} ${profile.name} `, `${profile.agentName}${profile.lastModel ? ` · ${profile.lastModel}` : ''}`));
+    };
+    if (tokens.length <= 1) {
+        const partial = firstToken.toLowerCase();
+        const subcommands = ['list', 'current', 'reset'];
+        const suggestions = [
+            ...subcommands
+                .filter(s => s.startsWith(partial))
+                .map(s => buildProfileArgSuggestion(`provider-subcommand-${s}`, s, `/provider ${s} `, s === 'list' ? 'Listar proveedores' : s === 'current' ? 'Ver proveedor actual' : 'Resetear configuración')),
+            ...makeProviderSuggestions(partial),
+        ];
+        return {
+            suggestions,
+            commandArgumentHint: '<proveedor|list|current>',
+        };
+    }
+    if (['list', 'current', 'reset'].includes(firstToken.toLowerCase())) {
+        return {
+            suggestions: [],
+            commandArgumentHint: undefined,
+        };
+    }
+    // Si el primer token es un proveedor válido
+    if (PROFILE_PROVIDER_OPTIONS.some(o => o.provider === firstToken.toLowerCase())) {
+        if (tokens.length <= 2) {
+            const partial = secondToken.toLowerCase();
+            const profiles = makeProfileSuggestions(firstToken.toLowerCase(), partial);
+            const keywords = ['reset', 'set', 'url', 'clear'].filter(k => k.startsWith(partial)).map(k => buildProfileArgSuggestion(`provider-keyword-${k}`, k, `/provider ${firstToken} ${k} `, `Acción: ${k}`));
+            return {
+                suggestions: [...profiles, ...keywords],
+                commandArgumentHint: '<perfil|url|reset>',
+            };
+        }
+    }
+    return {
+        suggestions: [],
+        commandArgumentHint: undefined,
+    };
+}
+function getProviderAgentRefSuggestions(partial, prefixTokens, trailingSpace = true) {
+    const normalizedPartial = partial.toLowerCase();
+    const suggestions = [];
+    for (const option of PROFILE_PROVIDER_OPTIONS) {
+        for (const profile of listProviderProfiles(option.provider)) {
+            const agentRef = `${option.provider}/${profile.agentName || `${profile.name}-lead`}`;
+            if (!agentRef.toLowerCase().startsWith(normalizedPartial)) {
+                continue;
+            }
+            suggestions.push(buildTeamArgSuggestion(`team-agent-${profile.id}`, agentRef, replaceTeamArgs([...prefixTokens, agentRef].join(' ') + (trailingSpace ? ' ' : '')), profile.lastModel ? `${option.label} - ${profile.lastModel}` : option.label));
+        }
+    }
+    return suggestions;
+}
+function getTeamCommandSuggestions(value) {
+    const parsed = extractCommandNameAndArgs(value);
+    if (!parsed || parsed.commandName !== 'team') {
+        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 normalizedFirst = firstToken.toLowerCase();
+    if (tokens.length <= 1) {
+        const partial = firstToken.toLowerCase();
+        return {
+            suggestions: TEAM_SUBCOMMANDS.filter(option => option.startsWith(partial)).map(option => buildTeamArgSuggestion(`team-subcommand-${option}`, option, replaceTeamArgs(`${option} `))),
+            commandArgumentHint: '<subcomando>'
+        };
+    }
+    if (normalizedFirst === 'list') {
+        return {
+            suggestions: [],
+            commandArgumentHint: undefined
+        };
+    }
+    if (normalizedFirst === 'create') {
+        return {
+            suggestions: [],
+            commandArgumentHint: '<nombre-equipo>'
+        };
+    }
+    if (normalizedFirst === 'show') {
+        return {
+            suggestions: [],
+            commandArgumentHint: '<equipo>'
+        };
+    }
+    if (normalizedFirst === 'orchestrator') {
+        if (tokens.length <= 2) {
+            return {
+                suggestions: [],
+                commandArgumentHint: '<equipo>'
+            };
+        }
+        const currentToken = tokens[tokens.length - 1] ?? '';
+        const prefixTokens = tokens.slice(0, tokens.length - 1);
+        return {
+            suggestions: getProviderAgentRefSuggestions(currentToken, prefixTokens, false),
+            commandArgumentHint: '<provider/agent>'
+        };
+    }
+    if (normalizedFirst === 'domain') {
+        if (tokens.length <= 2) {
+            return {
+                suggestions: [],
+                commandArgumentHint: '<equipo>'
+            };
+        }
+        if (tokens.length <= 3) {
+            const teamName = tokens[1] ?? '';
+            const partialDomain = (tokens[2] ?? '').toLowerCase();
+            return {
+                suggestions: WORKSPACE_COMMON_DOMAINS.filter(domain => domain.startsWith(partialDomain)).map(domain => buildTeamArgSuggestion(`team-domain-${domain}`, domain, replaceTeamArgs(['domain', teamName, domain, ''].join(' ').trimEnd() + ' '), `area ${domain}`)),
+                commandArgumentHint: '<area>'
+            };
+        }
+        const currentToken = tokens[tokens.length - 1] ?? '';
+        const prefixTokens = tokens.slice(0, tokens.length - 1);
+        return {
+            suggestions: getProviderAgentRefSuggestions(currentToken, prefixTokens, false),
+            commandArgumentHint: '<provider/agent>'
+        };
+    }
+    if (normalizedFirst === 'add-member') {
+        if (tokens.length <= 2) {
+            return {
+                suggestions: [],
+                commandArgumentHint: '<equipo>'
+            };
+        }
+        if (tokens.length <= 3) {
+            const teamName = tokens[1] ?? '';
+            const partialDomain = (tokens[2] ?? '').toLowerCase();
+            return {
+                suggestions: WORKSPACE_COMMON_DOMAINS.filter(domain => domain.startsWith(partialDomain)).map(domain => buildTeamArgSuggestion(`team-member-domain-${domain}`, domain, replaceTeamArgs(['add-member', teamName, domain, ''].join(' ').trimEnd() + ' '), `area ${domain}`)),
+                commandArgumentHint: '<area>'
+            };
+        }
+        if (tokens.length <= 4) {
+            const currentToken = tokens[3] ?? '';
+            const prefixTokens = tokens.slice(0, 3);
+            return {
+                suggestions: getProviderAgentRefSuggestions(currentToken, prefixTokens),
+                commandArgumentHint: '<provider/agent>'
+            };
+        }
+        return {
+            suggestions: [],
+            commandArgumentHint: '[duty]'
+        };
+    }
+    return {
+        suggestions: [],
+        commandArgumentHint: undefined
+    };
+}
+function getWorkspaceCommandSuggestions(value) {
+    const parsed = extractCommandNameAndArgs(value);
+    if (!parsed || parsed.commandName !== 'workspace') {
+        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 normalizedFirst = firstToken.toLowerCase();
+    if (tokens.length <= 1) {
+        const partial = firstToken.toLowerCase();
+        return {
+            suggestions: WORKSPACE_SUBCOMMANDS.filter(option => option.startsWith(partial)).map(option => buildWorkspaceArgSuggestion(`workspace-subcommand-${option}`, option, replaceWorkspaceArgs(`${option} `))),
+            commandArgumentHint: '<subcomando>'
+        };
+    }
+    if (['show', 'enable', 'disable'].includes(normalizedFirst) && tokens.length <= 2) {
+        const partial = (tokens[1] ?? '').toLowerCase();
+        return {
+            suggestions: PROFILE_PROVIDER_OPTIONS.filter(option => option.provider.startsWith(partial)).map(option => buildWorkspaceArgSuggestion(`workspace-provider-${option.provider}`, option.provider, replaceWorkspaceArgs(`${normalizedFirst} ${option.provider}`), option.label)),
+            commandArgumentHint: '<proveedor>'
+        };
+    }
+    if (normalizedFirst === 'orchestrator') {
+        return {
+            suggestions: [],
+            commandArgumentHint: '[equipo] [provider/agent]'
+        };
+    }
+    if (normalizedFirst !== 'setup') {
+        return {
+            suggestions: [],
+            commandArgumentHint: undefined
+        };
+    }
+    if (tokens.length <= 2) {
+        return {
+            suggestions: [],
+            commandArgumentHint: '<equipo> [orchestrator=<area|provider/agent>]'
+        };
+    }
+    const currentIndex = tokens.length - 1;
+    const currentToken = tokens[currentIndex] ?? '';
+    const prefixTokens = tokens.slice(0, currentIndex);
+    const hasOrchestratorToken = prefixTokens.some(token => token.toLowerCase().startsWith('orchestrator='));
+    if (!hasOrchestratorToken && 'orchestrator='.startsWith(currentToken.toLowerCase())) {
+        return {
+            suggestions: [buildWorkspaceArgSuggestion('workspace-orchestrator', 'orchestrator=', replaceWorkspaceArgs([...prefixTokens, 'orchestrator='].join(' ')), 'escoger coordinador principal')],
+            commandArgumentHint: 'orchestrator=<area|provider/agent>'
+        };
+    }
+    if (currentToken.toLowerCase().startsWith('orchestrator=')) {
+        const partial = currentToken.slice('orchestrator='.length).toLowerCase();
+        const domainSuggestions = WORKSPACE_COMMON_DOMAINS.filter(domain => domain.startsWith(partial)).map(domain => buildWorkspaceArgSuggestion(`workspace-orchestrator-domain-${domain}`, domain, replaceWorkspaceArgs([...prefixTokens, `orchestrator=${domain} `].join(' ').trimEnd()), `usar el area ${domain} como orquestador`));
+        const agentSuggestions = [];
+        for (const option of PROFILE_PROVIDER_OPTIONS) {
+            for (const profile of listProviderProfiles(option.provider)) {
+                const valueForEntry = `${option.provider}/${profile.agentName || `${profile.name}-lead`}`;
+                if (!valueForEntry.toLowerCase().startsWith(partial)) {
+                    continue;
+                }
+                agentSuggestions.push(buildWorkspaceArgSuggestion(`workspace-orchestrator-agent-${profile.id}`, valueForEntry, replaceWorkspaceArgs([...prefixTokens, `orchestrator=${valueForEntry} `].join(' ').trimEnd()), `agente de ${option.label}`));
+            }
+        }
+        return {
+            suggestions: [...domainSuggestions, ...agentSuggestions],
+            commandArgumentHint: 'orchestrator=<area|provider/agent>'
+        };
+    }
+    const colonIndex = currentToken.indexOf(':');
+    if (colonIndex >= 0) {
+        const providerProfile = currentToken.slice(0, colonIndex);
+        const partialDomain = currentToken.slice(colonIndex + 1).toLowerCase();
+        const suggestions = WORKSPACE_COMMON_DOMAINS.filter(domain => domain.startsWith(partialDomain)).map(domain => buildWorkspaceArgSuggestion(`workspace-domain-${providerProfile}-${domain}`, domain, replaceWorkspaceArgs([...prefixTokens, `${providerProfile}:${domain} `].join(' ').trimEnd()), `area ${domain}`));
+        return {
+            suggestions,
+            commandArgumentHint: '<proveedor/perfil:area>'
+        };
+    }
+    const partial = currentToken.toLowerCase();
+    const profileSuggestions = [];
+    for (const option of PROFILE_PROVIDER_OPTIONS) {
+        for (const profile of listProviderProfiles(option.provider)) {
+            const valueForEntry = `${option.provider}/${profile.name}`;
+            if (!valueForEntry.toLowerCase().startsWith(partial)) {
+                continue;
+            }
+            profileSuggestions.push(buildWorkspaceArgSuggestion(`workspace-profile-${profile.id}`, `${valueForEntry}:`, replaceWorkspaceArgs([...prefixTokens, `${valueForEntry}:`].join(' ')), profile.lastModel ? `${option.label} - ${profile.lastModel}` : option.label));
+        }
+    }
+    return {
+        suggestions: profileSuggestions,
+        commandArgumentHint: '<proveedor/perfil:area>'
+    };
+}
+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 teamSuggestions = mode === 'prompt' ? getTeamCommandSuggestions(value) : null;
+        if (teamSuggestions) {
+            const { suggestions: teamItems, commandArgumentHint } = teamSuggestions;
+            setSuggestionsState(() => ({
+                commandArgumentHint,
+                suggestions: teamItems,
+                selectedSuggestion: teamItems.length > 0 ? 0 : -1
+            }));
+            setSuggestionType(teamItems.length > 0 ? 'command-arg' : 'none');
+            setMaxColumnWidth(undefined);
+            return;
+        }
+        const workspaceSuggestions = mode === 'prompt' ? getWorkspaceCommandSuggestions(value) : null;
+        if (workspaceSuggestions) {
+            const { suggestions: workspaceItems, commandArgumentHint } = workspaceSuggestions;
+            setSuggestionsState(() => ({
+                commandArgumentHint,
+                suggestions: workspaceItems,
+                selectedSuggestion: workspaceItems.length > 0 ? 0 : -1
+            }));
+            setSuggestionType(workspaceItems.length > 0 ? 'command-arg' : 'none');
+            setMaxColumnWidth(undefined);
+            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;
+        }
+        const providerSuggestions = mode === 'prompt' ? getProviderCommandSuggestions(value) : null;
+        if (providerSuggestions) {
+            const { suggestions: providerItems, commandArgumentHint } = providerSuggestions;
+            setSuggestionsState(() => ({
+                commandArgumentHint,
+                suggestions: providerItems,
+                selectedSuggestion: providerItems.length > 0 ? 0 : -1
+            }));
+            setSuggestionType(providerItems.length > 0 ? 'command-arg' : 'none');
+            setMaxColumnWidth(undefined);
+            return;
+        }
+        // General slash command suggestions
+        if (mode !== 'bash' && isCommandInput(value) && effectiveCursorOffset > 0 && !isAtEndWithWhitespace) {
+            const partialCommand = value.slice(1).toLowerCase();
+            if (!hasCommandWithArguments(isAtEndWithWhitespace, value)) {
+                // Filter commands based on partial input
+                const filteredCommands = commands
+                    .filter(cmd => !cmd.isHidden)
+                    .filter(cmd => {
+                    const cmdName = getCommandName(cmd);
+                    return cmdName.startsWith(partialCommand) || (cmd.aliases ?? []).some(alias => alias.startsWith(partialCommand));
+                })
+                    .map(cmd => ({
+                    id: getCommandName(cmd),
+                    displayText: `/${getCommandName(cmd)}`,
+                    description: cmd.description ?? ''
+                }));
+                setSuggestionsState(prev => ({
+                    commandArgumentHint: undefined,
+                    suggestions: filteredCommands,
+                    selectedSuggestion: getPreservedSelection(prev.suggestions, prev.selectedSuggestion, filteredCommands)
+                }));
+                setSuggestionType(filteredCommands.length > 0 ? 'command' : 'none');
+                setMaxColumnWidth(filteredCommands.length > 0 ? allCommandsMaxWidth : undefined);
+                return;
+            }
+        }
+        // Handle @ file suggestions
+        if (hasAtSymbol) {
+            const completionToken = extractCompletionToken(value, effectiveCursorOffset, true);
+            if (completionToken) {
+                const isAtSymbolPrefix = completionToken.token.startsWith('@');
+                const searchToken = isAtSymbolPrefix ? completionToken.token.substring(1) : completionToken.token;
+                debouncedFetchFileSuggestions(searchToken, isAtSymbolPrefix);
+                return;
+            }
+        }
+        // Default: clear suggestions
+        debouncedFetchFileSuggestions.cancel();
+        clearSuggestions();
+    }, [mode, suppressSuggestions, commands, clearSuggestions, debouncedFetchFileSuggestions, setSuggestionsState, allCommandsMaxWidth, debouncedFetchSlackChannels, suggestionType]);
+    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
+    };
+}