@defai.digital/ax-cli 3.8.1 → 3.8.3

package/dist/ui/hooks/use-enhanced-input.js

@@ -21,19 +21,43 @@ function isIncompleteInput(text, smartDetection) {
             '[': 0,
             '{': 0,
         };
+        // BUG FIX: Track string/template literal state to avoid counting brackets inside strings
+        let inSingleQuote = false;
+        let inDoubleQuote = false;
+        let inBacktick = false;
+        let prevChar = '';
         for (const char of trimmed) {
-            if (char === '(')
-                brackets['(']++;
-            else if (char === ')')
-                brackets['(']--;
-            else if (char === '[')
-                brackets['[']++;
-            else if (char === ']')
-                brackets['[']--;
-            else if (char === '{')
-                brackets['{']++;
-            else if (char === '}')
-                brackets['{']--;
+            // Handle escape sequences - skip if previous char was backslash
+            if (prevChar === '\\') {
+                prevChar = ''; // Reset to avoid double-escape issues
+                continue;
+            }
+            // Track string state
+            if (char === "'" && !inDoubleQuote && !inBacktick) {
+                inSingleQuote = !inSingleQuote;
+            }
+            else if (char === '"' && !inSingleQuote && !inBacktick) {
+                inDoubleQuote = !inDoubleQuote;
+            }
+            else if (char === '`' && !inSingleQuote && !inDoubleQuote) {
+                inBacktick = !inBacktick;
+            }
+            // Only count brackets outside of strings
+            if (!inSingleQuote && !inDoubleQuote && !inBacktick) {
+                if (char === '(')
+                    brackets['(']++;
+                else if (char === ')')
+                    brackets['(']--;
+                else if (char === '[')
+                    brackets['[']++;
+                else if (char === ']')
+                    brackets['[']--;
+                else if (char === '{')
+                    brackets['{']++;
+                else if (char === '}')
+                    brackets['{']--;
+            }
+            prevChar = char;
         }
         // If any bracket is unclosed, input is incomplete
         if (brackets['('] > 0 || brackets['['] > 0 || brackets['{'] > 0) {
@@ -42,14 +66,37 @@ function isIncompleteInput(text, smartDetection) {
     }
     // Check for trailing operators
     if (smartDetection.checkOperators) {
+        // BUG FIX: Order operators by length (longest first) to avoid false positives
+        // e.g., "===" should be checked before "==" and "="
         const trailingOperators = [
-            '+', '-', '*', '/', '%', '=', '==', '===', '!=', '!==',
-            '<', '>', '<=', '>=', '&&', '||', '&', '|', '^',
-            '?', ':', ',', '.', '..', '...', '=>',
+            '===', '!==', '...', '&&', '||', '==', '!=', '<=', '>=', '=>',
+            '..', '+', '-', '*', '/', '%', '=', '<', '>', '&', '|', '^',
+            '?', ':', ',', '.',
         ];
-        for (const op of trailingOperators) {
-            if (trimmed.endsWith(op)) {
-                return true;
+        // BUG FIX: Don't check for trailing operators if line ends inside a string
+        // Check if we're inside an unclosed string by counting unescaped quotes
+        const lastLine = trimmed.split('\n').pop() || '';
+        let inSingleQuote = false;
+        let inDoubleQuote = false;
+        let inBacktick = false;
+        let prevChar = '';
+        for (const char of lastLine) {
+            if (prevChar !== '\\') {
+                if (char === "'" && !inDoubleQuote && !inBacktick)
+                    inSingleQuote = !inSingleQuote;
+                else if (char === '"' && !inSingleQuote && !inBacktick)
+                    inDoubleQuote = !inDoubleQuote;
+                else if (char === '`' && !inSingleQuote && !inDoubleQuote)
+                    inBacktick = !inBacktick;
+            }
+            prevChar = char === '\\' && prevChar !== '\\' ? '\\' : '';
+        }
+        // Only check for trailing operators if we're not inside a string
+        if (!inSingleQuote && !inDoubleQuote && !inBacktick) {
+            for (const op of trailingOperators) {
+                if (trimmed.endsWith(op)) {
+                    return true;
+                }
             }
         }
     }
@@ -63,15 +110,56 @@ function isIncompleteInput(text, smartDetection) {
         ];
         // Check if line ends with a statement keyword (potentially incomplete)
         const lastLine = trimmed.split('\n').pop() || '';
-        const words = lastLine.trim().split(/\s+/);
-        const lastWord = words[words.length - 1];
-        if (incompleteKeywords.includes(lastWord)) {
-            return true;
+        // BUG FIX: Check if we're inside a string before checking keywords
+        let inSingleQuote = false;
+        let inDoubleQuote = false;
+        let inBacktick = false;
+        let prevChar = '';
+        for (const char of lastLine) {
+            if (prevChar !== '\\') {
+                if (char === "'" && !inDoubleQuote && !inBacktick)
+                    inSingleQuote = !inSingleQuote;
+                else if (char === '"' && !inSingleQuote && !inBacktick)
+                    inDoubleQuote = !inDoubleQuote;
+                else if (char === '`' && !inSingleQuote && !inDoubleQuote)
+                    inBacktick = !inBacktick;
+            }
+            prevChar = char === '\\' && prevChar !== '\\' ? '\\' : '';
         }
-        // Check for statement keywords at start of last line without closing
-        const firstWord = words[0];
-        if (incompleteKeywords.includes(firstWord) && !lastLine.includes('{') && !lastLine.includes(';')) {
-            return true;
+        // Only check keywords if we're not inside a string
+        if (!inSingleQuote && !inDoubleQuote && !inBacktick) {
+            const words = lastLine.trim().split(/\s+/);
+            const lastWord = words[words.length - 1];
+            if (incompleteKeywords.includes(lastWord)) {
+                return true;
+            }
+            // Check for statement keywords at start of last line without closing
+            // BUG FIX: Check for { and ; outside of strings, not just anywhere in line
+            const firstWord = words[0];
+            if (incompleteKeywords.includes(firstWord)) {
+                // Check if { or ; appears outside strings
+                let hasClosingOutsideString = false;
+                let inSQ = false, inDQ = false, inBT = false;
+                let prev = '';
+                for (const c of lastLine) {
+                    if (prev !== '\\') {
+                        if (c === "'" && !inDQ && !inBT)
+                            inSQ = !inSQ;
+                        else if (c === '"' && !inSQ && !inBT)
+                            inDQ = !inDQ;
+                        else if (c === '`' && !inSQ && !inDQ)
+                            inBT = !inBT;
+                    }
+                    if (!inSQ && !inDQ && !inBT && (c === '{' || c === ';')) {
+                        hasClosingOutsideString = true;
+                        break;
+                    }
+                    prev = c === '\\' && prev !== '\\' ? '\\' : '';
+                }
+                if (!hasClosingOutsideString) {
+                    return true;
+                }
+            }
         }
     }
     return false;
@@ -82,6 +170,9 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
     const [pastedBlocks, setPastedBlocks] = useState([]);
     // BUG FIX: Use ref instead of state to prevent race conditions with concurrent pastes
     const pasteCounterRef = useRef(0);
+    // BUG FIX: Use ref for pastedBlocks to ensure expandPlaceholdersForSubmit always has current value
+    // This prevents race conditions when paste + submit happen rapidly before React re-renders
+    const pastedBlocksRef = useRef(pastedBlocks);
     const [currentBlockAtCursor, setCurrentBlockAtCursor] = useState(null);
     const [isPasting, setIsPasting] = useState(false); // v3.8.0: Track paste accumulation state
     // Load input configuration from settings (Phase 1)  // FIX: Use RequiredInputSettings type to match getInputConfig() return type
@@ -100,33 +191,46 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
     const fallbackPasteBufferRef = useRef('');
     const fallbackPasteTimeoutRef = useRef(null);
     const fallbackPasteLastChunkTimeRef = useRef(0); // Track when last chunk arrived
+    // BUG FIX: Use refs for callbacks used in setTimeout to avoid stale closures
+    const onLargePasteRef = useRef(onLargePaste);
+    const onPasteTruncatedRef = useRef(onPasteTruncated);
+    // BUG FIX: Track mounted state for async operations
+    const isMountedRef = useRef(true);
     // Keep ref in sync with prop to avoid stale closure
     isMultilineRef.current = multiline;
+    onLargePasteRef.current = onLargePaste;
+    onPasteTruncatedRef.current = onPasteTruncated;
     const { addToHistory, navigateHistory, resetHistory, setOriginalInput, isNavigatingHistory, } = useInputHistory(projectDir);
     const setInput = useCallback((text) => {
         setInputState(text);
         // Use functional update to get the current cursor position, avoiding stale closure
-        setCursorPositionState((currentCursor) => Math.min(text.length, currentCursor));
+        const newCursor = Math.min(text.length, cursorPositionRef.current);
+        setCursorPositionState(newCursor);
         if (!isNavigatingHistory()) {
             setOriginalInput(text);
         }
+        // BUG FIX: Clear pasted blocks when input is completely replaced
+        // The old block metadata is no longer valid for the new text
+        pastedBlocksRef.current = [];
+        setPastedBlocks([]);
+        // BUG FIX: Synchronously update refs to prevent stale reads
+        inputRef.current = text;
+        cursorPositionRef.current = newCursor;
     }, [isNavigatingHistory, setOriginalInput]);
     const setCursorPosition = useCallback((position) => {
-        // Set cursor position with bounds checking based on current input length
-        // Use separate state reads to avoid nested state updates
-        setInputState((currentInput) => {
-            const boundedPosition = Math.max(0, Math.min(currentInput.length, position));
-            // Schedule cursor update after current state update completes
-            queueMicrotask(() => {
-                setCursorPositionState(boundedPosition);
-            });
-            return currentInput; // No change to input, just accessing for bounds check
-        });
+        // BUG FIX: Use inputRef for bounds checking instead of nested state update with queueMicrotask
+        // This avoids race conditions where input changes between scheduling and execution
+        const currentInputLength = inputRef.current.length;
+        const boundedPosition = Math.max(0, Math.min(currentInputLength, position));
+        setCursorPositionState(boundedPosition);
+        // BUG FIX: Synchronously update ref to prevent stale reads
+        cursorPositionRef.current = boundedPosition;
     }, []);
     const clearInput = useCallback(() => {
         setInputState("");
         setCursorPositionState(0);
         setOriginalInput("");
+        pastedBlocksRef.current = [];
         setPastedBlocks([]);
         pasteCounterRef.current = 0; // BUG FIX: Reset counter ref
         setIsPasting(false); // v3.8.0: Reset paste state
@@ -139,13 +243,24 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
             clearTimeout(fallbackPasteTimeoutRef.current);
             fallbackPasteTimeoutRef.current = null;
         }
+        // BUG FIX: Synchronously update refs to prevent stale reads
+        inputRef.current = '';
+        cursorPositionRef.current = 0;
     }, [setOriginalInput]);
     const insertAtCursor = useCallback((text) => {
-        const result = insertText(input, cursorPosition, text);
+        // BUG FIX: Use refs to get CURRENT values, avoiding stale closures
+        // This ensures insertAtCursor sees the latest input/cursor even if called
+        // rapidly after other state updates
+        const currentInput = inputRef.current;
+        const currentCursor = cursorPositionRef.current;
+        const result = insertText(currentInput, currentCursor, text);
         setInputState(result.text);
         setCursorPositionState(result.position);
         setOriginalInput(result.text);
-    }, [input, cursorPosition, setOriginalInput]);
+        // BUG FIX: Synchronously update refs to prevent stale reads
+        inputRef.current = result.text;
+        cursorPositionRef.current = result.position;
+    }, [setOriginalInput]);
     // Handle paste completion
     // Note: No timeout or accumulation needed - Ink batches the entire paste for us
     // BUG FIX: Create refs to track latest values without causing re-renders
@@ -156,6 +271,10 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
         inputRef.current = input;
         cursorPositionRef.current = cursorPosition;
     }, [input, cursorPosition]);
+    // BUG FIX: Keep pastedBlocksRef in sync with state
+    useEffect(() => {
+        pastedBlocksRef.current = pastedBlocks;
+    }, [pastedBlocks]);
     const handlePasteComplete = useCallback((pastedContent) => {
         // BUG FIX: Use refs to get CURRENT values, avoiding stale closures
         const currentInput = inputRef.current;
@@ -168,13 +287,20 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
             const blockId = pasteCounterRef.current++;
             // Create pasted block with CURRENT cursor position
             const block = createPastedBlock(blockId, pastedContent, currentCursor);
-            setPastedBlocks(prev => [...prev, block]);
+            // BUG FIX: Sync ref immediately so expandPlaceholdersForSubmit has current value
+            // even if submit happens before React processes the state update
+            const newBlocks = [...pastedBlocksRef.current, block];
+            pastedBlocksRef.current = newBlocks;
+            setPastedBlocks(newBlocks);
             // Insert placeholder instead of full content
             const placeholder = generatePlaceholder(block);
             const result = insertText(currentInput, currentCursor, placeholder);
             setInputState(result.text);
             setCursorPositionState(result.position);
             setOriginalInput(result.text);
+            // BUG FIX: Synchronously update refs to prevent stale reads in rapid operations
+            inputRef.current = result.text;
+            cursorPositionRef.current = result.position;
         }
         else {
             // Insert normally (below threshold) with all formatting preserved
@@ -182,11 +308,17 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
             setInputState(result.text);
             setCursorPositionState(result.position);
             setOriginalInput(result.text);
+            // BUG FIX: Synchronously update refs to prevent stale reads in rapid operations
+            inputRef.current = result.text;
+            cursorPositionRef.current = result.position;
         }
     }, [setOriginalInput]);
     // Toggle collapse/expand for block at cursor
     const toggleBlockAtCursor = useCallback(() => {
-        const block = findBlockAtCursor(input, cursorPosition, pastedBlocks);
+        // BUG FIX: Use refs to get CURRENT values, avoiding stale closures
+        const currentInput = inputRef.current;
+        const currentCursor = cursorPositionRef.current;
+        const block = findBlockAtCursor(currentInput, currentCursor, pastedBlocks);
         if (!block)
             return;
         const placeholder = generatePlaceholder(block);
@@ -195,12 +327,12 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
             let searchStart = 0;
             let targetStart = -1;
             // Find the occurrence that contains the cursor
-            while (searchStart < input.length) {
-                const occurrenceStart = input.indexOf(placeholder, searchStart);
+            while (searchStart < currentInput.length) {
+                const occurrenceStart = currentInput.indexOf(placeholder, searchStart);
                 if (occurrenceStart === -1)
                     break;
                 const occurrenceEnd = occurrenceStart + placeholder.length;
-                if (cursorPosition >= occurrenceStart && cursorPosition <= occurrenceEnd) {
+                if (currentCursor >= occurrenceStart && currentCursor <= occurrenceEnd) {
                     targetStart = occurrenceStart;
                     break;
                 }
@@ -209,28 +341,35 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
             if (targetStart === -1)
                 return; // Should not happen
             // Replace only this specific occurrence
-            const newInput = input.substring(0, targetStart) +
+            const newInput = currentInput.substring(0, targetStart) +
                 block.content +
-                input.substring(targetStart + placeholder.length);
+                currentInput.substring(targetStart + placeholder.length);
             setInputState(newInput);
             // Keep cursor at same position or adjust if needed
-            const newCursor = cursorPosition + (block.content.length - placeholder.length);
-            setCursorPositionState(Math.min(newInput.length, newCursor));
+            const newCursor = currentCursor + (block.content.length - placeholder.length);
+            const boundedCursor = Math.min(newInput.length, newCursor);
+            setCursorPositionState(boundedCursor);
             setOriginalInput(newInput);
+            // BUG FIX: Synchronously update refs to prevent stale reads
+            inputRef.current = newInput;
+            cursorPositionRef.current = boundedCursor;
             // Update block state
-            setPastedBlocks(prev => prev.map(b => (b.id === block.id ? { ...b, collapsed: false } : b)));
+            // BUG FIX: Sync ref immediately for expandPlaceholdersForSubmit
+            const updatedBlocks = pastedBlocksRef.current.map(b => b.id === block.id ? { ...b, collapsed: false } : b);
+            pastedBlocksRef.current = updatedBlocks;
+            setPastedBlocks(updatedBlocks);
         }
         else {
             // Collapse: find the specific occurrence near cursor and replace it
             let searchStart = 0;
             let targetStart = -1;
             // Find the occurrence that contains the cursor
-            while (searchStart < input.length) {
-                const occurrenceStart = input.indexOf(block.content, searchStart);
+            while (searchStart < currentInput.length) {
+                const occurrenceStart = currentInput.indexOf(block.content, searchStart);
                 if (occurrenceStart === -1)
                     break;
                 const occurrenceEnd = occurrenceStart + block.content.length;
-                if (cursorPosition >= occurrenceStart && cursorPosition <= occurrenceEnd) {
+                if (currentCursor >= occurrenceStart && currentCursor <= occurrenceEnd) {
                     targetStart = occurrenceStart;
                     break;
                 }
@@ -239,23 +378,39 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
             if (targetStart === -1)
                 return; // Should not happen
             // Replace only this specific occurrence
-            const newInput = input.substring(0, targetStart) +
+            const newInput = currentInput.substring(0, targetStart) +
                 placeholder +
-                input.substring(targetStart + block.content.length);
+                currentInput.substring(targetStart + block.content.length);
             setInputState(newInput);
             // Adjust cursor to end of placeholder
-            setCursorPositionState(targetStart + placeholder.length);
+            const newCursor = targetStart + placeholder.length;
+            setCursorPositionState(newCursor);
             setOriginalInput(newInput);
+            // BUG FIX: Synchronously update refs to prevent stale reads
+            inputRef.current = newInput;
+            cursorPositionRef.current = newCursor;
             // Update block state
-            setPastedBlocks(prev => prev.map(b => (b.id === block.id ? { ...b, collapsed: true } : b)));
+            // BUG FIX: Sync ref immediately for expandPlaceholdersForSubmit
+            const updatedBlocks = pastedBlocksRef.current.map(b => b.id === block.id ? { ...b, collapsed: true } : b);
+            pastedBlocksRef.current = updatedBlocks;
+            setPastedBlocks(updatedBlocks);
         }
-    }, [input, cursorPosition, pastedBlocks, setOriginalInput]);
+    }, [pastedBlocks, setOriginalInput]);
     // Expand all placeholders for submission
+    // BUG FIX: Use ref to always get current pastedBlocks, avoiding stale closure
+    // This ensures rapid paste + submit sequences work correctly before React re-renders
     const expandPlaceholdersForSubmit = useCallback((text) => {
-        return expandAllPlaceholders(text, pastedBlocks);
-    }, [pastedBlocks]);
+        return expandAllPlaceholders(text, pastedBlocksRef.current);
+    }, []);
     const handleSubmit = useCallback(() => {
-        // BUG FIX: Check for pending paste accumulation before submitting
+        // BUG FIX: Check for active bracketed paste mode before submitting
+        // If we're in the middle of receiving a bracketed paste, don't submit yet
+        if (bracketedPasteHandlerRef.current.isAccumulating()) {
+            // Bracketed paste is in progress - wait for it to complete
+            // The enter key will be part of the paste content
+            return;
+        }
+        // BUG FIX: Check for pending fallback paste accumulation before submitting
         if (fallbackPasteBufferRef.current.length > 0) {
             // There's accumulated paste content - flush it first
             if (fallbackPasteTimeoutRef.current) {
@@ -276,14 +431,17 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
             // User can hit Enter again to submit
             return;
         }
-        if (input.trim()) {
+        // BUG FIX: Use inputRef.current to get the latest input value
+        // This ensures we see updates from handlePasteComplete or other operations
+        const currentInput = inputRef.current;
+        if (currentInput.trim()) {
             // Expand all placeholders before submission
-            const expandedInput = expandPlaceholdersForSubmit(input);
+            const expandedInput = expandPlaceholdersForSubmit(currentInput);
             addToHistory(expandedInput);
             onSubmit?.(expandedInput);
             clearInput();
         }
-    }, [input, addToHistory, onSubmit, clearInput, expandPlaceholdersForSubmit, handlePasteComplete]);
+    }, [addToHistory, onSubmit, clearInput, expandPlaceholdersForSubmit, handlePasteComplete]);
     const handleInput = useCallback((inputChar, key) => {
         if (disabled)
             return;
@@ -292,6 +450,21 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
             setInputState("");
             setCursorPositionState(0);
             setOriginalInput("");
+            // BUG FIX: Clear pasted blocks when input is cleared
+            pastedBlocksRef.current = [];
+            setPastedBlocks([]);
+            // BUG FIX: Also clear pending paste accumulation to avoid unexpected behavior
+            fallbackPasteBufferRef.current = '';
+            fallbackPasteLastChunkTimeRef.current = 0;
+            if (fallbackPasteTimeoutRef.current) {
+                clearTimeout(fallbackPasteTimeoutRef.current);
+                fallbackPasteTimeoutRef.current = null;
+            }
+            setIsPasting(false);
+            bracketedPasteHandlerRef.current.reset();
+            // BUG FIX: Synchronously update refs to prevent stale reads
+            inputRef.current = '';
+            cursorPositionRef.current = 0;
             return;
         }
         // Handle Ctrl+P: Toggle expand/collapse for paste at cursor
@@ -314,25 +487,34 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
             const enterBehavior = inputConfig.enterBehavior || 'submit';
             // Check if user pressed Shift+Enter (submit key in newline mode)
             const isShiftEnter = key.shift && key.return;
+            // BUG FIX: Use refs to get CURRENT values, avoiding stale closures
+            const currentInput = inputRef.current;
+            const currentCursor = cursorPositionRef.current;
             if (enterBehavior === 'newline') {
                 // Newline mode: Enter inserts newline, Shift+Enter submits
                 if (isShiftEnter) {
                     handleSubmit();
                 }
                 else {
-                    const result = insertText(input, cursorPosition, "\n");
+                    const result = insertText(currentInput, currentCursor, "\n");
                     setInputState(result.text);
                     setCursorPositionState(result.position);
                     setOriginalInput(result.text);
+                    // BUG FIX: Synchronously update refs to prevent stale reads
+                    inputRef.current = result.text;
+                    cursorPositionRef.current = result.position;
                 }
             }
             else if (enterBehavior === 'submit') {
                 // Submit mode (legacy): Enter submits, Shift+Enter inserts newline
                 if (isShiftEnter) {
-                    const result = insertText(input, cursorPosition, "\n");
+                    const result = insertText(currentInput, currentCursor, "\n");
                     setInputState(result.text);
                     setCursorPositionState(result.position);
                     setOriginalInput(result.text);
+                    // BUG FIX: Synchronously update refs to prevent stale reads
+                    inputRef.current = result.text;
+                    cursorPositionRef.current = result.position;
                 }
                 else {
                     handleSubmit();
@@ -345,12 +527,15 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
                     // Explicit submit with Shift+Enter
                     handleSubmit();
                 }
-                else if (isIncompleteInput(input, inputConfig.smartDetection)) {
+                else if (isIncompleteInput(currentInput, inputConfig.smartDetection)) {
                     // Input appears incomplete, insert newline
-                    const result = insertText(input, cursorPosition, "\n");
+                    const result = insertText(currentInput, currentCursor, "\n");
                     setInputState(result.text);
                     setCursorPositionState(result.position);
                     setOriginalInput(result.text);
+                    // BUG FIX: Synchronously update refs to prevent stale reads
+                    inputRef.current = result.text;
+                    cursorPositionRef.current = result.position;
                 }
                 else {
                     // Input looks complete, submit
@@ -365,6 +550,13 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
             if (historyInput !== null) {
                 setInputState(historyInput);
                 setCursorPositionState(historyInput.length);
+                // BUG FIX: Clear pasted blocks when navigating history
+                // History entries don't have associated paste blocks
+                pastedBlocksRef.current = [];
+                setPastedBlocks([]);
+                // BUG FIX: Synchronously update refs to prevent stale reads
+                inputRef.current = historyInput;
+                cursorPositionRef.current = historyInput.length;
             }
             return;
         }
@@ -373,39 +565,64 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
             if (historyInput !== null) {
                 setInputState(historyInput);
                 setCursorPositionState(historyInput.length);
+                // BUG FIX: Clear pasted blocks when navigating history
+                // History entries don't have associated paste blocks
+                pastedBlocksRef.current = [];
+                setPastedBlocks([]);
+                // BUG FIX: Synchronously update refs to prevent stale reads
+                inputRef.current = historyInput;
+                cursorPositionRef.current = historyInput.length;
             }
             return;
         }
         // Handle cursor movement - ignore meta flag for arrows as it's unreliable in terminals
         // Only do word movement if ctrl is pressed AND no arrow escape sequence is in inputChar
         if ((key.leftArrow || key.name === 'left') && key.ctrl && !inputChar.includes('[')) {
-            const newPos = moveToPreviousWord(input, cursorPosition);
+            // BUG FIX: Use refs to get CURRENT values, avoiding stale closures
+            const newPos = moveToPreviousWord(inputRef.current, cursorPositionRef.current);
             setCursorPositionState(newPos);
+            // BUG FIX: Synchronously update ref to prevent stale reads
+            cursorPositionRef.current = newPos;
             return;
         }
         if ((key.rightArrow || key.name === 'right') && key.ctrl && !inputChar.includes('[')) {
-            const newPos = moveToNextWord(input, cursorPosition);
+            // BUG FIX: Use refs to get CURRENT values, avoiding stale closures
+            const newPos = moveToNextWord(inputRef.current, cursorPositionRef.current);
             setCursorPositionState(newPos);
+            // BUG FIX: Synchronously update ref to prevent stale reads
+            cursorPositionRef.current = newPos;
             return;
         }
         // Handle regular cursor movement - single character (ignore meta flag)
         if (key.leftArrow || key.name === 'left') {
-            const newPos = Math.max(0, cursorPosition - 1);
+            // BUG FIX: Use ref to get CURRENT cursor position, avoiding stale closure
+            const newPos = Math.max(0, cursorPositionRef.current - 1);
             setCursorPositionState(newPos);
+            // BUG FIX: Synchronously update ref to prevent stale reads
+            cursorPositionRef.current = newPos;
             return;
         }
         if (key.rightArrow || key.name === 'right') {
-            const newPos = Math.min(input.length, cursorPosition + 1);
+            // BUG FIX: Use refs to get CURRENT values, avoiding stale closures
+            const newPos = Math.min(inputRef.current.length, cursorPositionRef.current + 1);
             setCursorPositionState(newPos);
+            // BUG FIX: Synchronously update ref to prevent stale reads
+            cursorPositionRef.current = newPos;
             return;
         }
         // Handle Home/End keys or Ctrl+A/E
         if ((key.ctrl && inputChar === "a") || key.name === "home") {
             setCursorPositionState(0); // Simple start of input
+            // BUG FIX: Synchronously update ref to prevent stale reads
+            cursorPositionRef.current = 0;
             return;
         }
         if ((key.ctrl && inputChar === "e") || key.name === "end") {
-            setCursorPositionState(input.length); // Simple end of input
+            // BUG FIX: Use ref to get CURRENT input length, avoiding stale closure
+            const endPos = inputRef.current.length;
+            setCursorPositionState(endPos); // Simple end of input
+            // BUG FIX: Synchronously update ref to prevent stale reads
+            cursorPositionRef.current = endPos;
             return;
         }
         // Handle deletion - check multiple ways backspace might be detected
@@ -417,47 +634,69 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
             inputChar === '\x7f' ||
             (key.delete && inputChar === '' && !key.shift);
         if (isBackspace) {
+            // BUG FIX: Use refs to get CURRENT values, avoiding stale closures
+            const currentInput = inputRef.current;
+            const currentCursor = cursorPositionRef.current;
             if (key.ctrl || key.meta) {
                 // Ctrl/Cmd + Backspace: Delete word before cursor
-                const result = deleteWordBefore(input, cursorPosition);
+                const result = deleteWordBefore(currentInput, currentCursor);
                 setInputState(result.text);
                 setCursorPositionState(result.position);
                 setOriginalInput(result.text);
+                // BUG FIX: Synchronously update refs to prevent stale reads
+                inputRef.current = result.text;
+                cursorPositionRef.current = result.position;
             }
             else {
                 // Regular backspace
-                const result = deleteCharBefore(input, cursorPosition);
+                const result = deleteCharBefore(currentInput, currentCursor);
                 setInputState(result.text);
                 setCursorPositionState(result.position);
                 setOriginalInput(result.text);
+                // BUG FIX: Synchronously update refs to prevent stale reads
+                inputRef.current = result.text;
+                cursorPositionRef.current = result.position;
             }
             return;
         }
         // Handle forward delete (Del key) - but not if it was already handled as backspace above
         // Note: Ctrl+D is also treated as delete character (standard terminal behavior)
         if (key.delete && inputChar !== '') {
+            // BUG FIX: Use refs to get CURRENT values, avoiding stale closures
+            const currentInput = inputRef.current;
+            const currentCursor = cursorPositionRef.current;
             if (key.ctrl || key.meta) {
                 // Ctrl/Cmd + Delete: Delete word after cursor
-                const result = deleteWordAfter(input, cursorPosition);
+                const result = deleteWordAfter(currentInput, currentCursor);
                 setInputState(result.text);
                 setCursorPositionState(result.position);
                 setOriginalInput(result.text);
+                // BUG FIX: Synchronously update refs to prevent stale reads
+                inputRef.current = result.text;
+                cursorPositionRef.current = result.position;
             }
             else {
                 // Regular delete
-                const result = deleteCharAfter(input, cursorPosition);
+                const result = deleteCharAfter(currentInput, currentCursor);
                 setInputState(result.text);
                 setCursorPositionState(result.position);
                 setOriginalInput(result.text);
+                // BUG FIX: Synchronously update refs to prevent stale reads
+                inputRef.current = result.text;
+                cursorPositionRef.current = result.position;
             }
             return;
         }
         // Handle Ctrl+D: Delete character after cursor (standard terminal behavior)
         if (key.ctrl && inputChar === "d") {
-            const result = deleteCharAfter(input, cursorPosition);
+            // BUG FIX: Use refs to get CURRENT values, avoiding stale closures
+            const result = deleteCharAfter(inputRef.current, cursorPositionRef.current);
             setInputState(result.text);
             setCursorPositionState(result.position);
             setOriginalInput(result.text);
+            // BUG FIX: Synchronously update refs to prevent stale reads
+            inputRef.current = result.text;
+            cursorPositionRef.current = result.position;
             return;
         }
         // Handle Ctrl+K: Open quick actions menu
@@ -469,20 +708,30 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
         // Handle Ctrl+U: Delete from cursor to start of line
         // Check both key.ctrl with 'u' and raw ASCII code \x15 (Ctrl+U = ASCII 21)
         if ((key.ctrl && inputChar === "u") || inputChar === "\x15") {
-            const lineStart = moveToLineStart(input, cursorPosition);
-            const newText = input.slice(0, lineStart) + input.slice(cursorPosition);
+            // BUG FIX: Use refs to get CURRENT values, avoiding stale closures
+            const currentInput = inputRef.current;
+            const currentCursor = cursorPositionRef.current;
+            const lineStart = moveToLineStart(currentInput, currentCursor);
+            const newText = currentInput.slice(0, lineStart) + currentInput.slice(currentCursor);
             setInputState(newText);
             setCursorPositionState(lineStart);
             setOriginalInput(newText);
+            // BUG FIX: Synchronously update refs to prevent stale reads
+            inputRef.current = newText;
+            cursorPositionRef.current = lineStart;
             return;
         }
         // Handle Ctrl+W: Delete word before cursor
         // Check both key.ctrl with 'w' and raw ASCII code \x17 (Ctrl+W = ASCII 23)
         if ((key.ctrl && inputChar === "w") || inputChar === "\x17") {
-            const result = deleteWordBefore(input, cursorPosition);
+            // BUG FIX: Use refs to get CURRENT values, avoiding stale closures
+            const result = deleteWordBefore(inputRef.current, cursorPositionRef.current);
             setInputState(result.text);
             setCursorPositionState(result.position);
             setOriginalInput(result.text);
+            // BUG FIX: Synchronously update refs to prevent stale reads
+            inputRef.current = result.text;
+            cursorPositionRef.current = result.position;
             return;
         }
         // Handle Ctrl+O: Toggle verbose mode
@@ -509,6 +758,21 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
             setInputState("");
             setCursorPositionState(0);
             setOriginalInput("");
+            // BUG FIX: Clear pasted blocks when input is cleared
+            pastedBlocksRef.current = [];
+            setPastedBlocks([]);
+            // BUG FIX: Also clear pending paste accumulation to avoid unexpected behavior
+            fallbackPasteBufferRef.current = '';
+            fallbackPasteLastChunkTimeRef.current = 0;
+            if (fallbackPasteTimeoutRef.current) {
+                clearTimeout(fallbackPasteTimeoutRef.current);
+                fallbackPasteTimeoutRef.current = null;
+            }
+            setIsPasting(false);
+            bracketedPasteHandlerRef.current.reset();
+            // BUG FIX: Synchronously update refs to prevent stale reads
+            inputRef.current = '';
+            cursorPositionRef.current = 0;
             return;
         }
         // Handle Shift+Tab: Toggle auto-accept mode (Phase 2)
@@ -519,18 +783,45 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
         }
         // Handle Tab (alone): Toggle thinking mode (P2.4)
         // Only if input is empty (to avoid interfering with autocomplete)
-        if (key.tab && !key.shift && !key.ctrl && !key.meta && input.length === 0) {
+        // BUG FIX: Use inputRef.current to check current input length, avoiding stale closure
+        if (key.tab && !key.shift && !key.ctrl && !key.meta && inputRef.current.length === 0) {
             onThinkingModeToggle?.();
             return;
         }
         // Handle Ctrl+G: Open external editor (Phase 2)
         // Check both key.ctrl with 'g' and raw ASCII code \x07 (Ctrl+G = ASCII 7)
         if ((key.ctrl && inputChar === "g") || inputChar === "\x07") {
+            // BUG FIX: Use inputRef.current to get the latest input value
+            // This ensures the external editor receives current content even if
+            // there were rapid updates just before Ctrl+G was pressed
+            const currentInput = inputRef.current;
             // Call async external editor handler
-            onExternalEditor?.(input).then((editedContent) => {
+            onExternalEditor?.(currentInput).then((editedContent) => {
+                // BUG FIX: Check if component is still mounted before updating state
+                if (!isMountedRef.current)
+                    return;
                 if (editedContent !== null) {
                     setInputState(editedContent);
                     setCursorPositionState(editedContent.length);
+                    // BUG FIX: Also update original input for history tracking
+                    setOriginalInput(editedContent);
+                    // BUG FIX: Clear pasted blocks - external editor returns fully expanded content
+                    // The old block metadata is no longer valid
+                    pastedBlocksRef.current = [];
+                    setPastedBlocks([]);
+                    // BUG FIX: Clear pending paste accumulation to prevent it from overwriting
+                    // the external editor content when timeout fires
+                    fallbackPasteBufferRef.current = '';
+                    fallbackPasteLastChunkTimeRef.current = 0;
+                    if (fallbackPasteTimeoutRef.current) {
+                        clearTimeout(fallbackPasteTimeoutRef.current);
+                        fallbackPasteTimeoutRef.current = null;
+                    }
+                    setIsPasting(false);
+                    bracketedPasteHandlerRef.current.reset();
+                    // BUG FIX: Synchronously update refs to prevent stale reads
+                    inputRef.current = editedContent;
+                    cursorPositionRef.current = editedContent.length;
                 }
             }).catch(() => {
                 // Ignore errors - user will see error in UI
@@ -539,7 +830,8 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
         }
         // Handle ? key: Show keyboard shortcuts help (P1.4)
         // Only trigger if input is empty (avoid interfering with normal typing)
-        if (inputChar === "?" && input.length === 0) {
+        // BUG FIX: Use inputRef.current to check current input length, avoiding stale closure
+        if (inputChar === "?" && inputRef.current.length === 0) {
             onKeyboardHelp?.();
             return;
         }
@@ -616,9 +908,23 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
                             clearTimeout(fallbackPasteTimeoutRef.current);
                             fallbackPasteTimeoutRef.current = null;
                         }
-                        // Process accumulated content (truncated)
+                        // BUG FIX: Apply paste settings like other paste paths
+                        const settingsManager = getSettingsManager();
+                        const pasteSettings = settingsManager.getPasteSettings();
+                        const { allowLargePaste, maxPasteLength, warningThreshold } = pasteSettings;
+                        // Check if paste exceeds warning threshold
+                        if (accumulatedContent.length >= warningThreshold) {
+                            onLargePaste?.(accumulatedContent.length);
+                        }
+                        // Handle truncation if needed
+                        let finalContent = accumulatedContent;
+                        if (!allowLargePaste && accumulatedContent.length > maxPasteLength) {
+                            finalContent = accumulatedContent.slice(0, maxPasteLength);
+                            onPasteTruncated?.(accumulatedContent.length, maxPasteLength);
+                        }
+                        // Process accumulated content
                         try {
-                            handlePasteComplete(accumulatedContent);
+                            handlePasteComplete(finalContent);
                         }
                         catch (error) {
                             console.error('Error handling oversized paste:', error);
@@ -638,6 +944,9 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
                     const timeoutMs = isActiveAccumulation && timeSinceLastChunk < 1000 ? 500 : 200;
                     // Set new timeout - if no more chunks arrive, process the paste
                     fallbackPasteTimeoutRef.current = setTimeout(() => {
+                        // BUG FIX: Check if component is still mounted
+                        if (!isMountedRef.current)
+                            return;
                         // BUG FIX: Clear refs FIRST to prevent race conditions
                         const accumulatedContent = fallbackPasteBufferRef.current;
                         fallbackPasteBufferRef.current = '';
@@ -651,16 +960,17 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
                         const pasteSettings = settingsManager.getPasteSettings();
                         const { allowLargePaste, maxPasteLength, warningThreshold } = pasteSettings;
                         // Check if paste exceeds warning threshold
+                        // BUG FIX: Use ref to get current callback, avoiding stale closure
                         if (pastedContent.length >= warningThreshold) {
-                            onLargePaste?.(pastedContent.length);
+                            onLargePasteRef.current?.(pastedContent.length);
                         }
                         // Handle truncation if needed
                         let finalContent = pastedContent;
                         if (!allowLargePaste && pastedContent.length > maxPasteLength) {
                             // Truncate the paste
                             finalContent = pastedContent.slice(0, maxPasteLength);
-                            // Notify about truncation
-                            onPasteTruncated?.(pastedContent.length, maxPasteLength);
+                            // BUG FIX: Use ref to get current callback, avoiding stale closure
+                            onPasteTruncatedRef.current?.(pastedContent.length, maxPasteLength);
                         }
                         // Handle entire accumulated paste at once
                         // Note: handlePasteComplete will use CURRENT input/cursor values from React state
@@ -688,21 +998,48 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
                             clearTimeout(fallbackPasteTimeoutRef.current);
                         }
                         fallbackPasteTimeoutRef.current = setTimeout(() => {
+                            // BUG FIX: Check if component is still mounted
+                            if (!isMountedRef.current)
+                                return;
                             const accumulatedContent = fallbackPasteBufferRef.current;
                             fallbackPasteBufferRef.current = '';
                             fallbackPasteTimeoutRef.current = null;
                             fallbackPasteLastChunkTimeRef.current = 0;
                             if (accumulatedContent) {
-                                handlePasteComplete(accumulatedContent);
+                                // BUG FIX: Apply paste settings (truncation/warnings) like other paste paths
+                                const settingsManager = getSettingsManager();
+                                const pasteSettings = settingsManager.getPasteSettings();
+                                const { allowLargePaste, maxPasteLength, warningThreshold } = pasteSettings;
+                                // Check if paste exceeds warning threshold
+                                if (accumulatedContent.length >= warningThreshold) {
+                                    onLargePasteRef.current?.(accumulatedContent.length);
+                                }
+                                // Handle truncation if needed
+                                let finalContent = accumulatedContent;
+                                if (!allowLargePaste && accumulatedContent.length > maxPasteLength) {
+                                    finalContent = accumulatedContent.slice(0, maxPasteLength);
+                                    onPasteTruncatedRef.current?.(accumulatedContent.length, maxPasteLength);
+                                }
+                                try {
+                                    handlePasteComplete(finalContent);
+                                }
+                                catch (error) {
+                                    // BUG FIX: Catch errors to prevent timeout callback crash
+                                    console.error('Error handling accumulated paste:', error);
+                                }
                             }
                         }, 100); // Short timeout for single char after paste
                         return;
                     }
                     // No pending paste - process normal input
-                    const result2 = insertText(input, cursorPosition, result.content);
+                    // BUG FIX: Use refs to get CURRENT values, avoiding stale closures
+                    const result2 = insertText(inputRef.current, cursorPositionRef.current, result.content);
                     setInputState(result2.text);
                     setCursorPositionState(result2.position);
                     setOriginalInput(result2.text);
+                    // BUG FIX: Synchronously update refs to prevent stale reads
+                    inputRef.current = result2.text;
+                    cursorPositionRef.current = result2.position;
                 }
             }
             else if (enableFallback) {
@@ -728,9 +1065,23 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
                             clearTimeout(fallbackPasteTimeoutRef.current);
                             fallbackPasteTimeoutRef.current = null;
                         }
-                        // Process accumulated content (truncated)
+                        // BUG FIX: Apply paste settings like other paste paths
+                        const settingsManager = getSettingsManager();
+                        const pasteSettings = settingsManager.getPasteSettings();
+                        const { allowLargePaste, maxPasteLength, warningThreshold } = pasteSettings;
+                        // Check if paste exceeds warning threshold
+                        if (accumulatedContent.length >= warningThreshold) {
+                            onLargePaste?.(accumulatedContent.length);
+                        }
+                        // Handle truncation if needed
+                        let finalContent = accumulatedContent;
+                        if (!allowLargePaste && accumulatedContent.length > maxPasteLength) {
+                            finalContent = accumulatedContent.slice(0, maxPasteLength);
+                            onPasteTruncated?.(accumulatedContent.length, maxPasteLength);
+                        }
+                        // Process accumulated content
                         try {
-                            handlePasteComplete(accumulatedContent);
+                            handlePasteComplete(finalContent);
                         }
                         catch (error) {
                             console.error('Error handling oversized paste:', error);
@@ -748,6 +1099,9 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
                     const timeoutMs = isActiveAccumulation && timeSinceLastChunk < 1000 ? 500 : 200;
                     // Set new timeout - if no more chunks arrive, process the paste
                     fallbackPasteTimeoutRef.current = setTimeout(() => {
+                        // BUG FIX: Check if component is still mounted
+                        if (!isMountedRef.current)
+                            return;
                         // BUG FIX: Clear refs FIRST to prevent race conditions
                         const accumulatedContent = fallbackPasteBufferRef.current;
                         fallbackPasteBufferRef.current = '';
@@ -760,16 +1114,17 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
                         const pasteSettings = settingsManager.getPasteSettings();
                         const { allowLargePaste, maxPasteLength, warningThreshold } = pasteSettings;
                         // Check if paste exceeds warning threshold
+                        // BUG FIX: Use ref to get current callback, avoiding stale closure
                         if (accumulatedContent.length >= warningThreshold) {
-                            onLargePaste?.(accumulatedContent.length);
+                            onLargePasteRef.current?.(accumulatedContent.length);
                         }
                         // Handle truncation if needed
                         let finalContent = accumulatedContent;
                         if (!allowLargePaste && accumulatedContent.length > maxPasteLength) {
                             // Truncate the paste
                             finalContent = accumulatedContent.slice(0, maxPasteLength);
-                            // Notify about truncation
-                            onPasteTruncated?.(accumulatedContent.length, maxPasteLength);
+                            // BUG FIX: Use ref to get current callback, avoiding stale closure
+                            onPasteTruncatedRef.current?.(accumulatedContent.length, maxPasteLength);
                         }
                         // Handle entire accumulated paste at once
                         // Note: handlePasteComplete will use CURRENT input/cursor values from React state
@@ -787,21 +1142,29 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
                 }
                 else {
                     // Normal single character input
-                    const result = insertText(input, cursorPosition, inputChar);
+                    // BUG FIX: Use refs to get CURRENT values, avoiding stale closures
+                    const result = insertText(inputRef.current, cursorPositionRef.current, inputChar);
                     setInputState(result.text);
                     setCursorPositionState(result.position);
                     setOriginalInput(result.text);
+                    // BUG FIX: Synchronously update refs to prevent stale reads
+                    inputRef.current = result.text;
+                    cursorPositionRef.current = result.position;
                 }
             }
             else {
                 // Both bracketed paste and fallback disabled - normal input only
-                const result = insertText(input, cursorPosition, inputChar);
+                // BUG FIX: Use refs to get CURRENT values, avoiding stale closures
+                const result = insertText(inputRef.current, cursorPositionRef.current, inputChar);
                 setInputState(result.text);
                 setCursorPositionState(result.position);
                 setOriginalInput(result.text);
+                // BUG FIX: Synchronously update refs to prevent stale reads
+                inputRef.current = result.text;
+                cursorPositionRef.current = result.position;
             }
         }
-    }, [disabled, onSpecialKey, onVerboseToggle, onQuickActions, onBackgroundModeToggle, onCopyLastResponse, onAutoAcceptToggle, onThinkingModeToggle, onKeyboardHelp, onLargePaste, onPasteTruncated, input, cursorPosition, multiline, handleSubmit, navigateHistory, setOriginalInput, toggleBlockAtCursor, handlePasteComplete, pasteConfig, isPasting]);
+    }, [disabled, onSpecialKey, onVerboseToggle, onQuickActions, onBackgroundModeToggle, onCopyLastResponse, onAutoAcceptToggle, onThinkingModeToggle, onKeyboardHelp, onLargePaste, onPasteTruncated, onExternalEditor, onEscape, inputConfig, multiline, handleSubmit, navigateHistory, setOriginalInput, toggleBlockAtCursor, handlePasteComplete, pasteConfig, isPasting]);
     // Update current block at cursor when cursor position or input changes
     useEffect(() => {
         const block = findBlockAtCursor(input, cursorPosition, pastedBlocks);
@@ -809,7 +1172,10 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
     }, [input, cursorPosition, pastedBlocks]);
     // BUG FIX: Comprehensive cleanup on unmount
     useEffect(() => {
+        isMountedRef.current = true;
         return () => {
+            // BUG FIX: Set mounted flag to false first to prevent async state updates
+            isMountedRef.current = false;
             // Clear all timeouts
             if (pasteTimeoutRef.current) {
                 clearTimeout(pasteTimeoutRef.current);