centaurus-cli 3.0.0 → 3.1.0

package/dist/ui/components/InputBox.js

@@ -1,2212 +1,1682 @@
-import React, { useState, useEffect, useRef, useMemo } from 'react';
-import { Box, Text, useInput } from 'ink';
-import * as fs from 'fs';
-import * as path from 'path';
-import { useConnectivity } from '../../hooks/useConnectivity.js';
-import { Breadcrumbs } from './Breadcrumbs.js';
-import { ContextWindowIndicator } from './ContextWindowIndicator.js';
-import { logDebug } from '../../utils/logger.js';
-import { detectIntent } from '../../utils/input-classifier.js';
-import { CommandHistoryManager } from '../../utils/command-history.js';
-import { SlashCommandAutocomplete } from './SlashCommandAutocomplete.js';
-import { FileTagAutocomplete } from './FileTagAutocomplete.js';
-import { filterCommands } from '../../config/slash-commands.js';
-import { getClipboardFiles } from '../../services/clipboard-service.js';
-import { useTerminalDimensions, TERMINAL_HEIGHT_CONSTANTS } from '../../hooks/useTerminalDimensions.js';
-import { AIAutocompleteAgent, AI_AUTOCOMPLETE_DEBOUNCE_MS } from '../../services/ai-autocomplete-agent.js';
-import { workflowStorage } from '../../services/workflow-storage.js';
+import React, { useState, useEffect, useRef, useMemo } from "react";
+import { Box, Text, useInput } from "ink";
+import * as fs from "fs";
+import * as path from "path";
+import { useConnectivity } from "../../hooks/useConnectivity.js";
+import { Breadcrumbs } from "./Breadcrumbs.js";
+import { GitDiffBreadcrumb } from "./GitDiffBreadcrumb.js";
+import { ContextWindowIndicator } from "./ContextWindowIndicator.js";
+import { logDebug } from "../../utils/logger.js";
+import { detectIntent } from "../../utils/input-classifier.js";
+import { CommandHistoryManager } from "../../utils/command-history.js";
+import { SlashCommandAutocomplete } from "./SlashCommandAutocomplete.js";
+import { FileTagAutocomplete } from "./FileTagAutocomplete.js";
+import { filterCommands } from "../../config/slash-commands.js";
+import { getClipboardFiles } from "../../services/clipboard-service.js";
+import { useTerminalDimensions, TERMINAL_HEIGHT_CONSTANTS } from "../../hooks/useTerminalDimensions.js";
+import { AIAutocompleteAgent, AI_AUTOCOMPLETE_DEBOUNCE_MS } from "../../services/ai-autocomplete-agent.js";
+import { workflowStorage } from "../../services/workflow-storage.js";
+import { rulesStorage } from "../../services/rules-storage.js";
 const getVisualLines = (text, width) => {
-    const logicalLines = text.split('\n');
-    const visualLines = [];
-    let currentOffset = 0;
-    logicalLines.forEach((line, i) => {
-        if (line.length === 0) {
-            visualLines.push({ start: currentOffset, end: currentOffset, isHardEnd: true });
-            currentOffset += 1;
-            return;
-        }
-        let remaining = line;
-        let lineStartOffset = currentOffset;
-        while (remaining.length > 0) {
-            let splitIndex = remaining.length;
-            let isHardEnd = false;
-            if (remaining.length > width) {
-                splitIndex = width;
-                const lastSpace = remaining.lastIndexOf(' ', width);
-                if (lastSpace > 0) {
-                    splitIndex = lastSpace + 1;
-                }
-            }
-            else {
-                isHardEnd = true;
-            }
-            visualLines.push({
-                start: lineStartOffset,
-                end: lineStartOffset + splitIndex,
-                isHardEnd: isHardEnd
-            });
-            lineStartOffset += splitIndex;
-            remaining = remaining.slice(splitIndex);
+  const logicalLines = text.split("\n");
+  const visualLines = [];
+  let currentOffset = 0;
+  logicalLines.forEach((line, i) => {
+    if (line.length === 0) {
+      visualLines.push({ start: currentOffset, end: currentOffset, isHardEnd: true });
+      currentOffset += 1;
+      return;
+    }
+    let remaining = line;
+    let lineStartOffset = currentOffset;
+    while (remaining.length > 0) {
+      let splitIndex = remaining.length;
+      let isHardEnd = false;
+      if (remaining.length > width) {
+        splitIndex = width;
+        const lastSpace = remaining.lastIndexOf(" ", width);
+        if (lastSpace > 0) {
+          splitIndex = lastSpace + 1;
         }
-        currentOffset += line.length + (i < logicalLines.length - 1 ? 1 : 0);
-    });
-    return visualLines;
+      } else {
+        isHardEnd = true;
+      }
+      visualLines.push({
+        start: lineStartOffset,
+        end: lineStartOffset + splitIndex,
+        isHardEnd
+      });
+      lineStartOffset += splitIndex;
+      remaining = remaining.slice(splitIndex);
+    }
+    currentOffset += line.length + (i < logicalLines.length - 1 ? 1 : 0);
+  });
+  return visualLines;
 };
-export const InputBox = React.memo(({ onSubmit, placeholder = 'Ask anything...', autoAcceptMode, model, planMode = false, commandMode = false, backgroundMode = false, currentWorkingDirectory, commandHistory = [], onToggleAutoAccept, onToggleCommandMode, onToggleBackgroundMode, isActive = true, subshellContext, subshellContextStack, currentTokens = 0, maxTokens = 1000000, contextLimitReached = false, isShellRunning = false, backgroundTaskCount = 0, initialValue = '', onValueChange, onSetAutoModeSetup, sessionQuotaExhausted = false, sessionQuotaTimeRemaining = '', subAgentCount = 0, aiAutoSuggestEnabled = false, sessionCommands = [], getCheckpoints, onSetInputSetup }) => {
-    // Use initialValue for first mount, but manage state internally after that
-    const [value, setValueInternal] = useState(initialValue);
-    const [cursorOffset, setCursorOffset] = useState(0);
-    const [completions, setCompletions] = useState([]);
-    const [completionIndex, setCompletionIndex] = useState(0);
-    const [historyIndex, setHistoryIndex] = useState(-1);
-    const [tempValue, setTempValue] = useState('');
-    const ignoreNextChangeRef = useRef(false);
-    // Refs to track current value and cursor for paste handling
-    // This prevents stale closure issues when Ink calls useInput multiple times during paste
-    const valueRef = useRef(initialValue);
-    const cursorOffsetRef = useRef(0);
-    // Auto Mode State
-    const [isAutoMode, setIsAutoMode] = useState(true);
-    const [detectedIntent, setDetectedIntent] = useState('ai');
-    // Autocomplete State
-    const [autocompleteSuggestion, setAutocompleteSuggestion] = useState(null);
-    // AI Autocomplete State
-    const [aiAutocompleteSuggestion, setAiAutocompleteSuggestion] = useState(null);
-    const [isAiAutocompleteLoading, setIsAiAutocompleteLoading] = useState(false);
-    const aiAutocompleteDebounceRef = useRef(null);
-    const aiAutocompleteAbortRef = useRef(null);
-    // Undo/Redo State
-    const [undoStack, setUndoStack] = useState([]);
-    const [redoStack, setRedoStack] = useState([]);
-    // Selection State
-    const [selection, setSelection] = useState(null);
-    // Platform Detection
-    const isMac = process.platform === 'darwin';
-    // Reject Flash State (turns border red when submission is blocked)
-    const [rejectFlash, setRejectFlash] = useState(false);
-    // Session Quota Message State (shows quota exhausted message)
-    const [showQuotaMessage, setShowQuotaMessage] = useState(false);
-    // Slash Command Autocomplete State
-    const [slashAutocompleteVisible, setSlashAutocompleteVisible] = useState(false);
-    const [slashAutocompleteCommands, setSlashAutocompleteCommands] = useState([]);
-    const [slashAutocompleteSelectedIndex, setSlashAutocompleteSelectedIndex] = useState(0);
-    const [slashAutocompleteScrollOffset, setSlashAutocompleteScrollOffset] = useState(0);
-    // Connectivity State
-    const isConnected = useConnectivity();
-    // Terminal dimensions for height-aware autocomplete
-    const dimensions = useTerminalDimensions();
-    // Max 5 items, min 0 for very small terminals (use MIN_ROWS_FOR_STREAMING as threshold)
-    const slashMaxVisibleItems = dimensions.rows < TERMINAL_HEIGHT_CONSTANTS.MIN_ROWS_FOR_STREAMING
-        ? 0
-        : Math.min(5, Math.max(1, Math.floor((dimensions.rows - 20) / 3)));
-    // File Tag Autocomplete State (@ symbol)
-    const [fileTagAutocompleteVisible, setFileTagAutocompleteVisible] = useState(false);
-    const [fileTagSuggestions, setFileTagSuggestions] = useState([]);
-    const [fileTagSelectedIndex, setFileTagSelectedIndex] = useState(0);
-    const [activeFileTagStart, setActiveFileTagStart] = useState(null);
-    const [confirmedFileTags, setConfirmedFileTags] = useState([]);
-    // Clipboard File State (Alt+V paste)
-    const [confirmedClipboardFiles, setConfirmedClipboardFiles] = useState([]);
-    // Track visual line count to force re-renders when text wraps
-    // This is necessary because Ink doesn't automatically update layout when text wraps
-    const [visualLineCount, setVisualLineCount] = useState(1);
-    // Configuration for scrolling
-    const MAX_VISIBLE_LINES = 9;
-    // Wrapper for setValue that also notifies parent of changes and updates ref
-    const setValue = React.useCallback((newValue) => {
-        setValueInternal(prev => {
-            const resolvedValue = typeof newValue === 'function' ? newValue(prev) : newValue;
-            // Update ref synchronously for paste handling
-            valueRef.current = resolvedValue;
-            // Notify parent of value change for preservation across screen transitions
-            if (onValueChange) {
-                onValueChange(resolvedValue);
-            }
-            return resolvedValue;
-        });
-    }, [onValueChange]);
-    // Wrapper for setCursorOffset that also updates ref
-    const setCursorOffsetWithRef = React.useCallback((newOffset) => {
-        setCursorOffset(prev => {
-            const resolvedOffset = typeof newOffset === 'function' ? newOffset(prev) : newOffset;
-            // Update ref synchronously for paste handling
-            cursorOffsetRef.current = resolvedOffset;
-            return resolvedOffset;
-        });
-    }, []);
-    // Initialize cursor position when initialValue is provided
-    useEffect(() => {
-        if (initialValue && initialValue.length > 0) {
-            setCursorOffset(initialValue.length);
-            cursorOffsetRef.current = initialValue.length;
-        }
-    }, []); // Only run on mount
-    // Keep refs in sync with state (for cases where state is updated directly)
-    useEffect(() => {
-        valueRef.current = value;
-    }, [value]);
-    useEffect(() => {
-        cursorOffsetRef.current = cursorOffset;
-    }, [cursorOffset]);
-    // Load history on mount
-    useEffect(() => {
-        CommandHistoryManager.getInstance().load();
-    }, []);
-    // Register setInput callback for external control (e.g., for revert functionality)
-    useEffect(() => {
-        if (onSetInputSetup) {
-            onSetInputSetup((newValue) => {
-                setValue(newValue);
-                setCursorOffset(newValue.length);
-            });
-        }
-    }, [onSetInputSetup, setValue, setCursorOffset]);
-    // Register setIsAutoMode callback for external control (e.g., after background task starts)
-    useEffect(() => {
-        if (onSetInputSetup) {
-            onSetInputSetup((newValue) => {
-                setValue(newValue);
-                setCursorOffset(newValue.length);
-            });
-        }
-    }, [onSetInputSetup, setValue, setCursorOffset]);
-    useEffect(() => {
-        if (onSetAutoModeSetup) {
-            onSetAutoModeSetup((enabled) => {
-                setIsAutoMode(enabled);
-                if (enabled) {
-                    // When enabling Auto mode, also update detected intent based on current value
-                    const intent = detectIntent(value);
-                    setDetectedIntent(intent);
-                    // Set command mode based on intent
-                    if (intent === 'command' && !commandMode && onToggleCommandMode) {
-                        onToggleCommandMode();
-                    }
-                    else if (intent === 'ai' && commandMode && onToggleCommandMode) {
-                        onToggleCommandMode();
-                    }
-                }
-            });
-        }
-    }, [onSetAutoModeSetup, value, commandMode, onToggleCommandMode]);
-    // Force clear value if it becomes empty or whitespace-only after external changes
-    useEffect(() => {
-        if (value && value.trim() === '' && cursorOffset > 0) {
-            setValue('');
-            setCursorOffset(0);
-        }
-    }, [value, cursorOffset]);
-    // Track visual line count changes to force re-renders when text wraps
-    // This is crucial for the input box height to update correctly
-    useEffect(() => {
-        const termWidth = (process.stdout.columns || 80) - 6;
-        const visualLines = getVisualLines(value, termWidth);
-        const newLineCount = Math.max(1, visualLines.length);
-        if (newLineCount !== visualLineCount) {
-            setVisualLineCount(newLineCount);
-        }
-    }, [value, visualLineCount]);
-    // Determine current working directory
-    const currentDir = useMemo(() => {
-        const cwd = currentWorkingDirectory || process.cwd();
-        if (cwd.length > 60) {
-            return '...' + cwd.slice(-57);
-        }
-        return cwd;
-    }, [currentWorkingDirectory]);
-    // Determine current environment for command history isolation
-    // Format: 'local', 'ssh:user@host', or 'wsl:distroName'
-    const currentEnvironment = useMemo(() => {
-        if (!subshellContext)
-            return 'local';
-        if (subshellContext.type === 'ssh') {
-            const user = subshellContext.metadata?.username || 'user';
-            const host = subshellContext.metadata?.hostname || 'host';
-            return `ssh:${user}@${host}`;
-        }
-        if (subshellContext.type === 'wsl') {
-            const distro = subshellContext.metadata?.distroName || 'Ubuntu';
-            return `wsl:${distro}`;
-        }
-        if (subshellContext.type === 'docker') {
-            const container = subshellContext.metadata?.containerId || 'container';
-            return `docker:${container}`;
-        }
-        return 'local';
-    }, [subshellContext]);
-    // Autocomplete Logic
-    useEffect(() => {
-        if (!value || value.trim() === '') {
-            setAutocompleteSuggestion(null);
-            return;
-        }
-        // Only show suggestions if we are in command mode (manual or auto-detected)
-        // OR if we are in Auto mode and it looks like a command
-        const shouldSuggest = commandMode || (isAutoMode && detectedIntent === 'command');
-        if (shouldSuggest) {
-            const matches = CommandHistoryManager.getInstance().getMatches(value, currentDir, currentEnvironment);
-            if (matches.length > 0) {
-                setAutocompleteSuggestion(matches[0]);
-            }
-            else {
-                setAutocompleteSuggestion(null);
-            }
-        }
-        else {
-            setAutocompleteSuggestion(null);
-        }
-    }, [value, commandMode, isAutoMode, detectedIntent, aiAutoSuggestEnabled, currentDir, currentEnvironment]);
-    // AI Autocomplete Logic (5-second debounce)
-    useEffect(() => {
-        // Clear AI suggestion when value changes
-        setAiAutocompleteSuggestion(null);
-        // Clear any existing debounce timer
-        if (aiAutocompleteDebounceRef.current) {
-            clearTimeout(aiAutocompleteDebounceRef.current);
-            aiAutocompleteDebounceRef.current = null;
-        }
-        // Abort any pending AI request
-        if (aiAutocompleteAbortRef.current) {
-            aiAutocompleteAbortRef.current.abort();
-            aiAutocompleteAbortRef.current = null;
-        }
-        // Debug logging for trigger ref
-        /*
-        try {
-          if (detectedIntent !== 'ai' || value.length > 5) {
-             quickLog(`[InputBox] AI Effect: val="${value}", enabled=${aiAutoSuggestEnabled}, mode=${commandMode}, auto=${isAutoMode}, intent=${detectedIntent}`);
+const InputBox = React.memo(({
+  onSubmit,
+  placeholder = "Ask anything ...",
+  autoAcceptMode,
+  model,
+  planMode = false,
+  commandMode = false,
+  backgroundMode = false,
+  currentWorkingDirectory,
+  commandHistory = [],
+  onToggleAutoAccept,
+  onToggleCommandMode,
+  onToggleBackgroundMode,
+  isActive = true,
+  subshellContext,
+  subshellContextStack,
+  currentTokens = 0,
+  maxTokens = 1e6,
+  contextLimitReached = false,
+  isShellRunning = false,
+  backgroundTaskCount = 0,
+  initialValue = "",
+  onValueChange,
+  onSetAutoModeSetup,
+  sessionQuotaExhausted = false,
+  sessionQuotaTimeRemaining = "",
+  subAgentCount = 0,
+  aiAutoSuggestEnabled = false,
+  sessionCommands = [],
+  getCheckpoints,
+  onSetInputSetup,
+  gitDiffStats
+}) => {
+  const [value, setValueInternal] = useState(initialValue);
+  const [cursorOffset, setCursorOffset] = useState(0);
+  const [completions, setCompletions] = useState([]);
+  const [completionIndex, setCompletionIndex] = useState(0);
+  const [historyIndex, setHistoryIndex] = useState(-1);
+  const [tempValue, setTempValue] = useState("");
+  const ignoreNextChangeRef = useRef(false);
+  const valueRef = useRef(initialValue);
+  const cursorOffsetRef = useRef(0);
+  const [isAutoMode, setIsAutoMode] = useState(true);
+  const [detectedIntent, setDetectedIntent] = useState("ai");
+  const [autocompleteSuggestion, setAutocompleteSuggestion] = useState(null);
+  const [aiAutocompleteSuggestion, setAiAutocompleteSuggestion] = useState(null);
+  const [isAiAutocompleteLoading, setIsAiAutocompleteLoading] = useState(false);
+  const aiAutocompleteDebounceRef = useRef(null);
+  const aiAutocompleteAbortRef = useRef(null);
+  const [undoStack, setUndoStack] = useState([]);
+  const [redoStack, setRedoStack] = useState([]);
+  const [selection, setSelection] = useState(null);
+  const isMac = process.platform === "darwin";
+  const [rejectFlash, setRejectFlash] = useState(false);
+  const [showQuotaMessage, setShowQuotaMessage] = useState(false);
+  const [slashAutocompleteVisible, setSlashAutocompleteVisible] = useState(false);
+  const [slashAutocompleteCommands, setSlashAutocompleteCommands] = useState([]);
+  const [slashAutocompleteSelectedIndex, setSlashAutocompleteSelectedIndex] = useState(0);
+  const [slashAutocompleteScrollOffset, setSlashAutocompleteScrollOffset] = useState(0);
+  const isConnected = useConnectivity();
+  const dimensions = useTerminalDimensions();
+  const slashMaxVisibleItems = dimensions.rows < TERMINAL_HEIGHT_CONSTANTS.MIN_ROWS_FOR_STREAMING ? 0 : Math.min(5, Math.max(1, Math.floor((dimensions.rows - 20) / 3)));
+  const showBottomHints = dimensions.columns >= 90;
+  const showModeIndicator = dimensions.columns >= 70;
+  const [fileTagAutocompleteVisible, setFileTagAutocompleteVisible] = useState(false);
+  const [fileTagSuggestions, setFileTagSuggestions] = useState([]);
+  const [fileTagSelectedIndex, setFileTagSelectedIndex] = useState(0);
+  const [activeFileTagStart, setActiveFileTagStart] = useState(null);
+  const [confirmedFileTags, setConfirmedFileTags] = useState([]);
+  const [confirmedClipboardFiles, setConfirmedClipboardFiles] = useState([]);
+  const [visualLineCount, setVisualLineCount] = useState(1);
+  const MAX_VISIBLE_LINES = 9;
+  const setValue = React.useCallback((newValue) => {
+    setValueInternal((prev) => {
+      const resolvedValue = typeof newValue === "function" ? newValue(prev) : newValue;
+      valueRef.current = resolvedValue;
+      if (onValueChange) {
+        onValueChange(resolvedValue);
+      }
+      return resolvedValue;
+    });
+  }, [onValueChange]);
+  const setCursorOffsetWithRef = React.useCallback((newOffset) => {
+    setCursorOffset((prev) => {
+      const resolvedOffset = typeof newOffset === "function" ? newOffset(prev) : newOffset;
+      cursorOffsetRef.current = resolvedOffset;
+      return resolvedOffset;
+    });
+  }, []);
+  useEffect(() => {
+    if (initialValue && initialValue.length > 0) {
+      setCursorOffset(initialValue.length);
+      cursorOffsetRef.current = initialValue.length;
+    }
+  }, []);
+  useEffect(() => {
+    valueRef.current = value;
+  }, [value]);
+  useEffect(() => {
+    cursorOffsetRef.current = cursorOffset;
+  }, [cursorOffset]);
+  useEffect(() => {
+    CommandHistoryManager.getInstance().load();
+  }, []);
+  useEffect(() => {
+    if (onSetInputSetup) {
+      onSetInputSetup((newValue) => {
+        setValue(newValue);
+        setCursorOffset(newValue.length);
+      });
+    }
+  }, [onSetInputSetup, setValue, setCursorOffset]);
+  useEffect(() => {
+    if (onSetInputSetup) {
+      onSetInputSetup((newValue) => {
+        setValue(newValue);
+        setCursorOffset(newValue.length);
+      });
+    }
+  }, [onSetInputSetup, setValue, setCursorOffset]);
+  useEffect(() => {
+    if (onSetAutoModeSetup) {
+      onSetAutoModeSetup((enabled) => {
+        setIsAutoMode(enabled);
+        if (enabled) {
+          const intent = detectIntent(value);
+          setDetectedIntent(intent);
+          if (intent === "command" && !commandMode && onToggleCommandMode) {
+            onToggleCommandMode();
+          } else if (intent === "ai" && commandMode && onToggleCommandMode) {
+            onToggleCommandMode();
           }
-        } catch (e) {}
-        */
-        // Don't trigger AI autocomplete if disabled or not in command mode
-        if (!aiAutoSuggestEnabled) {
-            // quickLog('[InputBox] AI skipped: disabled');
-            return;
-        }
-        const shouldSuggest = commandMode || (isAutoMode && detectedIntent === 'command');
-        if (!shouldSuggest) {
-            // if (value.length > 3) quickLog(`[InputBox] AI skipped: !shouldSuggest (cmd=${commandMode}, auto=${isAutoMode}, intent=${detectedIntent})`);
-            return;
-        }
-        // Don't suggest for empty, very short, or slash commands
-        if (!value || value.trim().length < 2 || value.startsWith('/')) {
-            // quickLog('[InputBox] AI skipped: too short or slash');
-            return;
         }
-        // quickLog('[InputBox] AI Triggering debounce...');
-        // Set up 5-second debounce timer
-        aiAutocompleteDebounceRef.current = setTimeout(async () => {
-            setIsAiAutocompleteLoading(true);
-            // Create abort controller for this request
-            const abortController = new AbortController();
-            aiAutocompleteAbortRef.current = abortController;
+      });
+    }
+  }, [onSetAutoModeSetup, value, commandMode, onToggleCommandMode]);
+  useEffect(() => {
+    if (value && value.trim() === "" && cursorOffset > 0) {
+      setValue("");
+      setCursorOffset(0);
+    }
+  }, [value, cursorOffset]);
+  useEffect(() => {
+    const termWidth = (process.stdout.columns || 80) - 6;
+    const visualLines = getVisualLines(value, termWidth);
+    const newLineCount = Math.max(1, visualLines.length);
+    if (newLineCount !== visualLineCount) {
+      setVisualLineCount(newLineCount);
+    }
+  }, [value, visualLineCount]);
+  const currentDir = useMemo(() => {
+    const cwd = currentWorkingDirectory || process.cwd();
+    const sep = cwd.includes("/") ? "/" : "\\";
+    const parts = cwd.split(/[\\/]/).filter(Boolean);
+    const maxSegments = dimensions.columns >= 120 ? 3 : dimensions.columns >= 100 ? 2 : 1;
+    if (parts.length > maxSegments) {
+      return "..." + sep + parts.slice(-maxSegments).join(sep);
+    }
+    return cwd;
+  }, [currentWorkingDirectory, dimensions.columns]);
+  const currentEnvironment = useMemo(() => {
+    if (!subshellContext) return "local";
+    if (subshellContext.type === "ssh") {
+      const user = subshellContext.metadata?.username || "user";
+      const host = subshellContext.metadata?.hostname || "host";
+      return `ssh:${user}@${host}`;
+    }
+    if (subshellContext.type === "wsl") {
+      const distro = subshellContext.metadata?.distroName || "Ubuntu";
+      return `wsl:${distro}`;
+    }
+    if (subshellContext.type === "docker") {
+      const container = subshellContext.metadata?.containerId || "container";
+      return `docker:${container}`;
+    }
+    return "local";
+  }, [subshellContext]);
+  useEffect(() => {
+    if (!value || value.trim() === "") {
+      setAutocompleteSuggestion(null);
+      return;
+    }
+    const shouldSuggest = commandMode || isAutoMode && detectedIntent === "command";
+    if (shouldSuggest) {
+      const matches = CommandHistoryManager.getInstance().getMatches(value, currentDir, currentEnvironment);
+      if (matches.length > 0) {
+        setAutocompleteSuggestion(matches[0]);
+      } else {
+        setAutocompleteSuggestion(null);
+      }
+    } else {
+      setAutocompleteSuggestion(null);
+    }
+  }, [value, commandMode, isAutoMode, detectedIntent, aiAutoSuggestEnabled, currentDir, currentEnvironment]);
+  useEffect(() => {
+    setAiAutocompleteSuggestion(null);
+    if (aiAutocompleteDebounceRef.current) {
+      clearTimeout(aiAutocompleteDebounceRef.current);
+      aiAutocompleteDebounceRef.current = null;
+    }
+    if (aiAutocompleteAbortRef.current) {
+      aiAutocompleteAbortRef.current.abort();
+      aiAutocompleteAbortRef.current = null;
+    }
+    if (!aiAutoSuggestEnabled) {
+      return;
+    }
+    const shouldSuggest = commandMode || isAutoMode && detectedIntent === "command";
+    if (!shouldSuggest) {
+      return;
+    }
+    if (!value || value.trim().length < 2 || value.startsWith("/")) {
+      return;
+    }
+    aiAutocompleteDebounceRef.current = setTimeout(async () => {
+      setIsAiAutocompleteLoading(true);
+      const abortController = new AbortController();
+      aiAutocompleteAbortRef.current = abortController;
+      try {
+        if (!aiAutoSuggestEnabled) return;
+        const directoryHistory = CommandHistoryManager.getInstance().getDirectoryHistory(currentDir, currentEnvironment);
+        let files = [];
+        try {
+          if (subshellContext && subshellContext.type !== "local" && subshellContext.handler) {
             try {
-                if (!aiAutoSuggestEnabled)
-                    return; // double check inside timeout
-                // Get directory history using the correct method
-                const directoryHistory = CommandHistoryManager.getInstance().getDirectoryHistory(currentDir, currentEnvironment);
-                // Get files in current directory (local or remote)
-                let files = [];
-                try {
-                    if (subshellContext && subshellContext.type !== 'local' && subshellContext.handler) {
-                        // Remote/Subshell environment
-                        // Check if we can list files
-                        try {
-                            const dirEntries = await subshellContext.handler.listDirectory(currentDir);
-                            files = dirEntries
-                                .slice(0, 50)
-                                .map((e) => e.name + (e.type === 'directory' ? '/' : ''));
-                        }
-                        catch (remoteErr) {
-                            // quickLog('Remote list error: ' + remoteErr);
-                        }
-                    }
-                    else {
-                        // Local environment
-                        const dir = currentDir || process.cwd();
-                        if (fs.existsSync(dir)) {
-                            const entries = fs.readdirSync(dir, { withFileTypes: true });
-                            files = entries
-                                .slice(0, 50)
-                                .map(e => e.name + (e.isDirectory() ? '/' : ''));
-                        }
-                    }
-                }
-                catch (e) {
-                    // Ignore file access errors
-                }
-                // Determine OS and Platform from subshell context if available
-                let osContext = process.platform;
-                let platformContext = process.platform;
-                if (subshellContext && subshellContext.type !== 'local' && subshellContext.metadata) {
-                    const metaOs = subshellContext.metadata.os;
-                    if (metaOs === 'windows') {
-                        osContext = 'win32';
-                        platformContext = 'win32';
-                    }
-                    else if (metaOs === 'macos') {
-                        osContext = 'darwin';
-                        platformContext = 'darwin';
-                    }
-                    else if (metaOs === 'linux') {
-                        osContext = 'linux';
-                        platformContext = 'linux';
-                    }
-                }
-                const context = {
-                    os: osContext,
-                    platform: platformContext,
-                    cwd: currentDir || process.cwd(),
-                    directoryHistory: directoryHistory.slice(0, 10),
-                    sessionCommands: sessionCommands.slice(-10),
-                    files: files,
-                    currentInput: value
-                };
-                const prediction = await AIAutocompleteAgent.predictCommand(context, abortController.signal);
-                if (prediction && !abortController.signal.aborted) {
-                    setAiAutocompleteSuggestion(prediction);
-                }
-            }
-            catch (error) {
-                // Ignore errors (likely aborted)
-            }
-            finally {
-                setIsAiAutocompleteLoading(false);
-                if (aiAutocompleteAbortRef.current === abortController) {
-                    aiAutocompleteAbortRef.current = null;
-                }
-            }
-        }, AI_AUTOCOMPLETE_DEBOUNCE_MS);
-        return () => {
-            if (aiAutocompleteDebounceRef.current) {
-                clearTimeout(aiAutocompleteDebounceRef.current);
+              const dirEntries = await subshellContext.handler.listDirectory(currentDir);
+              files = dirEntries.slice(0, 50).map((e) => e.name + (e.type === "directory" ? "/" : ""));
+            } catch (remoteErr) {
             }
-            if (aiAutocompleteAbortRef.current) {
-                aiAutocompleteAbortRef.current.abort();
+          } else {
+            const dir = currentDir || process.cwd();
+            if (fs.existsSync(dir)) {
+              const entries = fs.readdirSync(dir, { withFileTypes: true });
+              files = entries.slice(0, 50).map((e) => e.name + (e.isDirectory() ? "/" : ""));
             }
-        };
-    }, [value, commandMode, isAutoMode, detectedIntent, aiAutoSuggestEnabled, currentDir, currentEnvironment, sessionCommands]);
-    // Auto-classification effect (Synchronous Heuristics Only)
-    useEffect(() => {
-        // Only run classification if in Auto Mode
-        if (!isAutoMode) {
-            return;
+          }
+        } catch (e) {
         }
-        // Only classify if value is non-empty and not just whitespace
-        const trimmedValue = value.trim();
-        if (!trimmedValue || !onToggleCommandMode) {
-            // Default to AI if empty
-            setDetectedIntent('ai');
-            if (commandMode)
-                onToggleCommandMode();
-            return;
+        let osContext = process.platform;
+        let platformContext = process.platform;
+        if (subshellContext && subshellContext.type !== "local" && subshellContext.metadata) {
+          const metaOs = subshellContext.metadata.os;
+          if (metaOs === "windows") {
+            osContext = "win32";
+            platformContext = "win32";
+          } else if (metaOs === "macos") {
+            osContext = "darwin";
+            platformContext = "darwin";
+          } else if (metaOs === "linux") {
+            osContext = "linux";
+            platformContext = "linux";
+          }
         }
-        // Run local heuristic detection immediately
-        const intent = detectIntent(trimmedValue);
-        setDetectedIntent(intent);
-        // Switch mode based on intent
-        if (intent === 'command') {
-            if (!commandMode)
-                onToggleCommandMode();
+        const context = {
+          os: osContext,
+          platform: platformContext,
+          cwd: currentDir || process.cwd(),
+          directoryHistory: directoryHistory.slice(0, 10),
+          sessionCommands: sessionCommands.slice(-10),
+          files,
+          currentInput: value
+        };
+        const prediction = await AIAutocompleteAgent.predictCommand(context, abortController.signal);
+        if (prediction && !abortController.signal.aborted) {
+          setAiAutocompleteSuggestion(prediction);
         }
-        else {
-            // intent === 'ai'
-            if (commandMode)
-                onToggleCommandMode();
+      } catch (error) {
+      } finally {
+        setIsAiAutocompleteLoading(false);
+        if (aiAutocompleteAbortRef.current === abortController) {
+          aiAutocompleteAbortRef.current = null;
         }
-    }, [value, commandMode, onToggleCommandMode, isAutoMode]);
-    // Helper function to get files matching a query from the current directory
-    const getMatchingFiles = (query) => {
+      }
+    }, AI_AUTOCOMPLETE_DEBOUNCE_MS);
+    return () => {
+      if (aiAutocompleteDebounceRef.current) {
+        clearTimeout(aiAutocompleteDebounceRef.current);
+      }
+      if (aiAutocompleteAbortRef.current) {
+        aiAutocompleteAbortRef.current.abort();
+      }
+    };
+  }, [value, commandMode, isAutoMode, detectedIntent, aiAutoSuggestEnabled, currentDir, currentEnvironment, sessionCommands]);
+  useEffect(() => {
+    if (!isAutoMode) {
+      return;
+    }
+    const trimmedValue = value.trim();
+    if (!trimmedValue || !onToggleCommandMode) {
+      setDetectedIntent("ai");
+      if (commandMode) onToggleCommandMode();
+      return;
+    }
+    const intent = detectIntent(trimmedValue);
+    setDetectedIntent(intent);
+    if (intent === "command") {
+      if (!commandMode) onToggleCommandMode();
+    } else {
+      if (commandMode) onToggleCommandMode();
+    }
+  }, [value, commandMode, onToggleCommandMode, isAutoMode]);
+  const showSlashAutocomplete = React.useCallback((commands) => {
+    if (commands.length > 0) {
+      setSlashAutocompleteCommands(commands);
+      setSlashAutocompleteVisible(true);
+      setSlashAutocompleteSelectedIndex(0);
+      setSlashAutocompleteScrollOffset(0);
+    } else {
+      setSlashAutocompleteVisible(false);
+    }
+  }, []);
+  const getRuleNameAutocompleteEntries = React.useCallback((partialName) => {
+    const normalized = partialName.toLowerCase();
+    const rules = rulesStorage.list();
+    if (rules.length === 0) {
+      return [{
+        name: "(no rules)",
+        description: "Create one with /rules add"
+      }];
+    }
+    const matches = rules.filter((rule) => rule.name.toLowerCase().includes(normalized)).slice(0, 10).map((rule) => ({
+      name: rule.name,
+      description: rule.preview || "Saved rule"
+    }));
+    if (matches.length === 0) {
+      return [{
+        name: "(no matches)",
+        description: "No saved rules match that name"
+      }];
+    }
+    return matches;
+  }, []);
+  const updateSlashAutocomplete = React.useCallback((nextValue) => {
+    if (!nextValue.startsWith("/")) {
+      setSlashAutocompleteVisible(false);
+      return;
+    }
+    if (!nextValue.includes(" ")) {
+      showSlashAutocomplete(filterCommands(nextValue.slice(1)));
+      return;
+    }
+    if (nextValue.startsWith("/mcp ")) {
+      showSlashAutocomplete(filterCommands(nextValue.slice(1)));
+      return;
+    }
+    if (nextValue.startsWith("/chat ")) {
+      showSlashAutocomplete(filterCommands(nextValue.slice(1)));
+      return;
+    }
+    if (nextValue.startsWith("/add-command ") || nextValue.startsWith("/add-command-auto-detect ")) {
+      showSlashAutocomplete(filterCommands(nextValue.slice(1)));
+      return;
+    }
+    if (nextValue.startsWith("/background-task ") || nextValue.startsWith("/bkg ") || nextValue.startsWith("/bg-task ")) {
+      showSlashAutocomplete(filterCommands(nextValue.slice(1)));
+      return;
+    }
+    if (nextValue.startsWith("/sync ")) {
+      showSlashAutocomplete(filterCommands(nextValue.slice(1)));
+      return;
+    }
+    if (nextValue.startsWith("/models ") || nextValue.startsWith("/model ")) {
+      showSlashAutocomplete(filterCommands(nextValue.slice(1)));
+      return;
+    }
+    if (nextValue.startsWith("/settings auto-suggest ")) {
+      showSlashAutocomplete(filterCommands(nextValue.slice(1)));
+      return;
+    }
+    if (nextValue.startsWith("/settings ")) {
+      showSlashAutocomplete(filterCommands(nextValue.slice(1)));
+      return;
+    }
+    if (nextValue.startsWith("/revert ")) {
+      const partialId = nextValue.slice(8).toLowerCase();
+      const checkpoints = getCheckpoints ? getCheckpoints() : [];
+      if (checkpoints.length === 0) {
+        showSlashAutocomplete([{
+          name: "(no checkpoints)",
+          description: "Ask AI a question first to create a checkpoint"
+        }]);
+        return;
+      }
+      const checkpointCommands = checkpoints.filter((cp) => cp.id.toLowerCase().includes(partialId) || cp.prompt.toLowerCase().includes(partialId)).slice(0, 10).map((cp) => ({
+        name: cp.id,
+        description: cp.prompt.length > 50 ? cp.prompt.slice(0, 50) + "..." : cp.prompt
+      }));
+      showSlashAutocomplete(checkpointCommands);
+      return;
+    }
+    if (nextValue.match(/^\/rules\s+(edit|delete)\s+/)) {
+      const match = nextValue.match(/^\/rules\s+(?:edit|delete)\s+(.*)$/);
+      const partialName = match ? match[1] : "";
+      showSlashAutocomplete(getRuleNameAutocompleteEntries(partialName));
+      return;
+    }
+    if (nextValue.startsWith("/rules ")) {
+      showSlashAutocomplete(filterCommands(nextValue.slice(1)));
+      return;
+    }
+    if (nextValue.match(/^\/workflow\s+(run|view|delete)\s+/) || nextValue.match(/^\/wf\s+(run|view|delete)\s+/)) {
+      const match = nextValue.match(/^\/(?:workflow|wf)\s+(?:run|view|delete)\s+(.*)$/);
+      const partialName = match ? match[1].toLowerCase() : "";
+      const workflows = workflowStorage.list();
+      const matchingWorkflows = workflows.filter((wf) => wf.name.toLowerCase().includes(partialName)).slice(0, 10).map((wf) => ({
+        name: wf.name,
+        description: wf.description || `${wf.stepCount} step${wf.stepCount !== 1 ? "s" : ""}`
+      }));
+      showSlashAutocomplete(matchingWorkflows);
+      return;
+    }
+    if (nextValue.match(/^\/workflow\s+new\s+/) || nextValue.match(/^\/wf\s+new\s+/)) {
+      showSlashAutocomplete(filterCommands(nextValue.slice(1)));
+      return;
+    }
+    if (nextValue.startsWith("/workflow ") || nextValue.startsWith("/wf ")) {
+      showSlashAutocomplete(filterCommands(nextValue.slice(1)));
+      return;
+    }
+    setSlashAutocompleteVisible(false);
+  }, [getCheckpoints, getRuleNameAutocompleteEntries, showSlashAutocomplete]);
+  const getMatchingFiles = React.useCallback((query) => {
+    try {
+      const cwd = currentWorkingDirectory || process.cwd();
+      if (!fs.existsSync(cwd)) return [];
+      const lowerQuery = query.toLowerCase();
+      const results = [];
+      const SKIP_DIRS = /* @__PURE__ */ new Set([
+        ".git",
+        "node_modules",
+        "dist",
+        "build",
+        ".next",
+        "__pycache__",
+        ".cache",
+        "coverage",
+        ".nyc_output",
+        ".turbo",
+        "out",
+        ".svelte-kit"
+      ]);
+      if (lowerQuery === "") {
+        let entries;
         try {
-            const cwd = currentWorkingDirectory || process.cwd();
-            if (!fs.existsSync(cwd))
-                return [];
-            const entries = fs.readdirSync(cwd, { withFileTypes: true });
-            const lowerQuery = query.toLowerCase();
-            return entries
-                .filter(entry => {
-                // Exclude hidden files (starting with .)
-                if (entry.name.startsWith('.'))
-                    return false;
-                // Match case-insensitive
-                return entry.name.toLowerCase().includes(lowerQuery);
-            })
-                .map(entry => ({
-                name: entry.name,
-                isDirectory: entry.isDirectory()
-            }))
-                .sort((a, b) => {
-                // Prioritize files that start with the query
-                const aStarts = a.name.toLowerCase().startsWith(lowerQuery);
-                const bStarts = b.name.toLowerCase().startsWith(lowerQuery);
-                if (aStarts && !bStarts)
-                    return -1;
-                if (!aStarts && bStarts)
-                    return 1;
-                return a.name.localeCompare(b.name);
-            })
-                .slice(0, 10); // Get more than 6 initially, UI will limit display
+          entries = fs.readdirSync(cwd, { withFileTypes: true });
+        } catch {
+          return [];
         }
-        catch (error) {
-            return [];
+        for (const entry of entries) {
+          if (entry.name.startsWith(".")) continue;
+          results.push({
+            name: entry.name,
+            insertText: entry.isDirectory() ? `${entry.name}/` : entry.name,
+            kind: entry.isDirectory() ? "directory" : "file"
+          });
         }
-    };
-    // File tag (@) detection effect
-    useEffect(() => {
-        // Don't show file tag autocomplete in command mode
-        if (commandMode) {
-            setFileTagAutocompleteVisible(false);
-            return;
+        results.sort((a, b) => a.name.localeCompare(b.name));
+        return results.slice(0, 15);
+      }
+      const walk = (dir, relativePath, depth) => {
+        if (depth > 6 || results.length >= 60) return;
+        let entries;
+        try {
+          entries = fs.readdirSync(dir, { withFileTypes: true });
+        } catch {
+          return;
         }
-        // Find if cursor is within a potential file tag
-        // Look backwards from cursor to find @
-        let atPosition = -1;
-        for (let i = cursorOffset - 1; i >= 0; i--) {
-            const char = value[i];
-            // Stop if we hit whitespace or another special char
-            if (/[\s\n]/.test(char))
-                break;
-            if (char === '@') {
-                atPosition = i;
-                break;
+        for (const entry of entries) {
+          if (entry.name.startsWith(".")) continue;
+          const entryRelPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+          const lowerRelPath = entryRelPath.toLowerCase();
+          const lowerBasename = entry.name.toLowerCase();
+          if (entry.isDirectory()) {
+            if (SKIP_DIRS.has(entry.name)) continue;
+            if (lowerRelPath.includes(lowerQuery) || lowerBasename.includes(lowerQuery)) {
+              results.push({
+                name: entryRelPath,
+                insertText: `${entryRelPath}/`,
+                kind: "directory"
+              });
+            }
+            walk(path.join(dir, entry.name), entryRelPath, depth + 1);
+          } else {
+            if (lowerRelPath.includes(lowerQuery) || lowerBasename.includes(lowerQuery)) {
+              results.push({
+                name: entryRelPath,
+                insertText: entryRelPath,
+                kind: "file"
+              });
             }
+          }
         }
-        // Only treat @ as file tag if it's at start of input OR preceded by whitespace
-        // This prevents triggering on things like "rohan@localhost" or "email@domain.com"
-        if (atPosition === -1 || (atPosition > 0 && !/[\s\n]/.test(value[atPosition - 1]))) {
-            setFileTagAutocompleteVisible(false);
-            setActiveFileTagStart(null);
-            return;
+      };
+      walk(cwd, "", 0);
+      results.sort((a, b) => {
+        const aBasename = a.name.split("/").pop().toLowerCase();
+        const bBasename = b.name.split("/").pop().toLowerCase();
+        const aStartsBasename = aBasename.startsWith(lowerQuery);
+        const bStartsBasename = bBasename.startsWith(lowerQuery);
+        const aStartsFull = a.name.toLowerCase().startsWith(lowerQuery);
+        const bStartsFull = b.name.toLowerCase().startsWith(lowerQuery);
+        if ((aStartsFull || aStartsBasename) && !(bStartsFull || bStartsBasename)) return -1;
+        if (!(aStartsFull || aStartsBasename) && (bStartsFull || bStartsBasename)) return 1;
+        const aDepth = a.name.split("/").length;
+        const bDepth = b.name.split("/").length;
+        if (aDepth !== bDepth) return aDepth - bDepth;
+        return a.name.localeCompare(b.name);
+      });
+      return results.slice(0, 15);
+    } catch (error) {
+      return [];
+    }
+  }, [currentWorkingDirectory]);
+  const getMatchingMentionSuggestions = React.useCallback((query) => {
+    const normalized = query.toLowerCase();
+    if (normalized.startsWith("rules:")) {
+      const ruleQuery = query.slice("rules:".length).toLowerCase();
+      return rulesStorage.list().filter((rule) => rule.name.toLowerCase().includes(ruleQuery)).slice(0, 10).map((rule) => ({
+        name: `rules:${rule.name}`,
+        insertText: `rules:${rule.name}`,
+        kind: "rule",
+        description: rule.preview || "Saved rule"
+      }));
+    }
+    const suggestions = [];
+    if ("rules:".startsWith(normalized) || normalized.startsWith("rules")) {
+      suggestions.push({
+        name: "rules:",
+        insertText: "rules:",
+        kind: "rule-namespace",
+        description: "Insert a saved reusable rule"
+      });
+    }
+    return [...suggestions, ...getMatchingFiles(query)].slice(0, 15);
+  }, [getMatchingFiles]);
+  useEffect(() => {
+    if (commandMode) {
+      setFileTagAutocompleteVisible(false);
+      return;
+    }
+    let atPosition = -1;
+    for (let i = cursorOffset - 1; i >= 0; i--) {
+      const char = value[i];
+      if (/[\s\n]/.test(char)) break;
+      if (char === "@") {
+        atPosition = i;
+        break;
+      }
+    }
+    if (atPosition === -1 || atPosition > 0 && !/[\s\n]/.test(value[atPosition - 1])) {
+      setFileTagAutocompleteVisible(false);
+      setActiveFileTagStart(null);
+      return;
+    }
+    const query = value.slice(atPosition + 1, cursorOffset);
+    const matches = getMatchingMentionSuggestions(query);
+    if (matches.length > 0) {
+      setFileTagSuggestions(matches);
+      setFileTagAutocompleteVisible(true);
+      setActiveFileTagStart(atPosition);
+      setFileTagSelectedIndex(0);
+    } else {
+      setFileTagAutocompleteVisible(false);
+      setActiveFileTagStart(null);
+    }
+  }, [value, cursorOffset, commandMode, currentWorkingDirectory, getMatchingMentionSuggestions]);
+  const pushToUndoStack = () => {
+    setUndoStack((prev) => [...prev, { value, cursorOffset }]);
+    setRedoStack([]);
+  };
+  const handleUndo = () => {
+    if (undoStack.length === 0) return;
+    const previousState = undoStack[undoStack.length - 1];
+    setRedoStack((prev) => [...prev, { value, cursorOffset }]);
+    setUndoStack((prev) => prev.slice(0, -1));
+    setValue(previousState.value);
+    setCursorOffset(previousState.cursorOffset);
+    setSelection(null);
+  };
+  const applyMentionSuggestion = (selected, viaTab) => {
+    if (activeFileTagStart === null) {
+      return;
+    }
+    pushToUndoStack();
+    const beforeTag = value.slice(0, activeFileTagStart);
+    const afterCursor = value.slice(cursorOffset);
+    const baseValue = beforeTag + "@" + selected.insertText;
+    if (selected.kind === "rule-namespace") {
+      const newValue2 = baseValue + afterCursor;
+      const newCursorPos2 = activeFileTagStart + 1 + selected.insertText.length;
+      setValue(newValue2);
+      setCursorOffset(newCursorPos2);
+      return;
+    }
+    if (viaTab && selected.kind === "directory") {
+      const newValue2 = baseValue + afterCursor;
+      const newCursorPos2 = activeFileTagStart + 1 + selected.insertText.length;
+      setValue(newValue2);
+      setCursorOffset(newCursorPos2);
+      return;
+    }
+    const trailingSuffix = viaTab ? "" : " ";
+    const newValue = baseValue + trailingSuffix + afterCursor;
+    const newCursorPos = activeFileTagStart + 1 + selected.insertText.length + trailingSuffix.length;
+    setValue(newValue);
+    setCursorOffset(newCursorPos);
+    setConfirmedFileTags((prev) => [
+      ...prev.filter(
+        (tag) => !(tag.start >= activeFileTagStart && tag.start <= cursorOffset)
+      ),
+      {
+        start: activeFileTagStart,
+        end: activeFileTagStart + 1 + selected.insertText.length,
+        fileName: selected.name
+      }
+    ]);
+    setFileTagAutocompleteVisible(false);
+    setActiveFileTagStart(null);
+  };
+  useInput((input, key) => {
+    if (!isActive) return;
+    const isWindows = process.platform === "win32";
+    const inputCharCode = input ? input.charCodeAt(0) : null;
+    const normalizedInput = input ? input.toLowerCase() : "";
+    const isTerminalShiftEnterSequence = input === "\x1B\r" || input === "\x1B\n" || normalizedInput === "\x1B[13;2u" || normalizedInput === "\x1B[13;2~" || normalizedInput === "\x1B[27;2;13~";
+    const isEnterEvent = key.return || isTerminalShiftEnterSequence;
+    const isMacOptionWordBackwardSequence = isMac && (normalizedInput === "\x1Bb" || normalizedInput === "\x1B[1;3d" || normalizedInput === "\x1B[1;9d" || key.meta && normalizedInput === "b" || key.escape && key.leftArrow);
+    const isMacOptionWordForwardSequence = isMac && (normalizedInput === "\x1Bf" || normalizedInput === "\x1B[1;3c" || normalizedInput === "\x1B[1;9c" || key.meta && normalizedInput === "f" || key.escape && key.rightArrow);
+    if (slashAutocompleteVisible) {
+      if (key.downArrow) {
+        const newIndex = Math.min(slashAutocompleteSelectedIndex + 1, slashAutocompleteCommands.length - 1);
+        setSlashAutocompleteSelectedIndex(newIndex);
+        if (newIndex >= slashAutocompleteScrollOffset + slashMaxVisibleItems) {
+          setSlashAutocompleteScrollOffset(newIndex - slashMaxVisibleItems + 1);
         }
-        // Extract the query after @
-        const query = value.slice(atPosition + 1, cursorOffset);
-        // Get matching files
-        const matches = getMatchingFiles(query);
-        if (matches.length > 0) {
-            setFileTagSuggestions(matches);
-            setFileTagAutocompleteVisible(true);
-            setActiveFileTagStart(atPosition);
-            setFileTagSelectedIndex(0);
+        return;
+      }
+      if (key.upArrow) {
+        const newIndex = Math.max(slashAutocompleteSelectedIndex - 1, 0);
+        setSlashAutocompleteSelectedIndex(newIndex);
+        if (newIndex < slashAutocompleteScrollOffset) {
+          setSlashAutocompleteScrollOffset(newIndex);
         }
-        else {
-            setFileTagAutocompleteVisible(false);
-            setActiveFileTagStart(null);
+        return;
+      }
+      if (key.return && input.length <= 1 && !key.shift && !key.ctrl && !key.meta) {
+        const selected = slashAutocompleteCommands[slashAutocompleteSelectedIndex];
+        if (!selected || selected.name.startsWith("(no ")) {
+          setSlashAutocompleteVisible(false);
+          return;
         }
-    }, [value, cursorOffset, commandMode, currentWorkingDirectory]);
-    const pushToUndoStack = () => {
-        setUndoStack(prev => [...prev, { value, cursorOffset }]);
-        setRedoStack([]); // Clear redo stack on new action
-    };
-    const handleUndo = () => {
-        if (undoStack.length === 0)
-            return;
-        const previousState = undoStack[undoStack.length - 1];
-        setRedoStack(prev => [...prev, { value, cursorOffset }]);
-        setUndoStack(prev => prev.slice(0, -1));
-        setValue(previousState.value);
-        setCursorOffset(previousState.cursorOffset);
-        setSelection(null);
-    };
-    useInput((input, key) => {
-        if (!isActive)
-            return;
-        // Detect OS for platform-specific key handling
-        const isWindows = process.platform === 'win32';
-        const inputCharCode = input ? input.charCodeAt(0) : null;
-        // Handle slash command autocomplete navigation
-        if (slashAutocompleteVisible) {
-            if (key.downArrow) {
-                const newIndex = Math.min(slashAutocompleteSelectedIndex + 1, slashAutocompleteCommands.length - 1);
-                setSlashAutocompleteSelectedIndex(newIndex);
-                // Scroll down if selected is below visible window
-                if (newIndex >= slashAutocompleteScrollOffset + slashMaxVisibleItems) {
-                    setSlashAutocompleteScrollOffset(newIndex - slashMaxVisibleItems + 1);
-                }
-                return;
-            }
-            if (key.upArrow) {
-                const newIndex = Math.max(slashAutocompleteSelectedIndex - 1, 0);
-                setSlashAutocompleteSelectedIndex(newIndex);
-                // Scroll up if selected is above visible window
-                if (newIndex < slashAutocompleteScrollOffset) {
-                    setSlashAutocompleteScrollOffset(newIndex);
-                }
-                return;
-            }
-            if (key.return && input.length <= 1 && !key.shift && !key.ctrl) {
-                // Select the highlighted command
-                const selected = slashAutocompleteCommands[slashAutocompleteSelectedIndex];
-                // Check if we're in MCP subcommand mode
-                if (value.startsWith('/mcp ')) {
-                    // We're selecting an MCP subcommand, keep "/mcp " and append the subcommand
-                    const newValue = `/mcp ${selected.name} `;
-                    setValue(newValue);
-                    setCursorOffset(newValue.length);
-                    setSlashAutocompleteVisible(false);
-                }
-                else if (value.startsWith('/chat ')) {
-                    // We're selecting a chat subcommand, keep "/chat " and append the subcommand
-                    const newValue = `/chat ${selected.name} `;
-                    setValue(newValue);
-                    setCursorOffset(newValue.length);
-                    setSlashAutocompleteVisible(false);
-                }
-                else if (value.startsWith('/add-command ') || value.startsWith('/add-command-auto-detect ')) {
-                    // We're selecting an add-command subcommand
-                    const prefix = value.startsWith('/add-command-auto-detect ') ? '/add-command-auto-detect ' : '/add-command ';
-                    const newValue = `${prefix}${selected.name} `;
-                    setValue(newValue);
-                    setCursorOffset(newValue.length);
-                    setSlashAutocompleteVisible(false);
-                }
-                else if (value.startsWith('/background-task ') || value.startsWith('/bkg ') || value.startsWith('/bg-task ')) {
-                    // We're selecting a background-task subcommand
-                    const prefix = value.startsWith('/bkg ') ? '/bkg ' : (value.startsWith('/bg-task ') ? '/bg-task ' : '/background-task ');
-                    const newValue = `${prefix}${selected.name} `;
-                    setValue(newValue);
-                    setCursorOffset(newValue.length);
-                    setSlashAutocompleteVisible(false);
-                }
-                else if (value.startsWith('/sync ')) {
-                    // We're selecting a sync subcommand
-                    const newValue = `/sync ${selected.name} `;
-                    setValue(newValue);
-                    setCursorOffset(newValue.length);
-                    setSlashAutocompleteVisible(false);
-                }
-                else if (value.startsWith('/revert ')) {
-                    // We're selecting a checkpoint from /revert dropdown
-                    const newValue = `/revert ${selected.name}`;
-                    setValue(newValue);
-                    setCursorOffset(newValue.length);
-                    setSlashAutocompleteVisible(false);
-                }
-                else if (value.startsWith('/models ') || value.startsWith('/model ')) {
-                    // We're selecting a models subcommand
-                    const prefix = value.startsWith('/models ') ? '/models ' : '/model ';
-                    const newValue = `${prefix}${selected.name}`;
-                    setValue(newValue);
-                    setCursorOffset(newValue.length);
-                    setSlashAutocompleteVisible(false);
-                }
-                else if (value.startsWith('/workflow new ') || value.startsWith('/wf new ')) {
-                    // We're in workflow new subcommand mode (manual or learn-workflow)
-                    const prefix = value.startsWith('/workflow new ') ? '/workflow new ' : '/wf new ';
-                    const newValue = `${prefix}${selected.name}`;
-                    setValue(newValue);
-                    setCursorOffset(newValue.length);
-                    setSlashAutocompleteVisible(false);
-                }
-                else if (value.startsWith('/workflow ') || value.startsWith('/wf ')) {
-                    // Check if we're in workflow name selection mode (after run/view/delete)
-                    const workflowNameMatch = value.match(/^\/(?:workflow|wf)\s+(run|view|delete)\s+/);
-                    if (workflowNameMatch) {
-                        // We're selecting a workflow name
-                        const prefix = value.match(/^\/(?:workflow|wf)\s+(?:run|view|delete)\s+/)?.[0] || '';
-                        const newValue = `${prefix}${selected.name}`;
-                        setValue(newValue);
-                        setCursorOffset(newValue.length);
-                        setSlashAutocompleteVisible(false);
-                    }
-                    else {
-                        // We're selecting a workflow subcommand
-                        const prefix = value.startsWith('/workflow ') ? '/workflow ' : '/wf ';
-                        const newValue = `${prefix}${selected.name} `;
-                        setValue(newValue);
-                        setCursorOffset(newValue.length);
-                        // For run/view/delete, show workflow names immediately
-                        if (selected.name === 'run' || selected.name === 'view' || selected.name === 'delete') {
-                            const workflows = workflowStorage.list();
-                            const matchingWorkflows = workflows
-                                .slice(0, 10)
-                                .map(wf => ({
-                                name: wf.name,
-                                description: wf.description || `${wf.stepCount} step${wf.stepCount !== 1 ? 's' : ''}`
-                            }));
-                            if (matchingWorkflows.length > 0) {
-                                setSlashAutocompleteCommands(matchingWorkflows);
-                                setSlashAutocompleteSelectedIndex(0);
-                                setSlashAutocompleteScrollOffset(0);
-                                // Keep autocomplete visible
-                            }
-                            else {
-                                setSlashAutocompleteVisible(false);
-                            }
-                        }
-                        else if (selected.name === 'new') {
-                            // For 'new' subcommand, show manual/learn-workflow options
-                            const subcommandMatches = filterCommands('workflow new ');
-                            if (subcommandMatches.length > 0) {
-                                setSlashAutocompleteCommands(subcommandMatches);
-                                setSlashAutocompleteSelectedIndex(0);
-                                setSlashAutocompleteScrollOffset(0);
-                                // Keep autocomplete visible for next level
-                            }
-                            else {
-                                setSlashAutocompleteVisible(false);
-                            }
-                        }
-                        else {
-                            setSlashAutocompleteVisible(false);
-                        }
-                    }
-                }
-                else if (value.startsWith('/settings auto-suggest ')) {
-                    // We're selecting an auto-suggest option (on/off)
-                    const newValue = `/settings auto-suggest ${selected.name}`;
-                    setValue(newValue);
-                    setCursorOffset(newValue.length);
-                    setSlashAutocompleteVisible(false);
-                }
-                else if (value.startsWith('/settings ')) {
-                    // We're selecting a settings subcommand (e.g., auto-suggest)
-                    const newValue = `/settings ${selected.name} `;
-                    setValue(newValue);
-                    setCursorOffset(newValue.length);
-                    // Show the next level options (on/off for auto-suggest)
-                    if (selected.name === 'auto-suggest') {
-                        const optionMatches = filterCommands('settings auto-suggest ');
-                        if (optionMatches.length > 0) {
-                            setSlashAutocompleteCommands(optionMatches);
-                            setSlashAutocompleteSelectedIndex(0);
-                            setSlashAutocompleteScrollOffset(0);
-                        }
-                        else {
-                            setSlashAutocompleteVisible(false);
-                        }
-                    }
-                    else {
-                        setSlashAutocompleteVisible(false);
-                    }
-                }
-                else {
-                    // Regular slash command, replace everything
-                    const newValue = `/${selected.name} `;
-                    setValue(newValue);
-                    setCursorOffset(newValue.length);
-                    // Check if this command has subcommands (e.g., /mcp, /chat, /add-command)
-                    // If so, immediately show the subcommand list
-                    if (selected.name === 'mcp') {
-                        const subcommandMatches = filterCommands('mcp ');
-                        if (subcommandMatches.length > 0) {
-                            setSlashAutocompleteCommands(subcommandMatches);
-                            setSlashAutocompleteSelectedIndex(0);
-                            setSlashAutocompleteScrollOffset(0);
-                            // Keep autocomplete visible for subcommands
-                        }
-                        else {
-                            setSlashAutocompleteVisible(false);
-                        }
-                    }
-                    else if (selected.name === 'chat') {
-                        const subcommandMatches = filterCommands('chat ');
-                        if (subcommandMatches.length > 0) {
-                            setSlashAutocompleteCommands(subcommandMatches);
-                            setSlashAutocompleteSelectedIndex(0);
-                            setSlashAutocompleteScrollOffset(0);
-                            // Keep autocomplete visible for subcommands
-                        }
-                        else {
-                            setSlashAutocompleteVisible(false);
-                        }
-                    }
-                    else if (selected.name === 'add-command' || selected.name === 'add-command-auto-detect') {
-                        const subcommandMatches = filterCommands('add-command ');
-                        if (subcommandMatches.length > 0) {
-                            setSlashAutocompleteCommands(subcommandMatches);
-                            setSlashAutocompleteSelectedIndex(0);
-                            setSlashAutocompleteScrollOffset(0);
-                            // Keep autocomplete visible for subcommands
-                        }
-                        else {
-                            setSlashAutocompleteVisible(false);
-                        }
-                    }
-                    else if (selected.name === 'background-task' || selected.name === 'bkg' || selected.name === 'bg-task') {
-                        const subcommandMatches = filterCommands('background-task ');
-                        if (subcommandMatches.length > 0) {
-                            setSlashAutocompleteCommands(subcommandMatches);
-                            setSlashAutocompleteSelectedIndex(0);
-                            setSlashAutocompleteScrollOffset(0);
-                            // Keep autocomplete visible for subcommands
-                        }
-                        else {
-                            setSlashAutocompleteVisible(false);
-                        }
-                    }
-                    else if (selected.name === 'sync') {
-                        const subcommandMatches = filterCommands('sync ');
-                        if (subcommandMatches.length > 0) {
-                            setSlashAutocompleteCommands(subcommandMatches);
-                            setSlashAutocompleteSelectedIndex(0);
-                            setSlashAutocompleteScrollOffset(0);
-                            // Keep autocomplete visible for subcommands
-                        }
-                        else {
-                            setSlashAutocompleteVisible(false);
-                        }
-                    }
-                    else if (selected.name === 'models' || selected.name === 'model') {
-                        const subcommandMatches = filterCommands('models ');
-                        if (subcommandMatches.length > 0) {
-                            setSlashAutocompleteCommands(subcommandMatches);
-                            setSlashAutocompleteSelectedIndex(0);
-                            setSlashAutocompleteScrollOffset(0);
-                            // Keep autocomplete visible for subcommands
-                        }
-                        else {
-                            setSlashAutocompleteVisible(false);
-                        }
-                    }
-                    else if (selected.name === 'settings') {
-                        const subcommandMatches = filterCommands('settings ');
-                        if (subcommandMatches.length > 0) {
-                            setSlashAutocompleteCommands(subcommandMatches);
-                            setSlashAutocompleteSelectedIndex(0);
-                            setSlashAutocompleteScrollOffset(0);
-                            // Keep autocomplete visible for subcommands
-                        }
-                        else {
-                            setSlashAutocompleteVisible(false);
-                        }
-                    }
-                    else if (selected.name === 'workflow' || selected.name === 'wf') {
-                        const subcommandMatches = filterCommands('workflow ');
-                        if (subcommandMatches.length > 0) {
-                            setSlashAutocompleteCommands(subcommandMatches);
-                            setSlashAutocompleteSelectedIndex(0);
-                            setSlashAutocompleteScrollOffset(0);
-                            // Keep autocomplete visible for subcommands
-                        }
-                        else {
-                            setSlashAutocompleteVisible(false);
-                        }
-                    }
-                    else if (selected.name === 'revert') {
-                        // For revert, show checkpoints immediately
-                        const checkpoints = getCheckpoints ? getCheckpoints() : [];
-                        if (checkpoints.length === 0) {
-                            setSlashAutocompleteCommands([{
-                                    name: '(no checkpoints)',
-                                    description: 'Ask AI a question first to create a checkpoint'
-                                }]);
-                            setSlashAutocompleteSelectedIndex(0);
-                            setSlashAutocompleteScrollOffset(0);
-                            // Keep autocomplete visible
-                        }
-                        else {
-                            const checkpointCommands = checkpoints
-                                .slice(0, 10)
-                                .map(cp => {
-                                const truncatedPrompt = cp.prompt.length > 50 ? cp.prompt.slice(0, 50) + '...' : cp.prompt;
-                                return {
-                                    name: cp.id,
-                                    description: truncatedPrompt
-                                };
-                            });
-                            setSlashAutocompleteCommands(checkpointCommands);
-                            setSlashAutocompleteSelectedIndex(0);
-                            setSlashAutocompleteScrollOffset(0);
-                            // Keep autocomplete visible
-                        }
-                    }
-                    else {
-                        setSlashAutocompleteVisible(false);
-                    }
-                }
-                return;
-            }
-            if (key.escape) {
+        if (value.startsWith("/mcp ")) {
+          const newValue = `/mcp ${selected.name} `;
+          setValue(newValue);
+          setCursorOffset(newValue.length);
+          setSlashAutocompleteVisible(false);
+        } else if (value.startsWith("/chat ")) {
+          const newValue = `/chat ${selected.name} `;
+          setValue(newValue);
+          setCursorOffset(newValue.length);
+          setSlashAutocompleteVisible(false);
+        } else if (value.startsWith("/add-command ") || value.startsWith("/add-command-auto-detect ")) {
+          const prefix = value.startsWith("/add-command-auto-detect ") ? "/add-command-auto-detect " : "/add-command ";
+          const newValue = `${prefix}${selected.name} `;
+          setValue(newValue);
+          setCursorOffset(newValue.length);
+          setSlashAutocompleteVisible(false);
+        } else if (value.startsWith("/background-task ") || value.startsWith("/bkg ") || value.startsWith("/bg-task ")) {
+          const prefix = value.startsWith("/bkg ") ? "/bkg " : value.startsWith("/bg-task ") ? "/bg-task " : "/background-task ";
+          const newValue = `${prefix}${selected.name} `;
+          setValue(newValue);
+          setCursorOffset(newValue.length);
+          setSlashAutocompleteVisible(false);
+        } else if (value.startsWith("/sync ")) {
+          const newValue = `/sync ${selected.name} `;
+          setValue(newValue);
+          setCursorOffset(newValue.length);
+          setSlashAutocompleteVisible(false);
+        } else if (value.startsWith("/revert ")) {
+          const newValue = `/revert ${selected.name}`;
+          setValue(newValue);
+          setCursorOffset(newValue.length);
+          setSlashAutocompleteVisible(false);
+        } else if (value.startsWith("/models ") || value.startsWith("/model ")) {
+          const prefix = value.startsWith("/models ") ? "/models " : "/model ";
+          const newValue = `${prefix}${selected.name}`;
+          setValue(newValue);
+          setCursorOffset(newValue.length);
+          setSlashAutocompleteVisible(false);
+        } else if (value.startsWith("/rules ")) {
+          const ruleNameMatch = value.match(/^\/rules\s+(edit|delete)\s+/);
+          if (ruleNameMatch) {
+            const prefix = value.match(/^\/rules\s+(?:edit|delete)\s+/)?.[0] || "";
+            const newValue = `${prefix}${selected.name}`;
+            setValue(newValue);
+            setCursorOffset(newValue.length);
+            setSlashAutocompleteVisible(false);
+          } else {
+            const newValue = `/rules ${selected.name} `;
+            setValue(newValue);
+            setCursorOffset(newValue.length);
+            if (selected.name === "edit" || selected.name === "delete") {
+              const ruleMatches = getRuleNameAutocompleteEntries("");
+              if (ruleMatches.length > 0) {
+                setSlashAutocompleteCommands(ruleMatches);
+                setSlashAutocompleteSelectedIndex(0);
+                setSlashAutocompleteScrollOffset(0);
+              } else {
                 setSlashAutocompleteVisible(false);
-                return;
+              }
+            } else {
+              setSlashAutocompleteVisible(false);
             }
-        }
-        // Handle file tag (@) autocomplete navigation
-        if (fileTagAutocompleteVisible) {
-            if (key.downArrow) {
-                setFileTagSelectedIndex(prev => Math.min(prev + 1, Math.min(fileTagSuggestions.length - 1, 5)));
-                return;
-            }
-            if (key.upArrow) {
-                setFileTagSelectedIndex(prev => Math.max(prev - 1, 0));
-                return;
-            }
-            if (key.return && input.length <= 1 && !key.shift && !key.ctrl) {
-                // Select the highlighted file
-                const selected = fileTagSuggestions[fileTagSelectedIndex];
-                if (selected && activeFileTagStart !== null) {
-                    pushToUndoStack();
-                    // Replace @query with @filename
-                    const beforeTag = value.slice(0, activeFileTagStart);
-                    const afterCursor = value.slice(cursorOffset);
-                    const fileName = selected.name + (selected.isDirectory ? '/' : '');
-                    const newValue = beforeTag + '@' + fileName + ' ' + afterCursor;
-                    const newCursorPos = activeFileTagStart + 1 + fileName.length + 1;
-                    setValue(newValue);
-                    setCursorOffset(newCursorPos);
-                    // Add to confirmed file tags
-                    setConfirmedFileTags(prev => [
-                        ...prev.filter(tag => 
-                        // Remove any overlapping tags
-                        !(tag.start >= activeFileTagStart && tag.start <= cursorOffset)),
-                        {
-                            start: activeFileTagStart,
-                            end: activeFileTagStart + 1 + fileName.length,
-                            fileName: selected.name
-                        }
-                    ]);
-                    setFileTagAutocompleteVisible(false);
-                    setActiveFileTagStart(null);
-                }
-                return;
-            }
-            if (key.escape) {
-                setFileTagAutocompleteVisible(false);
-                setActiveFileTagStart(null);
-                return;
-            }
-            // If Tab is pressed, also select the current file
-            if (key.tab && !key.shift) {
-                const selected = fileTagSuggestions[fileTagSelectedIndex];
-                if (selected && activeFileTagStart !== null) {
-                    pushToUndoStack();
-                    const beforeTag = value.slice(0, activeFileTagStart);
-                    const afterCursor = value.slice(cursorOffset);
-                    const fileName = selected.name + (selected.isDirectory ? '/' : '');
-                    const newValue = beforeTag + '@' + fileName + afterCursor;
-                    const newCursorPos = activeFileTagStart + 1 + fileName.length;
-                    setValue(newValue);
-                    setCursorOffset(newCursorPos);
-                    // If it's a directory, keep dropdown open for subdirectory navigation
-                    if (!selected.isDirectory) {
-                        setConfirmedFileTags(prev => [
-                            ...prev.filter(tag => !(tag.start >= activeFileTagStart && tag.start <= cursorOffset)),
-                            {
-                                start: activeFileTagStart,
-                                end: activeFileTagStart + 1 + fileName.length,
-                                fileName: selected.name
-                            }
-                        ]);
-                        setFileTagAutocompleteVisible(false);
-                        setActiveFileTagStart(null);
-                    }
-                }
-                return;
-            }
-        }
-        // Alt+V: Paste image from clipboard
-        // Detect Alt+V on Windows/Linux (key.meta is often Alt on Windows in Ink)
-        // On Mac, we want to support Cmd+V explicitly as requested ("make alt key combinations work with cmd key")
-        // Note: Cmd+V is often captured by the terminal for text paste, but if it gets through, we handle it.
-        // Option+V on Mac often sends '√', which we also support.
-        const isAltV = (key.meta && input === 'v') || (input === '√');
-        if (isAltV && !commandMode) {
-            // Check clipboard for files asynchronously
-            (async () => {
-                try {
-                    const files = await getClipboardFiles();
-                    if (files.length > 0) {
-                        // Check limits (max 5 files allowed)
-                        const currentCount = confirmedClipboardFiles.length;
-                        const newCount = files.length;
-                        if (currentCount + newCount > 5) {
-                            logDebug(`Alt+V: Rejected file paste, limit exceeded (${currentCount} + ${newCount} > 5)`);
-                            setRejectFlash(true);
-                            setTimeout(() => setRejectFlash(false), 1000);
-                            return;
-                        }
-                        logDebug(`Alt+V: Found ${files.length} file(s) in clipboard, adding to input`);
-                        // Add files to confirmed list with unique ID
-                        const newFilesWithIds = files.map(file => ({
-                            ...file,
-                            id: `${file.id}_${Date.now()}_${Math.random().toString(36).substring(7)}`
-                        }));
-                        setConfirmedClipboardFiles(prev => [...prev, ...newFilesWithIds]);
-                    }
-                    else {
-                        logDebug('Alt+V: No file in clipboard');
-                    }
-                }
-                catch (error) {
-                    logDebug(`Alt+V: Failed to check clipboard: ${error instanceof Error ? error.message : 'Unknown error'}`);
-                }
-            })();
-            return;
-        }
-        // Alt+X / Cmd+X: Remove the last attached file/image
-        // Detect Alt+X on Windows/Linux or Cmd+X on Mac.
-        // Option+X on Mac often produces '≈'
-        const isAltX = (key.meta && input === 'x') || (input === '≈');
-        if (isAltX && !commandMode) {
-            if (confirmedClipboardFiles.length > 0) {
-                logDebug(`Alt+X: Removing last attached file`);
-                setConfirmedClipboardFiles(prev => prev.slice(0, -1));
+          }
+        } else if (value.startsWith("/workflow new ") || value.startsWith("/wf new ")) {
+          const prefix = value.startsWith("/workflow new ") ? "/workflow new " : "/wf new ";
+          const newValue = `${prefix}${selected.name}`;
+          setValue(newValue);
+          setCursorOffset(newValue.length);
+          setSlashAutocompleteVisible(false);
+        } else if (value.startsWith("/workflow ") || value.startsWith("/wf ")) {
+          const workflowNameMatch = value.match(/^\/(?:workflow|wf)\s+(run|view|delete)\s+/);
+          if (workflowNameMatch) {
+            const prefix = value.match(/^\/(?:workflow|wf)\s+(?:run|view|delete)\s+/)?.[0] || "";
+            const newValue = `${prefix}${selected.name}`;
+            setValue(newValue);
+            setCursorOffset(newValue.length);
+            setSlashAutocompleteVisible(false);
+          } else {
+            const prefix = value.startsWith("/workflow ") ? "/workflow " : "/wf ";
+            const newValue = `${prefix}${selected.name} `;
+            setValue(newValue);
+            setCursorOffset(newValue.length);
+            if (selected.name === "run" || selected.name === "view" || selected.name === "delete") {
+              const workflows = workflowStorage.list();
+              const matchingWorkflows = workflows.slice(0, 10).map((wf) => ({
+                name: wf.name,
+                description: wf.description || `${wf.stepCount} step${wf.stepCount !== 1 ? "s" : ""}`
+              }));
+              if (matchingWorkflows.length > 0) {
+                setSlashAutocompleteCommands(matchingWorkflows);
+                setSlashAutocompleteSelectedIndex(0);
+                setSlashAutocompleteScrollOffset(0);
+              } else {
+                setSlashAutocompleteVisible(false);
+              }
+            } else if (selected.name === "new") {
+              const subcommandMatches = filterCommands("workflow new ");
+              if (subcommandMatches.length > 0) {
+                setSlashAutocompleteCommands(subcommandMatches);
+                setSlashAutocompleteSelectedIndex(0);
+                setSlashAutocompleteScrollOffset(0);
+              } else {
+                setSlashAutocompleteVisible(false);
+              }
+            } else {
+              setSlashAutocompleteVisible(false);
             }
-            else {
-                logDebug(`Alt+X: No files to remove`);
+          }
+        } else if (value.startsWith("/settings auto-suggest ")) {
+          const newValue = `/settings auto-suggest ${selected.name}`;
+          setValue(newValue);
+          setCursorOffset(newValue.length);
+          setSlashAutocompleteVisible(false);
+        } else if (value.startsWith("/settings ")) {
+          const newValue = `/settings ${selected.name} `;
+          setValue(newValue);
+          setCursorOffset(newValue.length);
+          if (selected.name === "auto-suggest") {
+            const optionMatches = filterCommands("settings auto-suggest ");
+            if (optionMatches.length > 0) {
+              setSlashAutocompleteCommands(optionMatches);
+              setSlashAutocompleteSelectedIndex(0);
+              setSlashAutocompleteScrollOffset(0);
+            } else {
+              setSlashAutocompleteVisible(false);
+            }
+          } else {
+            setSlashAutocompleteVisible(false);
+          }
+        } else {
+          const newValue = `/${selected.name} `;
+          setValue(newValue);
+          setCursorOffset(newValue.length);
+          if (selected.name === "mcp") {
+            const subcommandMatches = filterCommands("mcp ");
+            if (subcommandMatches.length > 0) {
+              setSlashAutocompleteCommands(subcommandMatches);
+              setSlashAutocompleteSelectedIndex(0);
+              setSlashAutocompleteScrollOffset(0);
+            } else {
+              setSlashAutocompleteVisible(false);
+            }
+          } else if (selected.name === "chat") {
+            const subcommandMatches = filterCommands("chat ");
+            if (subcommandMatches.length > 0) {
+              setSlashAutocompleteCommands(subcommandMatches);
+              setSlashAutocompleteSelectedIndex(0);
+              setSlashAutocompleteScrollOffset(0);
+            } else {
+              setSlashAutocompleteVisible(false);
+            }
+          } else if (selected.name === "add-command" || selected.name === "add-command-auto-detect") {
+            const subcommandMatches = filterCommands("add-command ");
+            if (subcommandMatches.length > 0) {
+              setSlashAutocompleteCommands(subcommandMatches);
+              setSlashAutocompleteSelectedIndex(0);
+              setSlashAutocompleteScrollOffset(0);
+            } else {
+              setSlashAutocompleteVisible(false);
+            }
+          } else if (selected.name === "background-task" || selected.name === "bkg" || selected.name === "bg-task") {
+            const subcommandMatches = filterCommands("background-task ");
+            if (subcommandMatches.length > 0) {
+              setSlashAutocompleteCommands(subcommandMatches);
+              setSlashAutocompleteSelectedIndex(0);
+              setSlashAutocompleteScrollOffset(0);
+            } else {
+              setSlashAutocompleteVisible(false);
+            }
+          } else if (selected.name === "sync") {
+            const subcommandMatches = filterCommands("sync ");
+            if (subcommandMatches.length > 0) {
+              setSlashAutocompleteCommands(subcommandMatches);
+              setSlashAutocompleteSelectedIndex(0);
+              setSlashAutocompleteScrollOffset(0);
+            } else {
+              setSlashAutocompleteVisible(false);
+            }
+          } else if (selected.name === "models" || selected.name === "model") {
+            const subcommandMatches = filterCommands("models ");
+            if (subcommandMatches.length > 0) {
+              setSlashAutocompleteCommands(subcommandMatches);
+              setSlashAutocompleteSelectedIndex(0);
+              setSlashAutocompleteScrollOffset(0);
+            } else {
+              setSlashAutocompleteVisible(false);
+            }
+          } else if (selected.name === "settings") {
+            const subcommandMatches = filterCommands("settings ");
+            if (subcommandMatches.length > 0) {
+              setSlashAutocompleteCommands(subcommandMatches);
+              setSlashAutocompleteSelectedIndex(0);
+              setSlashAutocompleteScrollOffset(0);
+            } else {
+              setSlashAutocompleteVisible(false);
+            }
+          } else if (selected.name === "workflow" || selected.name === "wf") {
+            const subcommandMatches = filterCommands("workflow ");
+            if (subcommandMatches.length > 0) {
+              setSlashAutocompleteCommands(subcommandMatches);
+              setSlashAutocompleteSelectedIndex(0);
+              setSlashAutocompleteScrollOffset(0);
+            } else {
+              setSlashAutocompleteVisible(false);
+            }
+          } else if (selected.name === "rules") {
+            const subcommandMatches = filterCommands("rules ");
+            if (subcommandMatches.length > 0) {
+              setSlashAutocompleteCommands(subcommandMatches);
+              setSlashAutocompleteSelectedIndex(0);
+              setSlashAutocompleteScrollOffset(0);
+            } else {
+              setSlashAutocompleteVisible(false);
+            }
+          } else if (selected.name === "revert") {
+            const checkpoints = getCheckpoints ? getCheckpoints() : [];
+            if (checkpoints.length === 0) {
+              setSlashAutocompleteCommands([{
+                name: "(no checkpoints)",
+                description: "Ask AI a question first to create a checkpoint"
+              }]);
+              setSlashAutocompleteSelectedIndex(0);
+              setSlashAutocompleteScrollOffset(0);
+            } else {
+              const checkpointCommands = checkpoints.slice(0, 10).map((cp) => {
+                const truncatedPrompt = cp.prompt.length > 50 ? cp.prompt.slice(0, 50) + "..." : cp.prompt;
+                return {
+                  name: cp.id,
+                  description: truncatedPrompt
+                };
+              });
+              setSlashAutocompleteCommands(checkpointCommands);
+              setSlashAutocompleteSelectedIndex(0);
+              setSlashAutocompleteScrollOffset(0);
             }
-            return;
+          } else {
+            setSlashAutocompleteVisible(false);
+          }
         }
-        // DELETE WORD BACKWARDS
-        // 1. Ctrl+W
-        // 2. Cmd+Backspace (Mac) - often mapped to delete line, but here we treat key.meta as modifier
-        // 3. Alt+Backspace (Windows/Linux)
-        const isDeleteWord = inputCharCode === 23 || // Ctrl+W
-            (key.meta && (key.backspace || key.delete)) || // Cmd+Backspace (Mac) or Alt+Backspace (Win)
-            (key.ctrl && key.delete) || // Ctrl+Delete
-            (isWindows && inputCharCode === 127); // Windows: Ctrl+Del sends char 127
-        if (isDeleteWord) {
-            pushToUndoStack();
-            if (cursorOffset > 0) {
-                let newOffset = cursorOffset;
-                // Skip whitespace backwards
-                while (newOffset > 0 && /\s/.test(value[newOffset - 1])) {
-                    newOffset--;
-                }
-                // Skip non-whitespace backwards
-                while (newOffset > 0 && !/\s/.test(value[newOffset - 1])) {
-                    newOffset--;
-                }
-                const newValue = value.slice(0, newOffset) + value.slice(cursorOffset);
-                setValue(newValue);
-                setCursorOffset(newOffset);
-                // Update slash command autocomplete
-                if (newValue.startsWith('/') && !newValue.includes(' ')) {
-                    const query = newValue.slice(1);
-                    const matches = filterCommands(query);
-                    if (matches.length > 0) {
-                        setSlashAutocompleteCommands(matches);
-                        setSlashAutocompleteVisible(true);
-                        setSlashAutocompleteSelectedIndex(0);
-                        setSlashAutocompleteScrollOffset(0);
-                    }
-                    else {
-                        setSlashAutocompleteVisible(false);
-                    }
-                }
-                else if (newValue.startsWith('/mcp ')) {
-                    // MCP subcommands
-                    const fullQuery = newValue.slice(1);
-                    const matches = filterCommands(fullQuery);
-                    if (matches.length > 0) {
-                        setSlashAutocompleteCommands(matches);
-                        setSlashAutocompleteVisible(true);
-                        setSlashAutocompleteSelectedIndex(0);
-                        setSlashAutocompleteScrollOffset(0);
-                    }
-                    else {
-                        setSlashAutocompleteVisible(false);
-                    }
-                }
-                else if (newValue.startsWith('/chat ')) {
-                    // Chat subcommands
-                    const fullQuery = newValue.slice(1);
-                    const matches = filterCommands(fullQuery);
-                    if (matches.length > 0) {
-                        setSlashAutocompleteCommands(matches);
-                        setSlashAutocompleteVisible(true);
-                        setSlashAutocompleteSelectedIndex(0);
-                        setSlashAutocompleteScrollOffset(0);
-                    }
-                    else {
-                        setSlashAutocompleteVisible(false);
-                    }
-                }
-                else if (newValue.startsWith('/add-command ') || newValue.startsWith('/add-command-auto-detect ')) {
-                    // Add-command subcommands
-                    const fullQuery = newValue.slice(1);
-                    const matches = filterCommands(fullQuery);
-                    if (matches.length > 0) {
-                        setSlashAutocompleteCommands(matches);
-                        setSlashAutocompleteVisible(true);
-                        setSlashAutocompleteSelectedIndex(0);
-                        setSlashAutocompleteScrollOffset(0);
-                    }
-                    else {
-                        setSlashAutocompleteVisible(false);
-                    }
-                }
-                else if (newValue.startsWith('/background-task ') || newValue.startsWith('/bkg ') || newValue.startsWith('/bg-task ')) {
-                    // Background-task subcommands
-                    const fullQuery = newValue.slice(1);
-                    const matches = filterCommands(fullQuery);
-                    if (matches.length > 0) {
-                        setSlashAutocompleteCommands(matches);
-                        setSlashAutocompleteVisible(true);
-                        setSlashAutocompleteSelectedIndex(0);
-                        setSlashAutocompleteScrollOffset(0);
-                    }
-                    else {
-                        setSlashAutocompleteVisible(false);
-                    }
-                }
-                else if (newValue.startsWith('/sync ')) {
-                    // Sync subcommands
-                    const fullQuery = newValue.slice(1);
-                    const matches = filterCommands(fullQuery);
-                    if (matches.length > 0) {
-                        setSlashAutocompleteCommands(matches);
-                        setSlashAutocompleteVisible(true);
-                        setSlashAutocompleteSelectedIndex(0);
-                        setSlashAutocompleteScrollOffset(0);
-                    }
-                    else {
-                        setSlashAutocompleteVisible(false);
-                    }
-                }
-                else if (newValue.startsWith('/models ') || newValue.startsWith('/model ')) {
-                    // Models subcommands
-                    const fullQuery = newValue.slice(1);
-                    const matches = filterCommands(fullQuery);
-                    if (matches.length > 0) {
-                        setSlashAutocompleteCommands(matches);
-                        setSlashAutocompleteVisible(true);
-                        setSlashAutocompleteSelectedIndex(0);
-                        setSlashAutocompleteScrollOffset(0);
-                    }
-                    else {
-                        setSlashAutocompleteVisible(false);
-                    }
-                }
-                else if (newValue.startsWith('/revert ')) {
-                    // Checkpoint autocomplete for /revert command
-                    const partialId = newValue.slice(8).toLowerCase(); // Remove "/revert "
-                    const checkpoints = getCheckpoints ? getCheckpoints() : [];
-                    if (checkpoints.length === 0) {
-                        // No checkpoints yet - show informative message
-                        setSlashAutocompleteCommands([{
-                                name: '(no checkpoints)',
-                                description: 'Ask AI a question first to create a checkpoint'
-                            }]);
-                        setSlashAutocompleteVisible(true);
-                        setSlashAutocompleteSelectedIndex(0);
-                        setSlashAutocompleteScrollOffset(0);
-                    }
-                    else {
-                        const matchingCheckpoints = checkpoints
-                            .filter(cp => cp.id.toLowerCase().includes(partialId) || cp.prompt.toLowerCase().includes(partialId))
-                            .slice(0, 10)
-                            .map(cp => {
-                            const truncatedPrompt = cp.prompt.length > 50 ? cp.prompt.slice(0, 50) + '...' : cp.prompt;
-                            return {
-                                name: cp.id,
-                                description: truncatedPrompt
-                            };
-                        });
-                        if (matchingCheckpoints.length > 0) {
-                            setSlashAutocompleteCommands(matchingCheckpoints);
-                            setSlashAutocompleteVisible(true);
-                            setSlashAutocompleteSelectedIndex(0);
-                            setSlashAutocompleteScrollOffset(0);
-                        }
-                        else {
-                            setSlashAutocompleteVisible(false);
-                        }
-                    }
-                }
-                else if (newValue.match(/^\/workflow\s+(run|view|delete)\s+/) ||
-                    newValue.match(/^\/wf\s+(run|view|delete)\s+/)) {
-                    // Workflow name autocomplete (when user types "/workflow run " or similar)
-                    // This MUST come before the /workflow subcommand check since it's more specific
-                    const match = newValue.match(/^\/(?:workflow|wf)\s+(?:run|view|delete)\s+(.*)$/);
-                    const partialName = match ? match[1].toLowerCase() : '';
-                    const workflows = workflowStorage.list();
-                    const matchingWorkflows = workflows
-                        .filter(wf => wf.name.toLowerCase().includes(partialName))
-                        .slice(0, 10)
-                        .map(wf => ({
-                        name: wf.name,
-                        description: wf.description || `${wf.stepCount} step${wf.stepCount !== 1 ? 's' : ''}`
-                    }));
-                    if (matchingWorkflows.length > 0) {
-                        setSlashAutocompleteCommands(matchingWorkflows);
-                        setSlashAutocompleteVisible(true);
-                        setSlashAutocompleteSelectedIndex(0);
-                        setSlashAutocompleteScrollOffset(0);
-                    }
-                    else {
-                        setSlashAutocompleteVisible(false);
-                    }
-                }
-                else if (newValue.match(/^\/workflow\s+new\s+/) ||
-                    newValue.match(/^\/wf\s+new\s+/)) {
-                    // Workflow new subcommand autocomplete (manual, learn-workflow)
-                    const fullQuery = newValue.slice(1);
-                    const matches = filterCommands(fullQuery);
-                    if (matches.length > 0) {
-                        setSlashAutocompleteCommands(matches);
-                        setSlashAutocompleteVisible(true);
-                        setSlashAutocompleteSelectedIndex(0);
-                        setSlashAutocompleteScrollOffset(0);
-                    }
-                    else {
-                        setSlashAutocompleteVisible(false);
-                    }
-                }
-                else if (newValue.startsWith('/workflow ') || newValue.startsWith('/wf ')) {
-                    // Workflow subcommands (when user types "/workflow " or "/wf ")
-                    const fullQuery = newValue.slice(1);
-                    const matches = filterCommands(fullQuery);
-                    if (matches.length > 0) {
-                        setSlashAutocompleteCommands(matches);
-                        setSlashAutocompleteVisible(true);
-                        setSlashAutocompleteSelectedIndex(0);
-                        setSlashAutocompleteScrollOffset(0);
-                    }
-                    else {
-                        setSlashAutocompleteVisible(false);
-                    }
-                }
-                else {
-                    setSlashAutocompleteVisible(false);
-                }
-            }
-            setHistoryIndex(-1);
-            setCompletions([]);
-            return;
+        return;
+      }
+      if (key.escape) {
+        setSlashAutocompleteVisible(false);
+        return;
+      }
+    }
+    if (fileTagAutocompleteVisible) {
+      if (key.downArrow) {
+        setFileTagSelectedIndex(
+          (prev) => Math.min(prev + 1, fileTagSuggestions.length - 1)
+        );
+        return;
+      }
+      if (key.upArrow) {
+        setFileTagSelectedIndex((prev) => Math.max(prev - 1, 0));
+        return;
+      }
+      if (key.return && input.length <= 1 && !key.shift && !key.ctrl && !key.meta) {
+        const selected = fileTagSuggestions[fileTagSelectedIndex];
+        if (selected && activeFileTagStart !== null) {
+          applyMentionSuggestion(selected, false);
         }
-        // Ctrl+T: Toggle auto-accept
-        if (key.ctrl && input.toLowerCase() === 't') {
-            ignoreNextChangeRef.current = true;
-            onToggleAutoAccept();
-            setTimeout(() => { ignoreNextChangeRef.current = false; }, 100);
-            return;
+        return;
+      }
+      if (key.escape) {
+        setFileTagAutocompleteVisible(false);
+        setActiveFileTagStart(null);
+        return;
+      }
+      if (key.tab && !key.shift) {
+        const selected = fileTagSuggestions[fileTagSelectedIndex];
+        if (selected && activeFileTagStart !== null) {
+          applyMentionSuggestion(selected, true);
         }
-        // Ctrl+D: Cycle modes (Agent -> Terminal -> Background -> Auto -> Agent)
-        if (key.ctrl && input.toLowerCase() === 'd') {
-            if (onToggleCommandMode) {
-                ignoreNextChangeRef.current = true;
-                // Cycle Logic: Agent -> Terminal -> Background -> Auto -> Agent
-                if (!isAutoMode && !commandMode && !backgroundMode) {
-                    // Agent -> Terminal
-                    onToggleCommandMode();
-                }
-                else if (!isAutoMode && commandMode && !backgroundMode) {
-                    // Terminal -> Background
-                    onToggleCommandMode(); // Exit terminal mode
-                    if (onToggleBackgroundMode)
-                        onToggleBackgroundMode(); // Enter background mode
-                }
-                else if (!isAutoMode && !commandMode && backgroundMode) {
-                    // Background -> Auto
-                    if (onToggleBackgroundMode)
-                        onToggleBackgroundMode(); // Exit background mode
-                    setIsAutoMode(true);
-                    // Trigger initial detection for Auto mode
-                    const intent = detectIntent(value);
-                    setDetectedIntent(intent);
-                    // Set command mode based on intent
-                    if (intent === 'command')
-                        onToggleCommandMode();
-                }
-                else if (isAutoMode) {
-                    // Auto -> Agent
-                    setIsAutoMode(false);
-                    // Ensure we go back to Agent mode (commandMode = false, backgroundMode = false)
-                    if (commandMode)
-                        onToggleCommandMode();
-                    if (backgroundMode && onToggleBackgroundMode)
-                        onToggleBackgroundMode();
-                }
-                setTimeout(() => { ignoreNextChangeRef.current = false; }, 100);
-            }
-            return;
+        return;
+      }
+    }
+    const isAltV = key.meta && input === "v" || input === "\u221A";
+    if (isAltV && !commandMode) {
+      (async () => {
+        try {
+          const files = await getClipboardFiles();
+          if (files.length > 0) {
+            const currentCount = confirmedClipboardFiles.length;
+            const newCount = files.length;
+            if (currentCount + newCount > 5) {
+              logDebug(`Alt+V: Rejected file paste, limit exceeded (${currentCount} + ${newCount} > 5)`);
+              setRejectFlash(true);
+              setTimeout(() => setRejectFlash(false), 1e3);
+              return;
+            }
+            logDebug(`Alt+V: Found ${files.length} file(s) in clipboard, adding to input`);
+            const newFilesWithIds = files.map((file) => ({
+              ...file,
+              id: `${file.id}_${Date.now()}_${Math.random().toString(36).substring(7)}`
+            }));
+            setConfirmedClipboardFiles((prev) => [...prev, ...newFilesWithIds]);
+          } else {
+            logDebug("Alt+V: No file in clipboard");
+          }
+        } catch (error) {
+          logDebug(`Alt+V: Failed to check clipboard: ${error instanceof Error ? error.message : "Unknown error"}`);
         }
-        // Ctrl+Z / Cmd+Z: Undo
-        if ((key.ctrl && input.toLowerCase() === 'z') || (key.meta && input.toLowerCase() === 'z')) {
-            handleUndo();
-            return;
+      })();
+      return;
+    }
+    const isAltX = key.meta && input === "x" || input === "\u2248";
+    if (isAltX && !commandMode) {
+      if (confirmedClipboardFiles.length > 0) {
+        logDebug(`Alt+X: Removing last attached file`);
+        setConfirmedClipboardFiles((prev) => prev.slice(0, -1));
+      } else {
+        logDebug(`Alt+X: No files to remove`);
+      }
+      return;
+    }
+    if (isMacOptionWordBackwardSequence) {
+      if (cursorOffset > 0) {
+        let newOffset = cursorOffset;
+        while (newOffset > 0 && /\s/.test(value[newOffset - 1])) {
+          newOffset--;
         }
-        // Ctrl+A / Cmd+A: Select All
-        if ((key.ctrl && input.toLowerCase() === 'a') || (key.meta && input.toLowerCase() === 'a')) {
-            setSelection({ start: 0, end: value.length });
-            setCursorOffset(value.length);
-            return;
+        while (newOffset > 0 && !/\s/.test(value[newOffset - 1])) {
+          newOffset--;
         }
-        // Home: Start of Line
-        // Note: In single-line inputs, this goes to start of text. 
-        // In multi-line wrapped view, we ideally want start of logical line or start of text? 
-        // Standard terminal Home = Start of command. Editor Home = Start of line.
-        // Let's stick to Start of Text for now as it's a single "input box".
-        // Home: Start of Line
-        // @ts-ignore
-        if (key.home) {
-            const width = (process.stdout.columns || 80) - 6;
-            const visualLines = getVisualLines(value, width);
-            const currentLine = visualLines.find(line => (cursorOffset >= line.start && cursorOffset < line.end) ||
-                (cursorOffset === line.end && line.isHardEnd));
-            if (currentLine) {
-                setCursorOffset(currentLine.start);
-            }
-            else {
-                setCursorOffset(0);
-            }
-            return;
+        setCursorOffset(newOffset);
+      }
+      return;
+    }
+    if (isMacOptionWordForwardSequence) {
+      if (cursorOffset < value.length) {
+        let newOffset = cursorOffset;
+        while (newOffset < value.length && /\s/.test(value[newOffset])) {
+          newOffset++;
         }
-        // End: End of Line
-        // @ts-ignore
-        if (key.end) {
-            const width = (process.stdout.columns || 80) - 6;
-            const visualLines = getVisualLines(value, width);
-            const currentLine = visualLines.find(line => (cursorOffset >= line.start && cursorOffset < line.end) ||
-                (cursorOffset === line.end && line.isHardEnd));
-            if (currentLine) {
-                setCursorOffset(currentLine.end);
-            }
-            else {
-                setCursorOffset(value.length);
-            }
-            return;
+        while (newOffset < value.length && !/\s/.test(value[newOffset])) {
+          newOffset++;
         }
-        // Note: Clipboard images are handled via Alt+V keyboard shortcut
-        // DELETE CHAR - Only runs if Delete Word did NOT trigger
-        // Triggers on:
-        // 1. Backspace or Delete key flag is present
-        // 2. OR char code 8 (standard backspace)
-        // 3. OR char code 127 (DEL) on non-Windows (Mac/Linux treat 127 as normal backspace)
-        // NOTE: On Windows/Ink, Backspace often reports as 'delete: true', so we treat key.delete as Backspace to ensure the Backspace key works correctly.
-        const isDeleteChar = key.backspace ||
-            key.delete ||
-            inputCharCode === 8 ||
-            (!isWindows && inputCharCode === 127);
-        if (isDeleteChar) {
-            pushToUndoStack();
-            let newValue = value;
-            if (selection) {
-                // Delete selection
-                const start = Math.min(selection.start, selection.end);
-                const end = Math.max(selection.start, selection.end);
-                newValue = value.slice(0, start) + value.slice(end);
-                setValue(newValue);
-                setCursorOffset(start);
-                setSelection(null);
-            }
-            else if (cursorOffset > 0) {
-                // Backspace (or Delete acting as Backspace): Delete character before cursor
-                newValue = value.slice(0, cursorOffset - 1) + value.slice(cursorOffset);
-                setValue(newValue);
-                setCursorOffset(cursorOffset - 1);
-            }
-            // Reset history/completions on edit
-            setHistoryIndex(-1);
-            setCompletions([]);
-            // Update slash command autocomplete
-            if (newValue.startsWith('/') && !newValue.includes(' ')) {
-                const query = newValue.slice(1);
-                const matches = filterCommands(query);
-                if (matches.length > 0) {
-                    setSlashAutocompleteCommands(matches);
-                    setSlashAutocompleteVisible(true);
-                    setSlashAutocompleteSelectedIndex(0);
-                    setSlashAutocompleteScrollOffset(0);
-                }
-                else {
-                    setSlashAutocompleteVisible(false);
-                }
-            }
-            else if (newValue.startsWith('/mcp ')) {
-                // MCP subcommands
-                const fullQuery = newValue.slice(1);
-                const matches = filterCommands(fullQuery);
-                if (matches.length > 0) {
-                    setSlashAutocompleteCommands(matches);
-                    setSlashAutocompleteVisible(true);
-                    setSlashAutocompleteSelectedIndex(0);
-                    setSlashAutocompleteScrollOffset(0);
-                }
-                else {
-                    setSlashAutocompleteVisible(false);
-                }
-            }
-            else if (newValue.startsWith('/chat ')) {
-                // Chat subcommands
-                const fullQuery = newValue.slice(1);
-                const matches = filterCommands(fullQuery);
-                if (matches.length > 0) {
-                    setSlashAutocompleteCommands(matches);
-                    setSlashAutocompleteVisible(true);
-                    setSlashAutocompleteSelectedIndex(0);
-                    setSlashAutocompleteScrollOffset(0);
-                }
-                else {
-                    setSlashAutocompleteVisible(false);
-                }
-            }
-            else if (newValue.startsWith('/add-command ') || newValue.startsWith('/add-command-auto-detect ')) {
-                // Add-command subcommands
-                const fullQuery = newValue.slice(1);
-                const matches = filterCommands(fullQuery);
-                if (matches.length > 0) {
-                    setSlashAutocompleteCommands(matches);
-                    setSlashAutocompleteVisible(true);
-                    setSlashAutocompleteSelectedIndex(0);
-                    setSlashAutocompleteScrollOffset(0);
-                }
-                else {
-                    setSlashAutocompleteVisible(false);
-                }
-            }
-            else if (newValue.startsWith('/background-task ') || newValue.startsWith('/bkg ') || newValue.startsWith('/bg-task ')) {
-                // Background-task subcommands
-                const fullQuery = newValue.slice(1);
-                const matches = filterCommands(fullQuery);
-                if (matches.length > 0) {
-                    setSlashAutocompleteCommands(matches);
-                    setSlashAutocompleteVisible(true);
-                    setSlashAutocompleteSelectedIndex(0);
-                    setSlashAutocompleteScrollOffset(0);
-                }
-                else {
-                    setSlashAutocompleteVisible(false);
-                }
-            }
-            else if (newValue.startsWith('/sync ')) {
-                // Sync subcommands
-                const fullQuery = newValue.slice(1);
-                const matches = filterCommands(fullQuery);
-                if (matches.length > 0) {
-                    setSlashAutocompleteCommands(matches);
-                    setSlashAutocompleteVisible(true);
-                    setSlashAutocompleteSelectedIndex(0);
-                    setSlashAutocompleteScrollOffset(0);
-                }
-                else {
-                    setSlashAutocompleteVisible(false);
-                }
-            }
-            else if (newValue.startsWith('/models ') || newValue.startsWith('/model ')) {
-                // Models subcommands
-                const fullQuery = newValue.slice(1);
-                const matches = filterCommands(fullQuery);
-                if (matches.length > 0) {
-                    setSlashAutocompleteCommands(matches);
-                    setSlashAutocompleteVisible(true);
-                    setSlashAutocompleteSelectedIndex(0);
-                    setSlashAutocompleteScrollOffset(0);
-                }
-                else {
-                    setSlashAutocompleteVisible(false);
-                }
-            }
-            else {
-                setSlashAutocompleteVisible(false);
-            }
-            return;
+        setCursorOffset(newOffset);
+      }
+      return;
+    }
+    const isDeleteWord = inputCharCode === 23 || // Ctrl+W
+    key.meta && (key.backspace || key.delete) || // Cmd+Backspace (Mac) or Alt+Backspace (Win)
+    key.ctrl && key.delete || // Ctrl+Delete
+    isWindows && inputCharCode === 127;
+    if (isDeleteWord) {
+      pushToUndoStack();
+      if (cursorOffset > 0) {
+        let newOffset = cursorOffset;
+        while (newOffset > 0 && /\s/.test(value[newOffset - 1])) {
+          newOffset--;
         }
-        // Handle Enter
-        // Check input length to distinguish single key press from paste
-        if (key.return && input.length <= 1) {
-            // Check for Shift+Enter, Ctrl+Enter, OR explicit newline char
-            // Note: Shift+Enter doesn't work on Windows/Ink, so Ctrl+Enter is the alternative
-            // Alt+Enter can't be used as it fullscreens the terminal on Windows
-            if (key.shift || key.ctrl || input === '\n') {
-                pushToUndoStack();
-                // Shift+Enter or Ctrl+Enter: Insert newline
-                // If selection exists, replace it
-                let newValue = value;
-                let newOffset = cursorOffset;
-                if (selection) {
-                    const start = Math.min(selection.start, selection.end);
-                    const end = Math.max(selection.start, selection.end);
-                    newValue = value.slice(0, start) + '\n' + value.slice(end);
-                    newOffset = start + 1;
-                    setSelection(null);
-                }
-                else {
-                    newValue = value.slice(0, cursorOffset) + '\n' + value.slice(cursorOffset);
-                    newOffset = cursorOffset + 1;
-                }
-                setValue(newValue);
-                setCursorOffset(newOffset);
-            }
-            else {
-                // Enter: Submit
-                // Check if submission is allowed when disconnected
-                // Allowed: /exit command, OR Command Mode is active, OR detected intent is 'command'
-                const isExitCommand = value.trim() === '/exit';
-                const isCommandIntent = detectedIntent === 'command';
-                const isAllowedOffline = isConnected || isExitCommand || commandMode || isCommandIntent;
-                if (!isAllowedOffline) {
-                    setRejectFlash(true);
-                    setTimeout(() => setRejectFlash(false), 1000);
-                    return;
-                }
-                // Check context limit (only for AI mode, not command mode or slash commands)
-                // Slash commands and terminal commands should always be allowed
-                const isSlashCommand = value.trim().startsWith('/');
-                if (!commandMode && !isCommandIntent && !isSlashCommand && contextLimitReached) {
-                    setRejectFlash(true);
-                    setTimeout(() => {
-                        setRejectFlash(false);
-                    }, 3000); // Flash red for 3 seconds
-                    return;
-                }
-                // Check session quota (only for AI mode, not command mode or slash commands)
-                // Slash commands and terminal commands should always be allowed
-                if (!commandMode && !isCommandIntent && !isSlashCommand && sessionQuotaExhausted) {
-                    setRejectFlash(true);
-                    setShowQuotaMessage(true);
-                    setTimeout(() => {
-                        setRejectFlash(false);
-                        setShowQuotaMessage(false);
-                    }, 3000); // Show quota message for 3 seconds
-                    return;
-                }
-                handleSubmit();
-            }
-            return;
+        while (newOffset > 0 && !/\s/.test(value[newOffset - 1])) {
+          newOffset--;
         }
-        // Handle Arrows
-        if (key.upArrow || key.downArrow || key.leftArrow || key.rightArrow) {
-            // Clear selection on arrow keys
-            if (selection) {
-                setSelection(null);
-                // If left/right, maybe move cursor to start/end of selection?
-                // For now, just clear selection and let default logic run (or reset cursor to one end)
-                if (key.leftArrow)
-                    setCursorOffset(Math.min(selection.start, selection.end));
-                if (key.rightArrow)
-                    setCursorOffset(Math.max(selection.start, selection.end));
-                if (key.upArrow || key.downArrow) {
-                    // Keep cursor where it is (at the end usually) or move it?
-                    // Let's just fall through to normal arrow logic from current cursorOffset
-                }
-                if (key.leftArrow || key.rightArrow)
-                    return; // We handled the move
-            }
+        const newValue = value.slice(0, newOffset) + value.slice(cursorOffset);
+        setValue(newValue);
+        setCursorOffset(newOffset);
+        updateSlashAutocomplete(newValue);
+      }
+      setHistoryIndex(-1);
+      setCompletions([]);
+      return;
+    }
+    if (key.ctrl && input.toLowerCase() === "t") {
+      ignoreNextChangeRef.current = true;
+      onToggleAutoAccept();
+      setTimeout(() => {
+        ignoreNextChangeRef.current = false;
+      }, 100);
+      return;
+    }
+    if (key.ctrl && input.toLowerCase() === "d") {
+      if (onToggleCommandMode) {
+        ignoreNextChangeRef.current = true;
+        if (!isAutoMode && !commandMode && !backgroundMode) {
+          onToggleCommandMode();
+        } else if (!isAutoMode && commandMode && !backgroundMode) {
+          onToggleCommandMode();
+          if (onToggleBackgroundMode) onToggleBackgroundMode();
+        } else if (!isAutoMode && !commandMode && backgroundMode) {
+          if (onToggleBackgroundMode) onToggleBackgroundMode();
+          setIsAutoMode(true);
+          const intent = detectIntent(value);
+          setDetectedIntent(intent);
+          if (intent === "command") onToggleCommandMode();
+        } else if (isAutoMode) {
+          setIsAutoMode(false);
+          if (commandMode) onToggleCommandMode();
+          if (backgroundMode && onToggleBackgroundMode) onToggleBackgroundMode();
         }
-        if (key.upArrow) {
-            const width = (process.stdout.columns || 80) - 6;
-            const visualLines = getVisualLines(value, width);
-            let currentVisualLineIndex = visualLines.findIndex(line => {
-                if (cursorOffset >= line.start && cursorOffset < line.end)
-                    return true;
-                if (cursorOffset === line.end && line.isHardEnd)
-                    return true;
-                return false;
-            });
-            // If cursor is at the very end of the last line
-            if (currentVisualLineIndex === -1 && cursorOffset === value.length) {
-                currentVisualLineIndex = visualLines.length - 1;
-            }
-            if (currentVisualLineIndex <= 0) {
-                // Top line: History navigation
-                if (commandHistory.length > 0) {
-                    if (historyIndex === -1) {
-                        setTempValue(value);
-                        const newIndex = commandHistory.length - 1;
-                        setHistoryIndex(newIndex);
-                        const newValue = commandHistory[newIndex];
-                        setValue(newValue);
-                        setCursorOffset(newValue.length);
-                    }
-                    else if (historyIndex > 0) {
-                        const newIndex = historyIndex - 1;
-                        setHistoryIndex(newIndex);
-                        const newValue = commandHistory[newIndex];
-                        setValue(newValue);
-                        setCursorOffset(newValue.length);
-                    }
-                }
-            }
-            else {
-                // Move cursor up one visual line
-                const currentLine = visualLines[currentVisualLineIndex];
-                const targetLine = visualLines[currentVisualLineIndex - 1];
-                const offsetInLine = cursorOffset - currentLine.start;
-                const newOffset = targetLine.start + Math.min(offsetInLine, targetLine.end - targetLine.start);
-                setCursorOffset(newOffset);
-            }
-            return;
+        setTimeout(() => {
+          ignoreNextChangeRef.current = false;
+        }, 100);
+      }
+      return;
+    }
+    if (key.ctrl && input.toLowerCase() === "z" || key.meta && input.toLowerCase() === "z") {
+      handleUndo();
+      return;
+    }
+    if (key.ctrl && input.toLowerCase() === "a" || key.meta && input.toLowerCase() === "a") {
+      setSelection({ start: 0, end: value.length });
+      setCursorOffset(value.length);
+      return;
+    }
+    if (key.home) {
+      const width = (process.stdout.columns || 80) - 6;
+      const visualLines = getVisualLines(value, width);
+      const currentLine = visualLines.find(
+        (line) => cursorOffset >= line.start && cursorOffset < line.end || cursorOffset === line.end && line.isHardEnd
+      );
+      if (currentLine) {
+        setCursorOffset(currentLine.start);
+      } else {
+        setCursorOffset(0);
+      }
+      return;
+    }
+    if (key.end) {
+      const width = (process.stdout.columns || 80) - 6;
+      const visualLines = getVisualLines(value, width);
+      const currentLine = visualLines.find(
+        (line) => cursorOffset >= line.start && cursorOffset < line.end || cursorOffset === line.end && line.isHardEnd
+      );
+      if (currentLine) {
+        setCursorOffset(currentLine.end);
+      } else {
+        setCursorOffset(value.length);
+      }
+      return;
+    }
+    const isDeleteChar = key.backspace || key.delete || inputCharCode === 8 || !isWindows && inputCharCode === 127;
+    if (isDeleteChar) {
+      pushToUndoStack();
+      let newValue = value;
+      if (selection) {
+        const start = Math.min(selection.start, selection.end);
+        const end = Math.max(selection.start, selection.end);
+        newValue = value.slice(0, start) + value.slice(end);
+        setValue(newValue);
+        setCursorOffset(start);
+        setSelection(null);
+      } else if (cursorOffset > 0) {
+        newValue = value.slice(0, cursorOffset - 1) + value.slice(cursorOffset);
+        setValue(newValue);
+        setCursorOffset(cursorOffset - 1);
+      }
+      setHistoryIndex(-1);
+      setCompletions([]);
+      updateSlashAutocomplete(newValue);
+      return;
+    }
+    if (isEnterEvent && (input.length <= 1 || isTerminalShiftEnterSequence)) {
+      const isBackslashEnterFallback = !key.shift && !key.ctrl && !key.meta && !isTerminalShiftEnterSequence && !selection && cursorOffset > 0 && value[cursorOffset - 1] === "\\";
+      if (key.shift || key.ctrl || key.meta || input === "\n" || isTerminalShiftEnterSequence || isBackslashEnterFallback) {
+        pushToUndoStack();
+        let newValue = value;
+        let newOffset = cursorOffset;
+        if (selection) {
+          const start = Math.min(selection.start, selection.end);
+          const end = Math.max(selection.start, selection.end);
+          newValue = value.slice(0, start) + "\n" + value.slice(end);
+          newOffset = start + 1;
+          setSelection(null);
+        } else if (isBackslashEnterFallback) {
+          newValue = value.slice(0, cursorOffset - 1) + "\n" + value.slice(cursorOffset);
+          newOffset = cursorOffset;
+        } else {
+          newValue = value.slice(0, cursorOffset) + "\n" + value.slice(cursorOffset);
+          newOffset = cursorOffset + 1;
         }
-        if (key.downArrow) {
-            const width = (process.stdout.columns || 80) - 6;
-            const visualLines = getVisualLines(value, width);
-            let currentVisualLineIndex = visualLines.findIndex(line => {
-                if (cursorOffset >= line.start && cursorOffset < line.end)
-                    return true;
-                if (cursorOffset === line.end && line.isHardEnd)
-                    return true;
-                return false;
-            });
-            // If cursor is at the very end of the last line
-            if (currentVisualLineIndex === -1 && cursorOffset === value.length) {
-                currentVisualLineIndex = visualLines.length - 1;
-            }
-            if (currentVisualLineIndex === visualLines.length - 1) {
-                // Bottom line: History navigation
-                if (historyIndex !== -1) {
-                    if (historyIndex < commandHistory.length - 1) {
-                        const newIndex = historyIndex + 1;
-                        setHistoryIndex(newIndex);
-                        const newValue = commandHistory[newIndex];
-                        setValue(newValue);
-                        setCursorOffset(newValue.length);
-                    }
-                    else {
-                        setHistoryIndex(-1);
-                        setValue(tempValue);
-                        setCursorOffset(tempValue.length);
-                    }
-                }
-            }
-            else {
-                // Move cursor down one visual line
-                const currentLine = visualLines[currentVisualLineIndex];
-                const targetLine = visualLines[currentVisualLineIndex + 1];
-                const offsetInLine = cursorOffset - currentLine.start;
-                const newOffset = targetLine.start + Math.min(offsetInLine, targetLine.end - targetLine.start);
-                setCursorOffset(newOffset);
-            }
-            return;
+        setValue(newValue);
+        setCursorOffset(newOffset);
+      } else {
+        const isExitCommand = value.trim() === "/exit";
+        const isCommandIntent = detectedIntent === "command";
+        const isAllowedOffline = isConnected || isExitCommand || commandMode || isCommandIntent;
+        if (!isAllowedOffline) {
+          setRejectFlash(true);
+          setTimeout(() => setRejectFlash(false), 1e3);
+          return;
         }
-        if (key.leftArrow) {
-            if (isMac && key.meta) {
-                // Mac: Cmd+Left -> Start of line (Home)
-                setCursorOffset(0);
-                return;
-            }
-            if (key.ctrl || (!isMac && key.meta)) {
-                // Ctrl+Left (All) or Alt+Left (Win/Linux): Move word backwards
-                // Note: On Mac, Option+Left is the standard for word back, but Ink doesn't expose 'alt'.
-                // Users can use Ctrl+Left or rely on terminal mapping Option to Meta which effectively makes it key.meta
-                // BUT if key.meta is Cmd on Mac, we map that to Home.
-                // So standard Mac "Option+Left" might not work unless it sends Esc sequence or mapped to Ctrl.
-                // We allow Ctrl+Left for Mac users.
-                let newOffset = cursorOffset;
-                if (newOffset > 0) {
-                    // Skip whitespace backwards
-                    while (newOffset > 0 && /\s/.test(value[newOffset - 1])) {
-                        newOffset--;
-                    }
-                    // Skip non-whitespace backwards
-                    while (newOffset > 0 && !/\s/.test(value[newOffset - 1])) {
-                        newOffset--;
-                    }
-                    setCursorOffset(newOffset);
-                }
-                return;
-            }
-            // Standard Left Arrow
-            if (cursorOffset > 0) {
-                setCursorOffset(cursorOffset - 1);
-            }
-            return;
+        const isSlashCommand = value.trim().startsWith("/");
+        if (!commandMode && !isCommandIntent && !isSlashCommand && sessionQuotaExhausted) {
+          setRejectFlash(true);
+          setShowQuotaMessage(true);
+          setTimeout(() => {
+            setRejectFlash(false);
+            setShowQuotaMessage(false);
+          }, 3e3);
+          return;
         }
-        if (key.rightArrow) {
-            // Autocomplete Logic (Only at end of line)
-            // AI suggestion takes priority over passive suggestion
-            // Autocomplete Logic
-            const effectiveSuggestion = aiAutocompleteSuggestion || autocompleteSuggestion;
-            if (effectiveSuggestion && cursorOffset === value.length) {
-                if (key.ctrl || (isMac && key.meta)) {
-                    // Ctrl+Right (Win) or Cmd+Right (Mac): Accept FULL suggestion
-                    // (Wait, Cmd+Right is usually End of Line on Mac. We should prioritize Navigation over Autocomplete?
-                    //  Actually, if we are at end of line, End of Line does nothing. So we can use it for accept full?)
-                    //  Convention: Right Arrow accepts word. Ctrl+Right accepts full?
-                    //  On Mac, Cmd+Right is End. If at End, it's a no-op for nav.
-                    //  Let's allow Cmd+Right to accept full IF at end.
-                    setValue(effectiveSuggestion);
-                    setCursorOffset(effectiveSuggestion.length);
-                    setAutocompleteSuggestion(null);
-                    setAiAutocompleteSuggestion(null);
-                    return;
-                }
-                else {
-                    // Right: Accept NEXT WORD
-                    const remaining = effectiveSuggestion.slice(value.length);
-                    // Match next chunk of non-whitespace
-                    const match = remaining.match(/^(\s*\S+)/);
-                    if (match) {
-                        const toAdd = match[0];
-                        const newValue = value + toAdd;
-                        setValue(newValue);
-                        setCursorOffset(newValue.length);
-                        return; // Done
-                    }
-                    else if (remaining.length > 0) {
-                        const newValue = value + remaining;
-                        setValue(newValue);
-                        setCursorOffset(newValue.length);
-                        return;
-                    }
-                }
-            }
-            // Navigation Logic
-            if (isMac && key.meta) {
-                // Cmd+Right -> End of line
-                setCursorOffset(value.length);
-                return;
-            }
-            if ((!isMac && key.meta) || key.ctrl) {
-                // Alt+Right (Win) or Ctrl+Right: Word Forward
-                // (Note: Ink uses key.meta for Alt on Windows)
-                let newOffset = cursorOffset;
-                if (newOffset < value.length) {
-                    // Skip whitespace forwards
-                    while (newOffset < value.length && /\s/.test(value[newOffset])) {
-                        newOffset++;
-                    }
-                    // Skip non-whitespace forwards
-                    while (newOffset < value.length && !/\s/.test(value[newOffset])) {
-                        newOffset++;
-                    }
-                    setCursorOffset(newOffset);
-                }
-                return;
-            }
-            // Navigation Logic (if not completing)
-            if (key.ctrl || key.meta) {
-                // Ctrl+Right / Meta+Right (Option+Right): Move word forwards
-                let newOffset = cursorOffset;
-                if (newOffset < value.length) {
-                    // Skip non-whitespace forwards
-                    while (newOffset < value.length && !/\s/.test(value[newOffset])) {
-                        newOffset++;
-                    }
-                    // Skip whitespace forwards
-                    while (newOffset < value.length && /\s/.test(value[newOffset])) {
-                        newOffset++;
-                    }
-                    setCursorOffset(newOffset);
-                }
-            }
-            else if (cursorOffset < value.length) {
-                setCursorOffset(cursorOffset + 1);
-            }
-            return;
+        handleSubmit();
+      }
+      return;
+    }
+    if (key.upArrow || key.downArrow || key.leftArrow || key.rightArrow) {
+      if (selection) {
+        setSelection(null);
+        if (key.leftArrow) setCursorOffset(Math.min(selection.start, selection.end));
+        if (key.rightArrow) setCursorOffset(Math.max(selection.start, selection.end));
+        if (key.upArrow || key.downArrow) {
         }
-        // Tab Completion
-        if (key.tab && !key.shift) {
-            // Only file completion (only in command mode)
-            if (commandMode) {
-                handleTabCompletion();
-                return;
-            }
+        if (key.leftArrow || key.rightArrow) return;
+      }
+    }
+    if (key.upArrow) {
+      const width = (process.stdout.columns || 80) - 6;
+      const visualLines = getVisualLines(value, width);
+      let currentVisualLineIndex = visualLines.findIndex((line) => {
+        if (cursorOffset >= line.start && cursorOffset < line.end) return true;
+        if (cursorOffset === line.end && line.isHardEnd) return true;
+        return false;
+      });
+      if (currentVisualLineIndex === -1 && cursorOffset === value.length) {
+        currentVisualLineIndex = visualLines.length - 1;
+      }
+      if (currentVisualLineIndex <= 0) {
+        if (commandHistory.length > 0) {
+          if (historyIndex === -1) {
+            setTempValue(value);
+            const newIndex = commandHistory.length - 1;
+            setHistoryIndex(newIndex);
+            const newValue = commandHistory[newIndex];
+            setValue(newValue);
+            setCursorOffset(newValue.length);
+          } else if (historyIndex > 0) {
+            const newIndex = historyIndex - 1;
+            setHistoryIndex(newIndex);
+            const newValue = commandHistory[newIndex];
+            setValue(newValue);
+            setCursorOffset(newValue.length);
+          }
         }
-        // Regular Input
-        // Ignore control keys to prevent printing garbage (like 'v' for Ctrl+V)
-        if (input && !key.ctrl && !key.meta) {
-            pushToUndoStack();
-            // Handle paste with newlines
-            const cleanedInput = input.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
-            // Use refs to get the latest value and cursor position
-            // This prevents stale closure issues when Ink calls useInput multiple times during paste
-            const currentValue = valueRef.current;
-            const currentCursorOffset = cursorOffsetRef.current;
-            let newValue = currentValue;
-            let newOffset = currentCursorOffset;
-            if (selection) {
-                const start = Math.min(selection.start, selection.end);
-                const end = Math.max(selection.start, selection.end);
-                newValue = currentValue.slice(0, start) + cleanedInput + currentValue.slice(end);
-                newOffset = start + cleanedInput.length;
-                setSelection(null);
-            }
-            else {
-                newValue = currentValue.slice(0, currentCursorOffset) + cleanedInput + currentValue.slice(currentCursorOffset);
-                newOffset = currentCursorOffset + cleanedInput.length;
-            }
-            // Update refs immediately for subsequent paste chunks
-            valueRef.current = newValue;
-            cursorOffsetRef.current = newOffset;
+      } else {
+        const currentLine = visualLines[currentVisualLineIndex];
+        const targetLine = visualLines[currentVisualLineIndex - 1];
+        const offsetInLine = cursorOffset - currentLine.start;
+        const newOffset = targetLine.start + Math.min(offsetInLine, targetLine.end - targetLine.start);
+        setCursorOffset(newOffset);
+      }
+      return;
+    }
+    if (key.downArrow) {
+      const width = (process.stdout.columns || 80) - 6;
+      const visualLines = getVisualLines(value, width);
+      let currentVisualLineIndex = visualLines.findIndex((line) => {
+        if (cursorOffset >= line.start && cursorOffset < line.end) return true;
+        if (cursorOffset === line.end && line.isHardEnd) return true;
+        return false;
+      });
+      if (currentVisualLineIndex === -1 && cursorOffset === value.length) {
+        currentVisualLineIndex = visualLines.length - 1;
+      }
+      if (currentVisualLineIndex === visualLines.length - 1) {
+        if (historyIndex !== -1) {
+          if (historyIndex < commandHistory.length - 1) {
+            const newIndex = historyIndex + 1;
+            setHistoryIndex(newIndex);
+            const newValue = commandHistory[newIndex];
             setValue(newValue);
-            setCursorOffsetWithRef(newOffset);
-            // Reset history/completions
+            setCursorOffset(newValue.length);
+          } else {
             setHistoryIndex(-1);
-            setCompletions([]);
-            // Check for slash command autocomplete
-            if (newValue.startsWith('/') && !newValue.includes(' ')) {
-                // Main slash commands (no space yet)
-                const query = newValue.slice(1);
-                const matches = filterCommands(query);
-                if (matches.length > 0) {
-                    setSlashAutocompleteCommands(matches);
-                    setSlashAutocompleteVisible(true);
-                    setSlashAutocompleteSelectedIndex(0);
-                    setSlashAutocompleteScrollOffset(0);
-                }
-                else {
-                    setSlashAutocompleteVisible(false);
-                }
-            }
-            else if (newValue.startsWith('/mcp ')) {
-                // MCP subcommands (when user types "/mcp ")
-                const fullQuery = newValue.slice(1); // Remove leading "/", pass "mcp <subquery>" to filterCommands
-                const matches = filterCommands(fullQuery);
-                if (matches.length > 0) {
-                    setSlashAutocompleteCommands(matches);
-                    setSlashAutocompleteVisible(true);
-                    setSlashAutocompleteSelectedIndex(0);
-                    setSlashAutocompleteScrollOffset(0);
-                }
-                else {
-                    setSlashAutocompleteVisible(false);
-                }
-            }
-            else if (newValue.startsWith('/chat ')) {
-                // Chat subcommands (when user types "/chat ")
-                const fullQuery = newValue.slice(1); // Remove leading "/", pass "chat <subquery>" to filterCommands
-                const matches = filterCommands(fullQuery);
-                if (matches.length > 0) {
-                    setSlashAutocompleteCommands(matches);
-                    setSlashAutocompleteVisible(true);
-                    setSlashAutocompleteSelectedIndex(0);
-                    setSlashAutocompleteScrollOffset(0);
-                }
-                else {
-                    setSlashAutocompleteVisible(false);
-                }
-            }
-            else if (newValue.startsWith('/add-command ') || newValue.startsWith('/add-command-auto-detect ')) {
-                // Add-command subcommands (when user types "/add-command ")
-                const fullQuery = newValue.slice(1); // Remove leading "/", pass "add-command <subquery>" to filterCommands
-                const matches = filterCommands(fullQuery);
-                if (matches.length > 0) {
-                    setSlashAutocompleteCommands(matches);
-                    setSlashAutocompleteVisible(true);
-                    setSlashAutocompleteSelectedIndex(0);
-                    setSlashAutocompleteScrollOffset(0);
-                }
-                else {
-                    setSlashAutocompleteVisible(false);
-                }
-            }
-            else if (newValue.startsWith('/background-task ') || newValue.startsWith('/bkg ') || newValue.startsWith('/bg-task ')) {
-                // Background-task subcommands (when user types "/background-task ", "/bkg ", or "/bg-task ")
-                const fullQuery = newValue.slice(1); // Remove leading "/", pass "background-task <subquery>" to filterCommands
-                const matches = filterCommands(fullQuery);
-                if (matches.length > 0) {
-                    setSlashAutocompleteCommands(matches);
-                    setSlashAutocompleteVisible(true);
-                    setSlashAutocompleteSelectedIndex(0);
-                    setSlashAutocompleteScrollOffset(0);
-                }
-                else {
-                    setSlashAutocompleteVisible(false);
-                }
-            }
-            else if (newValue.startsWith('/sync ')) {
-                // Sync subcommands (when user types "/sync ")
-                const fullQuery = newValue.slice(1); // Remove leading "/", pass "sync <subquery>" to filterCommands
-                const matches = filterCommands(fullQuery);
-                if (matches.length > 0) {
-                    setSlashAutocompleteCommands(matches);
-                    setSlashAutocompleteVisible(true);
-                    setSlashAutocompleteSelectedIndex(0);
-                    setSlashAutocompleteScrollOffset(0);
-                }
-                else {
-                    setSlashAutocompleteVisible(false);
-                }
-            }
-            else if (newValue.startsWith('/models ') || newValue.startsWith('/model ')) {
-                // Models subcommands (when user types "/models " or "/model ")
-                const fullQuery = newValue.slice(1); // Remove leading "/", pass "models <subquery>" to filterCommands
-                const matches = filterCommands(fullQuery);
-                if (matches.length > 0) {
-                    setSlashAutocompleteCommands(matches);
-                    setSlashAutocompleteVisible(true);
-                    setSlashAutocompleteSelectedIndex(0);
-                    setSlashAutocompleteScrollOffset(0);
-                }
-                else {
-                    setSlashAutocompleteVisible(false);
-                }
-            }
-            else if (newValue.startsWith('/revert ')) {
-                // Checkpoint autocomplete for /revert command (on backspace)
-                const partialId = newValue.slice(8).toLowerCase(); // Remove "/revert "
-                const checkpoints = getCheckpoints ? getCheckpoints() : [];
-                if (checkpoints.length === 0) {
-                    // No checkpoints yet - show informative message
-                    setSlashAutocompleteCommands([{
-                            name: '(no checkpoints)',
-                            description: 'Ask AI a question first to create a checkpoint'
-                        }]);
-                    setSlashAutocompleteVisible(true);
-                    setSlashAutocompleteSelectedIndex(0);
-                    setSlashAutocompleteScrollOffset(0);
-                }
-                else {
-                    const matchingCheckpoints = checkpoints
-                        .filter(cp => cp.id.toLowerCase().includes(partialId) || cp.prompt.toLowerCase().includes(partialId))
-                        .slice(0, 10)
-                        .map(cp => {
-                        const truncatedPrompt = cp.prompt.length > 50 ? cp.prompt.slice(0, 50) + '...' : cp.prompt;
-                        return {
-                            name: cp.id,
-                            description: truncatedPrompt
-                        };
-                    });
-                    if (matchingCheckpoints.length > 0) {
-                        setSlashAutocompleteCommands(matchingCheckpoints);
-                        setSlashAutocompleteVisible(true);
-                        setSlashAutocompleteSelectedIndex(0);
-                        setSlashAutocompleteScrollOffset(0);
-                    }
-                    else {
-                        setSlashAutocompleteVisible(false);
-                    }
-                }
-            }
-            else if (newValue.match(/^\/workflow\s+(run|view|delete)\s+/) ||
-                newValue.match(/^\/wf\s+(run|view|delete)\s+/)) {
-                // Workflow name autocomplete (when user types "/workflow run " or similar)
-                // This MUST come before the /workflow subcommand check since it's more specific
-                const match = newValue.match(/^\/(?:workflow|wf)\s+(?:run|view|delete)\s+(.*)$/);
-                const partialName = match ? match[1].toLowerCase() : '';
-                const workflows = workflowStorage.list();
-                const matchingWorkflows = workflows
-                    .filter(wf => wf.name.toLowerCase().includes(partialName))
-                    .slice(0, 10)
-                    .map(wf => ({
-                    name: wf.name,
-                    description: wf.description || `${wf.stepCount} step${wf.stepCount !== 1 ? 's' : ''}`
-                }));
-                if (matchingWorkflows.length > 0) {
-                    setSlashAutocompleteCommands(matchingWorkflows);
-                    setSlashAutocompleteVisible(true);
-                    setSlashAutocompleteSelectedIndex(0);
-                    setSlashAutocompleteScrollOffset(0);
-                }
-                else {
-                    setSlashAutocompleteVisible(false);
-                }
-            }
-            else if (newValue.startsWith('/workflow ') || newValue.startsWith('/wf ')) {
-                // Workflow subcommands (when user types "/workflow " or "/wf ")
-                const fullQuery = newValue.slice(1); // Remove leading "/", pass "workflow <subquery>" to filterCommands
-                const matches = filterCommands(fullQuery);
-                if (matches.length > 0) {
-                    setSlashAutocompleteCommands(matches);
-                    setSlashAutocompleteVisible(true);
-                    setSlashAutocompleteSelectedIndex(0);
-                    setSlashAutocompleteScrollOffset(0);
-                }
-                else {
-                    setSlashAutocompleteVisible(false);
-                }
-            }
-            else {
-                setSlashAutocompleteVisible(false);
-            }
+            setValue(tempValue);
+            setCursorOffset(tempValue.length);
+          }
+        }
+      } else {
+        const currentLine = visualLines[currentVisualLineIndex];
+        const targetLine = visualLines[currentVisualLineIndex + 1];
+        const offsetInLine = cursorOffset - currentLine.start;
+        const newOffset = targetLine.start + Math.min(offsetInLine, targetLine.end - targetLine.start);
+        setCursorOffset(newOffset);
+      }
+      return;
+    }
+    if (key.leftArrow) {
+      if (isMac && key.meta) {
+        let newOffset = cursorOffset;
+        if (newOffset > 0) {
+          while (newOffset > 0 && /\s/.test(value[newOffset - 1])) {
+            newOffset--;
+          }
+          while (newOffset > 0 && !/\s/.test(value[newOffset - 1])) {
+            newOffset--;
+          }
+          setCursorOffset(newOffset);
+        }
+        return;
+      }
+      if (key.ctrl || !isMac && key.meta) {
+        let newOffset = cursorOffset;
+        if (newOffset > 0) {
+          while (newOffset > 0 && /\s/.test(value[newOffset - 1])) {
+            newOffset--;
+          }
+          while (newOffset > 0 && !/\s/.test(value[newOffset - 1])) {
+            newOffset--;
+          }
+          setCursorOffset(newOffset);
         }
-    }, { isActive });
-    const handleTabCompletion = async () => {
-        if (!value)
+        return;
+      }
+      if (cursorOffset > 0) {
+        setCursorOffset(cursorOffset - 1);
+      }
+      return;
+    }
+    if (key.rightArrow) {
+      const effectiveSuggestion = aiAutocompleteSuggestion || autocompleteSuggestion;
+      if (effectiveSuggestion && cursorOffset === value.length) {
+        if (key.ctrl || !isMac && key.meta) {
+          setValue(effectiveSuggestion);
+          setCursorOffset(effectiveSuggestion.length);
+          setAutocompleteSuggestion(null);
+          setAiAutocompleteSuggestion(null);
+          return;
+        } else {
+          const remaining = effectiveSuggestion.slice(value.length);
+          const match = remaining.match(/^(\s*\S+)/);
+          if (match) {
+            const toAdd = match[0];
+            const newValue = value + toAdd;
+            setValue(newValue);
+            setCursorOffset(newValue.length);
             return;
-        const words = value.split(' ');
-        const lastWord = words[words.length - 1];
-        if (completions.length > 0) {
-            const nextIndex = (completionIndex + 1) % completions.length;
-            setCompletionIndex(nextIndex);
-            words[words.length - 1] = completions[nextIndex];
-            const newValue = words.join(' ');
+          } else if (remaining.length > 0) {
+            const newValue = value + remaining;
             setValue(newValue);
             setCursorOffset(newValue.length);
             return;
+          }
         }
-        try {
-            const cwd = currentWorkingDirectory || process.cwd();
-            let searchDir = cwd;
-            let searchPattern = lastWord;
-            let dirPart = '';
-            if (lastWord.includes('/') || lastWord.includes('\\')) {
-                const lastSep = Math.max(lastWord.lastIndexOf('/'), lastWord.lastIndexOf('\\'));
-                dirPart = lastWord.substring(0, lastSep + 1);
-                searchPattern = lastWord.substring(lastSep + 1);
-                if (subshellContext && subshellContext.type !== 'local') {
-                    searchDir = dirPart.startsWith('/') ? dirPart.slice(0, -1) : cwd + '/' + dirPart.slice(0, -1);
-                }
-                else {
-                    searchDir = path.resolve(cwd, dirPart);
-                }
-            }
-            let entries;
-            if (subshellContext && subshellContext.type !== 'local' && subshellContext.handler) {
-                const dirEntries = await subshellContext.handler.listDirectory(searchDir);
-                entries = dirEntries.map(entry => ({ name: entry.name, type: entry.type }));
-            }
-            else {
-                if (!fs.existsSync(searchDir))
-                    return;
-                const fsEntries = fs.readdirSync(searchDir, { withFileTypes: true });
-                entries = fsEntries.map(entry => ({
-                    name: entry.name,
-                    type: entry.isDirectory() ? 'directory' : 'file'
-                }));
-            }
-            const matches = entries
-                .filter(entry => entry.name.toLowerCase().startsWith(searchPattern.toLowerCase()))
-                .map(entry => {
-                const separator = (subshellContext && subshellContext.type !== 'local') ? '/' : path.sep;
-                const fullPath = dirPart ? dirPart + entry.name : entry.name;
-                return entry.type === 'directory' ? fullPath + separator : fullPath;
-            })
-                .sort();
-            if (matches.length > 0) {
-                if (matches.length > 1) {
-                    setCompletions(matches);
-                    setCompletionIndex(0);
-                }
-                words[words.length - 1] = matches[0];
-                const newValue = words.join(' ');
-                setValue(newValue);
-                setCursorOffset(newValue.length);
-            }
+      }
+      if (isMac && key.meta) {
+        let newOffset = cursorOffset;
+        if (newOffset < value.length) {
+          while (newOffset < value.length && /\s/.test(value[newOffset])) {
+            newOffset++;
+          }
+          while (newOffset < value.length && !/\s/.test(value[newOffset])) {
+            newOffset++;
+          }
+          setCursorOffset(newOffset);
         }
-        catch (error) {
-            // Ignore errors
+        return;
+      }
+      if (!isMac && key.meta || key.ctrl) {
+        let newOffset = cursorOffset;
+        if (newOffset < value.length) {
+          while (newOffset < value.length && /\s/.test(value[newOffset])) {
+            newOffset++;
+          }
+          while (newOffset < value.length && !/\s/.test(value[newOffset])) {
+            newOffset++;
+          }
+          setCursorOffset(newOffset);
         }
-    };
-    const handleSubmit = () => {
-        if (!isActive)
-            return;
-        // Block submission while shell command is running - flash red
-        if (isShellRunning) {
-            setRejectFlash(true);
-            setTimeout(() => setRejectFlash(false), 1000); // Flash for 1.0 seconds
-            return;
+        return;
+      }
+      if (key.ctrl || key.meta) {
+        let newOffset = cursorOffset;
+        if (newOffset < value.length) {
+          while (newOffset < value.length && !/\s/.test(value[newOffset])) {
+            newOffset++;
+          }
+          while (newOffset < value.length && /\s/.test(value[newOffset])) {
+            newOffset++;
+          }
+          setCursorOffset(newOffset);
         }
-        const trimmedValue = value.trim();
-        if (trimmedValue) {
-            // Save to history if it was a command
-            if (commandMode) {
-                CommandHistoryManager.getInstance().addCommand(trimmedValue, currentDir, currentEnvironment);
-            }
-            // Resolve file tags (@filename -> absolute path)
-            let resolvedValue = trimmedValue;
-            if (!commandMode) {
-                const cwd = currentWorkingDirectory || process.cwd();
-                // Find all @filename patterns (@ followed by non-whitespace)
-                resolvedValue = trimmedValue.replace(/@([^\s@]+)/g, (match, fileName) => {
-                    // Check if file exists
-                    const filePath = path.resolve(cwd, fileName);
-                    if (fs.existsSync(filePath)) {
-                        return filePath;
-                    }
-                    // If file doesn't exist, keep original
-                    return match;
-                });
-            }
-            onSubmit(resolvedValue, confirmedClipboardFiles.length > 0 ? confirmedClipboardFiles : undefined);
-            setValue('');
-            setCursorOffset(0);
-            setCompletions([]);
-            setCompletionIndex(0);
-            setHistoryIndex(-1);
-            setTempValue('');
-            setUndoStack([]);
-            setRedoStack([]);
-            setSelection(null);
-            setAutocompleteSuggestion(null);
-            setConfirmedFileTags([]); // Clear confirmed tags on submit
-            setConfirmedClipboardFiles([]); // Clear confirmed clipboard files on submit
+      } else if (cursorOffset < value.length) {
+        setCursorOffset(cursorOffset + 1);
+      }
+      return;
+    }
+    if (key.tab && !key.shift) {
+      if (commandMode) {
+        handleTabCompletion();
+        return;
+      }
+    }
+    if (input && !key.ctrl && !key.meta) {
+      pushToUndoStack();
+      const cleanedInput = input.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+      const currentValue = valueRef.current;
+      const currentCursorOffset = cursorOffsetRef.current;
+      let newValue = currentValue;
+      let newOffset = currentCursorOffset;
+      if (selection) {
+        const start = Math.min(selection.start, selection.end);
+        const end = Math.max(selection.start, selection.end);
+        newValue = currentValue.slice(0, start) + cleanedInput + currentValue.slice(end);
+        newOffset = start + cleanedInput.length;
+        setSelection(null);
+      } else {
+        newValue = currentValue.slice(0, currentCursorOffset) + cleanedInput + currentValue.slice(currentCursorOffset);
+        newOffset = currentCursorOffset + cleanedInput.length;
+      }
+      valueRef.current = newValue;
+      cursorOffsetRef.current = newOffset;
+      setValue(newValue);
+      setCursorOffsetWithRef(newOffset);
+      setHistoryIndex(-1);
+      setCompletions([]);
+      updateSlashAutocomplete(newValue);
+    }
+  }, { isActive });
+  const handleTabCompletion = async () => {
+    if (!value) return;
+    const words = value.split(" ");
+    const lastWord = words[words.length - 1];
+    if (completions.length > 0) {
+      const nextIndex = (completionIndex + 1) % completions.length;
+      setCompletionIndex(nextIndex);
+      words[words.length - 1] = completions[nextIndex];
+      const newValue = words.join(" ");
+      setValue(newValue);
+      setCursorOffset(newValue.length);
+      return;
+    }
+    try {
+      const cwd = currentWorkingDirectory || process.cwd();
+      let searchDir = cwd;
+      let searchPattern = lastWord;
+      let dirPart = "";
+      if (lastWord.includes("/") || lastWord.includes("\\")) {
+        const lastSep = Math.max(lastWord.lastIndexOf("/"), lastWord.lastIndexOf("\\"));
+        dirPart = lastWord.substring(0, lastSep + 1);
+        searchPattern = lastWord.substring(lastSep + 1);
+        if (subshellContext && subshellContext.type !== "local") {
+          searchDir = dirPart.startsWith("/") ? dirPart.slice(0, -1) : cwd + "/" + dirPart.slice(0, -1);
+        } else {
+          searchDir = path.resolve(cwd, dirPart);
         }
-    };
-    // Rendering Logic with Scrolling
-    const renderInput = () => {
-        // Get terminal width for visual line calculation
-        // Account for borders (2) + padding (2) + prompt "> " (2) = 6 chars
-        const termWidth = (process.stdout.columns || 80) - 6;
-        // Use getVisualLines to properly calculate wrapped lines
-        const visualLines = getVisualLines(value, termWidth);
-        const logicalLines = value.split('\n');
-        // If empty, show placeholder
-        if (logicalLines.length === 1 && logicalLines[0] === '') {
-            return React.createElement(Text, { color: "gray" }, placeholder);
+      }
+      let entries;
+      if (subshellContext && subshellContext.type !== "local" && subshellContext.handler) {
+        const dirEntries = await subshellContext.handler.listDirectory(searchDir);
+        entries = dirEntries.map((entry) => ({ name: entry.name, type: entry.type }));
+      } else {
+        if (!fs.existsSync(searchDir)) return;
+        const fsEntries = fs.readdirSync(searchDir, { withFileTypes: true });
+        entries = fsEntries.map((entry) => ({
+          name: entry.name,
+          type: entry.isDirectory() ? "directory" : "file"
+        }));
+      }
+      const matches = entries.filter((entry) => entry.name.toLowerCase().startsWith(searchPattern.toLowerCase())).map((entry) => {
+        const separator = subshellContext && subshellContext.type !== "local" ? "/" : path.sep;
+        const fullPath = dirPart ? dirPart + entry.name : entry.name;
+        return entry.type === "directory" ? fullPath + separator : fullPath;
+      }).sort();
+      if (matches.length > 0) {
+        if (matches.length > 1) {
+          setCompletions(matches);
+          setCompletionIndex(0);
         }
-        // For rendering, we still use logical lines (split by \n) since we render character-by-character
-        // But for height calculation, we use visualLines.length
-        const lines = logicalLines;
-        // Calculate cursor line and column (based on logical lines)
-        let currentPos = 0;
-        let cursorLine = 0;
-        let cursorCol = 0;
-        for (let i = 0; i < lines.length; i++) {
-            if (currentPos + lines[i].length >= cursorOffset) {
-                cursorLine = i;
-                cursorCol = cursorOffset - currentPos;
-                break;
-            }
-            currentPos += lines[i].length + 1; // +1 for newline
+        words[words.length - 1] = matches[0];
+        const newValue = words.join(" ");
+        setValue(newValue);
+        setCursorOffset(newValue.length);
+      }
+    } catch (error) {
+    }
+  };
+  const handleSubmit = () => {
+    if (!isActive) return;
+    if (isShellRunning) {
+      setRejectFlash(true);
+      setTimeout(() => setRejectFlash(false), 1e3);
+      return;
+    }
+    const trimmedValue = value.trim();
+    if (trimmedValue) {
+      if (commandMode) {
+        CommandHistoryManager.getInstance().addCommand(trimmedValue, currentDir, currentEnvironment);
+      }
+      onSubmit(trimmedValue, confirmedClipboardFiles.length > 0 ? confirmedClipboardFiles : void 0);
+      setValue("");
+      setCursorOffset(0);
+      setCompletions([]);
+      setCompletionIndex(0);
+      setHistoryIndex(-1);
+      setTempValue("");
+      setUndoStack([]);
+      setRedoStack([]);
+      setSelection(null);
+      setAutocompleteSuggestion(null);
+      setConfirmedFileTags([]);
+      setConfirmedClipboardFiles([]);
+    }
+  };
+  const renderInput = () => {
+    const effectivePlaceholder = backgroundMode ? "Run commands in the background" : commandMode ? "Run a command" : placeholder;
+    const termWidth = (process.stdout.columns || 80) - 6;
+    const visualLines = getVisualLines(value, termWidth);
+    const logicalLines = value.split("\n");
+    if (logicalLines.length === 1 && logicalLines[0] === "") {
+      return /* @__PURE__ */ React.createElement(Text, { color: "gray" }, effectivePlaceholder);
+    }
+    const lines = logicalLines;
+    let currentPos = 0;
+    let cursorLine = 0;
+    let cursorCol = 0;
+    for (let i = 0; i < lines.length; i++) {
+      if (currentPos + lines[i].length >= cursorOffset) {
+        cursorLine = i;
+        cursorCol = cursorOffset - currentPos;
+        break;
+      }
+      currentPos += lines[i].length + 1;
+    }
+    if (cursorOffset === value.length && lines.length > 0) {
+      cursorLine = lines.length - 1;
+      cursorCol = lines[lines.length - 1].length;
+    }
+    let cursorVisualLine = 0;
+    for (let i = 0; i < visualLines.length; i++) {
+      if (cursorOffset >= visualLines[i].start && cursorOffset <= visualLines[i].end) {
+        cursorVisualLine = i;
+        break;
+      }
+    }
+    if (cursorOffset === value.length && visualLines.length > 0) {
+      cursorVisualLine = visualLines.length - 1;
+    }
+    const totalVisualLines = visualLines.length;
+    let startLine = 0;
+    if (totalVisualLines > MAX_VISIBLE_LINES) {
+      if (cursorVisualLine < MAX_VISIBLE_LINES) {
+        startLine = 0;
+      } else {
+        startLine = cursorVisualLine - MAX_VISIBLE_LINES + 1;
+      }
+    }
+    const endLine = Math.min(startLine + MAX_VISIBLE_LINES, totalVisualLines);
+    const visibleVisualLines = visualLines.slice(startLine, endLine);
+    return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", flexGrow: 1 }, startLine > 0 && /* @__PURE__ */ React.createElement(Text, { color: "gray" }, "\u2191 ..."), visibleVisualLines.map((vLine, idx) => {
+      const actualVisualLineIndex = startLine + idx;
+      const lineText = value.slice(vLine.start, vLine.end);
+      const lineStartPos = vLine.start;
+      const isCursorLine = cursorOffset >= vLine.start && cursorOffset <= vLine.end;
+      const cursorCol2 = isCursorLine ? cursorOffset - vLine.start : -1;
+      const isLastLine = actualVisualLineIndex === totalVisualLines - 1;
+      if (!isActive) {
+        if (lineText.length === 0) {
+          return /* @__PURE__ */ React.createElement(Text, { key: idx }, " ");
         }
-        // Edge case: cursor at very end of content
-        if (cursorOffset === value.length && lines.length > 0) {
-            cursorLine = lines.length - 1;
-            cursorCol = lines[lines.length - 1].length;
+        return /* @__PURE__ */ React.createElement(Text, { key: idx }, lineText);
+      }
+      const chars = lineText.split("");
+      const renderedChars = chars.map((char, charIdx) => {
+        const absPos = lineStartPos + charIdx;
+        const isSelected = selection && absPos >= Math.min(selection.start, selection.end) && absPos < Math.max(selection.start, selection.end);
+        let activeFileTagEnd = activeFileTagStart !== null ? activeFileTagStart : 0;
+        if (activeFileTagStart !== null) {
+          for (let j = activeFileTagStart; j < value.length && j < cursorOffset; j++) {
+            if (/[\s\n]/.test(value[j])) {
+              break;
+            }
+            activeFileTagEnd = j + 1;
+          }
         }
-        // For scrolling, calculate which VISUAL line the cursor is on
-        let cursorVisualLine = 0;
-        for (let i = 0; i < visualLines.length; i++) {
-            if (cursorOffset >= visualLines[i].start && cursorOffset <= visualLines[i].end) {
-                cursorVisualLine = i;
-                break;
+        const isInActiveFileTag = activeFileTagStart !== null && absPos >= activeFileTagStart && absPos < activeFileTagEnd;
+        let isInConfirmedFileTag = false;
+        if (!commandMode) {
+          const fileTagRegex = /(?:^|[\s\n])(@[^\s@]+)/g;
+          let match;
+          while ((match = fileTagRegex.exec(value)) !== null) {
+            const fullMatch = match[0];
+            const tagContent = match[1];
+            const tagStart = match.index + (fullMatch.length - tagContent.length);
+            const tagEnd = tagStart + tagContent.length;
+            if (activeFileTagStart !== null && tagStart === activeFileTagStart) {
+              continue;
+            }
+            if (absPos >= tagStart && absPos < tagEnd) {
+              isInConfirmedFileTag = true;
+              break;
             }
+          }
         }
-        // Handle cursor at very end
-        if (cursorOffset === value.length && visualLines.length > 0) {
-            cursorVisualLine = visualLines.length - 1;
+        const isCursor = isCursorLine && charIdx === cursorCol2;
+        if (isCursor) {
+          return /* @__PURE__ */ React.createElement(Text, { key: charIdx, inverse: true, color: isSelected ? "yellow" : void 0 }, char);
         }
-        // Calculate visible range using VISUAL lines count for proper scrolling
-        const totalVisualLines = visualLines.length;
-        let startLine = 0;
-        if (totalVisualLines > MAX_VISIBLE_LINES) {
-            // Use visual line position for scrolling calculation
-            if (cursorVisualLine < MAX_VISIBLE_LINES) {
-                startLine = 0;
-            }
-            else {
-                startLine = cursorVisualLine - MAX_VISIBLE_LINES + 1;
-            }
+        if (isSelected) {
+          return /* @__PURE__ */ React.createElement(Text, { key: charIdx, backgroundColor: "white", color: "black" }, char);
         }
-        const endLine = Math.min(startLine + MAX_VISIBLE_LINES, totalVisualLines);
-        // Get the text content for each visual line
-        const visibleVisualLines = visualLines.slice(startLine, endLine);
-        return (React.createElement(Box, { flexDirection: "column", flexGrow: 1 },
-            startLine > 0 && React.createElement(Text, { color: "gray" }, "\u2191 ..."),
-            visibleVisualLines.map((vLine, idx) => {
-                const actualVisualLineIndex = startLine + idx;
-                // Extract the text content for this visual line
-                const lineText = value.slice(vLine.start, vLine.end);
-                const lineStartPos = vLine.start;
-                // Determine if cursor is on this visual line
-                const isCursorLine = cursorOffset >= vLine.start && cursorOffset <= vLine.end;
-                const cursorCol = isCursorLine ? cursorOffset - vLine.start : -1;
-                // Is this the last visual line?
-                const isLastLine = actualVisualLineIndex === totalVisualLines - 1;
-                if (!isActive) {
-                    if (lineText.length === 0) {
-                        return React.createElement(Text, { key: idx }, " ");
-                    }
-                    return React.createElement(Text, { key: idx }, lineText);
-                }
-                // Render with selection and cursor
-                const chars = lineText.split('');
-                const renderedChars = chars.map((char, charIdx) => {
-                    const absPos = lineStartPos + charIdx;
-                    const isSelected = selection &&
-                        absPos >= Math.min(selection.start, selection.end) &&
-                        absPos < Math.max(selection.start, selection.end);
-                    // Check if this character is part of an active file tag (being typed after @)
-                    let activeFileTagEnd = activeFileTagStart !== null ? activeFileTagStart : 0;
-                    if (activeFileTagStart !== null) {
-                        for (let j = activeFileTagStart; j < value.length && j < cursorOffset; j++) {
-                            if (/[\s\n]/.test(value[j])) {
-                                break;
-                            }
-                            activeFileTagEnd = j + 1;
-                        }
-                    }
-                    const isInActiveFileTag = activeFileTagStart !== null &&
-                        absPos >= activeFileTagStart &&
-                        absPos < activeFileTagEnd;
-                    // Check if this character is part of a confirmed file tag
-                    let isInConfirmedFileTag = false;
-                    if (!commandMode) {
-                        const fileTagRegex = /(?:^|[\s\n])(@[^\s@]+)/g;
-                        let match;
-                        while ((match = fileTagRegex.exec(value)) !== null) {
-                            const fullMatch = match[0];
-                            const tagContent = match[1];
-                            const tagStart = match.index + (fullMatch.length - tagContent.length);
-                            const tagEnd = tagStart + tagContent.length;
-                            if (activeFileTagStart !== null && tagStart === activeFileTagStart) {
-                                continue;
-                            }
-                            if (absPos >= tagStart && absPos < tagEnd) {
-                                isInConfirmedFileTag = true;
-                                break;
-                            }
-                        }
-                    }
-                    const isCursor = isCursorLine && charIdx === cursorCol;
-                    if (isCursor) {
-                        return React.createElement(Text, { key: charIdx, inverse: true, color: isSelected ? "yellow" : undefined }, char);
-                    }
-                    if (isSelected) {
-                        return React.createElement(Text, { key: charIdx, backgroundColor: "white", color: "black" }, char);
-                    }
-                    // Highlight file tags with cyan color
-                    if (isInConfirmedFileTag || isInActiveFileTag) {
-                        return React.createElement(Text, { key: charIdx, color: "#00ccff", bold: true }, char);
-                    }
-                    return React.createElement(Text, { key: charIdx }, char);
-                });
-                // Handle cursor at end of line
-                if (isCursorLine && cursorCol === lineText.length) {
-                    renderedChars.push(React.createElement(Text, { key: "cursor", inverse: true }, " "));
-                }
-                // Render Autocomplete Ghost Text
-                // Only on the last line, if suggestion exists and matches start
-                // AI suggestion takes priority over passive suggestion
-                const effectiveSuggestion = aiAutocompleteSuggestion || autocompleteSuggestion;
-                if (isLastLine && effectiveSuggestion && effectiveSuggestion.startsWith(value)) {
-                    const suffix = effectiveSuggestion.slice(value.length);
-                    if (suffix) {
-                        // Use slightly different color for AI suggestion to differentiate
-                        const ghostColor = aiAutocompleteSuggestion ? '#888888' : 'gray';
-                        renderedChars.push(React.createElement(Text, { key: "ghost", color: ghostColor }, suffix));
-                    }
-                }
-                if (renderedChars.length === 0) {
-                    return React.createElement(Text, { key: idx }, " ");
-                }
-                return React.createElement(Text, { key: idx }, renderedChars);
-            }),
-            endLine < totalVisualLines && React.createElement(Text, { color: "gray" }, "\u2193 ...")));
-    };
-    return (React.createElement(Box, { flexDirection: "column", borderStyle: "round", borderColor: rejectFlash ? "#ff3366" :
-            contextLimitReached ? "#ff3366" : // Red when context limit reached
-                sessionQuotaExhausted ? "#ff3366" : // Red when quota exhausted
-                    backgroundMode ? "#9966ff" :
-                        commandMode ? "#00cc66" :
-                            "#257aa5ff", paddingX: 1, paddingY: 0, width: "100%" },
-        React.createElement(Box, { marginY: 1, justifyContent: "space-between", width: "100%" },
-            React.createElement(Box, null,
-                subshellContext && subshellContext.type !== 'local' && (React.createElement(Breadcrumbs, { context: subshellContext, stack: subshellContextStack })),
-                React.createElement(Text, { color: "#666666" }, "CWD: "),
-                React.createElement(Text, { color: "#00ccff", bold: true }, currentDir)),
-            React.createElement(Box, null,
-                model && !commandMode && !backgroundMode && (React.createElement(Box, { marginRight: 1 },
-                    React.createElement(Text, { color: "#666666" }, "Model: "),
-                    React.createElement(Text, { color: "#00ccff" }, model))),
-                React.createElement(Box, null,
-                    React.createElement(Text, { color: "#666666" }, "Mode: "),
-                    isAutoMode ? (React.createElement(Text, null,
-                        React.createElement(Text, { color: "#00ccff", bold: true }, "Auto ["),
-                        detectedIntent === 'command' ? (React.createElement(Text, { color: "#00cc66", bold: true }, "Terminal")) : (React.createElement(Text, { color: "#00ccff" }, "Agent")),
-                        React.createElement(Text, { color: "#00ccff", bold: true }, "]"))) : backgroundMode ? (React.createElement(Text, { color: "#9966ff", bold: true }, "Background")) : commandMode ? (React.createElement(Text, { color: "#00cc66", bold: true }, "Terminal")) : planMode ? (React.createElement(Text, { color: "#ffaa00", bold: true }, "Plan")) : (React.createElement(Text, { color: "#00ccff" }, "Agent"))))),
-        confirmedClipboardFiles.length > 0 && (React.createElement(Box, { marginBottom: 1, flexDirection: "row", flexWrap: "wrap", gap: 1 }, confirmedClipboardFiles.map((file, index) => (React.createElement(Box, { key: file.id, borderStyle: "round", borderColor: "#ff69b4", paddingX: 1 },
-            React.createElement(Text, { color: "#ff69b4", bold: true },
-                "file_",
-                index + 1)))))),
-        showQuotaMessage && (React.createElement(Box, { justifyContent: "flex-end", marginBottom: 1 },
-            React.createElement(Text, { color: "#ff3366", bold: true },
-                "Session quota reached. Try again in ",
-                sessionQuotaTimeRemaining))),
-        contextLimitReached && (React.createElement(Box, { justifyContent: "flex-end", marginBottom: 1 },
-            React.createElement(Text, { color: "#ff3366", bold: true }, "\u26A0\uFE0F Context limit reached. Use /new to start a fresh chat."))),
-        React.createElement(Box, { flexDirection: "row", width: "100%" },
-            React.createElement(Text, { color: "#666666" }, "> "),
-            renderInput()),
-        React.createElement(Box, { marginY: 1, justifyContent: "space-between", width: "100%" },
-            React.createElement(Text, { color: "#666666", dimColor: true }, isAutoMode ? ('Ctrl+D to switch modes • Ctrl+T to auto-approve') : backgroundMode ? ('Ctrl+D to switch modes • Commands run in background') : commandMode ? ('Ctrl+D to switch modes • Tab for autocomplete') : ('Ctrl+D to switch modes • Ctrl+T to auto-approve')),
-            React.createElement(Box, { gap: 1 },
-                subAgentCount > 0 && (React.createElement(Text, { color: "#00ccff", bold: true },
-                    "[sub-agent: ",
-                    subAgentCount,
-                    "]")),
-                backgroundTaskCount > 0 && (React.createElement(Text, { color: "#9966ff", bold: true },
-                    "[bkg tasks: ",
-                    backgroundTaskCount,
-                    "]")),
-                !commandMode && !backgroundMode && planMode && (React.createElement(Text, { color: "#ffaa00", bold: true }, "[PLANNING]")),
-                !commandMode && !backgroundMode && autoAcceptMode ? (React.createElement(Text, { color: "#00cc66", bold: true }, "[AUTO-ACCEPT: ON]")) : !commandMode && !backgroundMode ? (React.createElement(Text, { color: "#666666", dimColor: true }, "[AUTO-ACCEPT: OFF]")) : null,
-                !commandMode && !backgroundMode && (React.createElement(Box, { marginLeft: 1 },
-                    React.createElement(ContextWindowIndicator, { currentTokens: currentTokens, maxTokens: maxTokens }))))),
-        slashAutocompleteVisible && slashMaxVisibleItems > 0 && (React.createElement(SlashCommandAutocomplete, { commands: slashAutocompleteCommands, selectedIndex: slashAutocompleteSelectedIndex, maxVisibleItems: slashMaxVisibleItems, scrollOffset: slashAutocompleteScrollOffset })),
-        fileTagAutocompleteVisible && (React.createElement(FileTagAutocomplete, { files: fileTagSuggestions, selectedIndex: fileTagSelectedIndex }))));
+        if (isInConfirmedFileTag || isInActiveFileTag) {
+          return /* @__PURE__ */ React.createElement(Text, { key: charIdx, color: "#00ccff", bold: true }, char);
+        }
+        return /* @__PURE__ */ React.createElement(Text, { key: charIdx }, char);
+      });
+      if (isCursorLine && cursorCol2 === lineText.length) {
+        renderedChars.push(/* @__PURE__ */ React.createElement(Text, { key: "cursor", inverse: true }, " "));
+      }
+      const effectiveSuggestion = aiAutocompleteSuggestion || autocompleteSuggestion;
+      if (isLastLine && effectiveSuggestion && effectiveSuggestion.startsWith(value)) {
+        const suffix = effectiveSuggestion.slice(value.length);
+        if (suffix) {
+          const ghostColor = aiAutocompleteSuggestion ? "#888888" : "gray";
+          renderedChars.push(/* @__PURE__ */ React.createElement(Text, { key: "ghost", color: ghostColor }, suffix));
+        }
+      }
+      if (renderedChars.length === 0) {
+        return /* @__PURE__ */ React.createElement(Text, { key: idx }, " ");
+      }
+      return /* @__PURE__ */ React.createElement(Text, { key: idx }, renderedChars);
+    }), endLine < totalVisualLines && /* @__PURE__ */ React.createElement(Text, { color: "gray" }, "\u2193 ..."));
+  };
+  return /* @__PURE__ */ React.createElement(
+    Box,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: rejectFlash ? "#ff3366" : sessionQuotaExhausted ? "#ff3366" : (
+        // Red when quota exhausted
+        backgroundMode ? "#9966ff" : commandMode ? "#00cc66" : "#257aa5ff"
+      ),
+      paddingX: 1,
+      paddingY: 0,
+      width: "100%"
+    },
+    /* @__PURE__ */ React.createElement(Box, { marginY: 1, justifyContent: "space-between", width: "100%" }, /* @__PURE__ */ React.createElement(Box, { flexShrink: 1, minWidth: 0, flexDirection: "row" }, subshellContext && subshellContext.type !== "local" && /* @__PURE__ */ React.createElement(Breadcrumbs, { context: subshellContext, stack: subshellContextStack }), /* @__PURE__ */ React.createElement(Text, { color: "#666666" }, "CWD: "), /* @__PURE__ */ React.createElement(Text, { color: "#00ccff", bold: true, wrap: "truncate-start" }, currentDir), gitDiffStats && (gitDiffStats.additions > 0 || gitDiffStats.deletions > 0) && /* @__PURE__ */ React.createElement(
+      GitDiffBreadcrumb,
+      {
+        additions: gitDiffStats.additions,
+        deletions: gitDiffStats.deletions
+      }
+    )), /* @__PURE__ */ React.createElement(Box, { flexShrink: 0 }, model && !commandMode && !backgroundMode && /* @__PURE__ */ React.createElement(Box, { marginRight: 1 }, /* @__PURE__ */ React.createElement(Text, { color: "#666666" }, "Model: "), /* @__PURE__ */ React.createElement(Text, { color: "#00ccff" }, model)), /* @__PURE__ */ React.createElement(Box, null, showModeIndicator && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Text, { color: "#666666" }, "Mode: "), isAutoMode ? /* @__PURE__ */ React.createElement(Text, null, /* @__PURE__ */ React.createElement(Text, { color: "#00ccff", bold: true }, "Auto ["), detectedIntent === "command" ? /* @__PURE__ */ React.createElement(Text, { color: "#00cc66", bold: true }, "Terminal") : /* @__PURE__ */ React.createElement(Text, { color: "#00ccff" }, "Agent"), /* @__PURE__ */ React.createElement(Text, { color: "#00ccff", bold: true }, "]")) : backgroundMode ? /* @__PURE__ */ React.createElement(Text, { color: "#9966ff", bold: true }, "Background") : commandMode ? /* @__PURE__ */ React.createElement(Text, { color: "#00cc66", bold: true }, "Terminal") : planMode ? /* @__PURE__ */ React.createElement(Text, { color: "#ffaa00", bold: true }, "Plan") : /* @__PURE__ */ React.createElement(Text, { color: "#00ccff" }, "Agent"))))),
+    confirmedClipboardFiles.length > 0 && /* @__PURE__ */ React.createElement(Box, { marginBottom: 1, flexDirection: "row", flexWrap: "wrap", gap: 1 }, confirmedClipboardFiles.map((file, index) => /* @__PURE__ */ React.createElement(
+      Box,
+      {
+        key: file.id,
+        borderStyle: "round",
+        borderColor: "#ff69b4",
+        paddingX: 1
+      },
+      /* @__PURE__ */ React.createElement(Text, { color: "#ff69b4", bold: true }, "file_", index + 1)
+    ))),
+    showQuotaMessage && /* @__PURE__ */ React.createElement(Box, { justifyContent: "flex-end", marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { color: "#ff3366", bold: true }, "Session quota reached. Try again in ", sessionQuotaTimeRemaining)),
+    /* @__PURE__ */ React.createElement(Box, { flexDirection: "row", width: "100%" }, /* @__PURE__ */ React.createElement(Text, { color: "#666666" }, "> "), renderInput()),
+    /* @__PURE__ */ React.createElement(Box, { marginY: 1, justifyContent: "space-between", width: "100%" }, /* @__PURE__ */ React.createElement(Text, { color: "#666666", dimColor: true }, isAutoMode ? showBottomHints ? "Ctrl+D to switch modes \u2022 Ctrl+T to auto-approve" : "Ctrl+D to switch modes" : backgroundMode ? "Ctrl+D to switch modes \u2022 Commands run in background" : commandMode ? "Ctrl+D to switch modes \u2022 Tab for autocomplete" : showBottomHints ? "Ctrl+D to switch modes \u2022 Ctrl+T to auto-approve" : "Ctrl+D to switch modes"), /* @__PURE__ */ React.createElement(Box, { gap: 1 }, subAgentCount > 0 && /* @__PURE__ */ React.createElement(Text, { color: "#00ccff", bold: true }, "[sub-agent: ", subAgentCount, "]"), backgroundTaskCount > 0 && /* @__PURE__ */ React.createElement(Text, { color: "#9966ff", bold: true }, "[bkg tasks: ", backgroundTaskCount, "]"), !commandMode && !backgroundMode && planMode && /* @__PURE__ */ React.createElement(Text, { color: "#ffaa00", bold: true }, "[PLANNING]"), !commandMode && !backgroundMode && autoAcceptMode ? /* @__PURE__ */ React.createElement(Text, { color: "#00cc66", bold: true }, "[AUTO-ACCEPT: ON]") : !commandMode && !backgroundMode ? /* @__PURE__ */ React.createElement(Text, { color: "#666666", dimColor: true }, "[AUTO-ACCEPT: OFF]") : null, !commandMode && !backgroundMode && /* @__PURE__ */ React.createElement(Box, { marginLeft: 1 }, /* @__PURE__ */ React.createElement(
+      ContextWindowIndicator,
+      {
+        currentTokens,
+        maxTokens
+      }
+    )))),
+    slashAutocompleteVisible && slashMaxVisibleItems > 0 && /* @__PURE__ */ React.createElement(
+      SlashCommandAutocomplete,
+      {
+        commands: slashAutocompleteCommands,
+        selectedIndex: slashAutocompleteSelectedIndex,
+        maxVisibleItems: slashMaxVisibleItems,
+        scrollOffset: slashAutocompleteScrollOffset
+      }
+    ),
+    fileTagAutocompleteVisible && /* @__PURE__ */ React.createElement(
+      FileTagAutocomplete,
+      {
+        files: fileTagSuggestions,
+        selectedIndex: fileTagSelectedIndex
+      }
+    )
+  );
 });
+export {
+  InputBox
+};
 //# sourceMappingURL=InputBox.js.map