@defai.digital/ax-cli 3.7.2 → 3.8.2

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

@@ -2,78 +2,323 @@ import { useState, useCallback, useRef, useEffect } from "react";
 import { deleteCharBefore, deleteCharAfter, deleteWordBefore, deleteWordAfter, insertText, moveToLineStart, moveToPreviousWord, moveToNextWord, } from "../../utils/text-utils.js";
 import { useInputHistory } from "./use-input-history.js";
 import { PasteDetector, shouldCollapsePaste, createPastedBlock, generatePlaceholder, findBlockAtCursor, expandAllPlaceholders, } from "../../utils/paste-utils.js";
-export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseToggle, onQuickActions, onBackgroundModeToggle, onCopyLastResponse, disabled = false, multiline = false, } = {}) {
+import { getSettingsManager } from "../../utils/settings-manager.js";
+import { BracketedPasteHandler } from "../utils/bracketed-paste-handler.js";
+/**
+ * Check if input appears incomplete and should not be submitted
+ * Used for smart mode to auto-insert newlines for incomplete input
+ */
+function isIncompleteInput(text, smartDetection) {
+    if (!smartDetection?.enabled)
+        return false;
+    const trimmed = text.trimEnd();
+    if (!trimmed)
+        return false;
+    // Check for unclosed brackets
+    if (smartDetection.checkBrackets) {
+        const brackets = {
+            '(': 0,
+            '[': 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) {
+            // 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) {
+            return true;
+        }
+    }
+    // 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 = [
+            '===', '!==', '...', '&&', '||', '==', '!=', '<=', '>=', '=>',
+            '..', '+', '-', '*', '/', '%', '=', '<', '>', '&', '|', '^',
+            '?', ':', ',', '.',
+        ];
+        // 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;
+                }
+            }
+        }
+    }
+    // Check for incomplete statements
+    if (smartDetection.checkStatements) {
+        const incompleteKeywords = [
+            'if', 'else', 'for', 'while', 'do', 'switch', 'case',
+            'function', 'const', 'let', 'var', 'class', 'interface',
+            'type', 'enum', 'import', 'export', 'return', 'throw',
+            'try', 'catch', 'finally', 'async', 'await',
+        ];
+        // Check if line ends with a statement keyword (potentially incomplete)
+        const lastLine = trimmed.split('\n').pop() || '';
+        // 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 !== '\\' ? '\\' : '';
+        }
+        // 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;
+}
+export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseToggle, onQuickActions, onBackgroundModeToggle, onCopyLastResponse, onAutoAcceptToggle, onThinkingModeToggle, onExternalEditor, onLargePaste, onPasteTruncated, onKeyboardHelp, projectDir, disabled = false, multiline = false, } = {}) {
     const [input, setInputState] = useState("");
     const [cursorPosition, setCursorPositionState] = useState(0);
     const [pastedBlocks, setPastedBlocks] = useState([]);
-    const [pasteCounter, setPasteCounter] = useState(0);
+    // 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
+    const [inputConfig] = useState(() => {
+        return getSettingsManager().getInputConfig();
+    });
+    // Load paste configuration from settings (v3.8.0)
+    const [pasteConfig] = useState(() => {
+        return getSettingsManager().getPasteSettings();
+    });
     const isMultilineRef = useRef(multiline);
     const pasteDetectorRef = useRef(new PasteDetector());
     const pasteTimeoutRef = useRef(null);
+    const bracketedPasteHandlerRef = useRef(new BracketedPasteHandler()); // v3.8.0: Bracketed paste mode handler
+    // v3.8.0: Fallback paste accumulation buffer (for terminals that send paste in chunks)
+    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;
-    const { addToHistory, navigateHistory, resetHistory, setOriginalInput, isNavigatingHistory, } = useInputHistory();
+    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([]);
-        setPasteCounter(0);
+        pasteCounterRef.current = 0; // BUG FIX: Reset counter ref
+        setIsPasting(false); // v3.8.0: Reset paste state
         pasteDetectorRef.current.reset();
+        bracketedPasteHandlerRef.current.reset(); // v3.8.0: Reset bracketed paste handler
+        // v3.8.0: Clear fallback paste buffer and timeout
+        fallbackPasteBufferRef.current = '';
+        fallbackPasteLastChunkTimeRef.current = 0;
+        if (fallbackPasteTimeoutRef.current) {
+            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]);
-    // Handle paste completion (after accumulation timeout)
+        // 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
+    const inputRef = useRef(input);
+    const cursorPositionRef = useRef(cursorPosition);
+    // Keep refs in sync with state
+    useEffect(() => {
+        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) => {
-        // Check if should collapse
+        // BUG FIX: Use refs to get CURRENT values, avoiding stale closures
+        const currentInput = inputRef.current;
+        const currentCursor = cursorPositionRef.current;
+        // Preserve all formatting - no trimming or normalization
+        // This ensures JSON indentation, newlines, and whitespace are intact
+        // Check if should collapse based on line count or character count
         if (shouldCollapsePaste(pastedContent)) {
-            // Create pasted block
-            const block = createPastedBlock(pasteCounter, pastedContent, cursorPosition);
-            setPasteCounter(prev => prev + 1);
-            setPastedBlocks(prev => [...prev, block]);
+            // BUG FIX: Use ref and increment immediately to prevent race conditions
+            const blockId = pasteCounterRef.current++;
+            // Create pasted block with CURRENT cursor position
+            const block = createPastedBlock(blockId, pastedContent, currentCursor);
+            // 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(input, cursorPosition, placeholder);
+            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)
-            const result = insertText(input, cursorPosition, pastedContent);
+            // Insert normally (below threshold) with all formatting preserved
+            const result = insertText(currentInput, currentCursor, pastedContent);
             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;
         }
-    }, [input, cursorPosition, pasteCounter, setOriginalInput]);
+    }, [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);
@@ -82,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;
                 }
@@ -96,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;
                 }
@@ -126,30 +378,70 @@ 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(() => {
-        if (input.trim()) {
+        // 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) {
+                clearTimeout(fallbackPasteTimeoutRef.current);
+                fallbackPasteTimeoutRef.current = null;
+            }
+            const accumulatedPaste = fallbackPasteBufferRef.current;
+            fallbackPasteBufferRef.current = '';
+            fallbackPasteLastChunkTimeRef.current = 0;
+            // Add accumulated paste to input before submitting
+            try {
+                handlePasteComplete(accumulatedPaste);
+            }
+            catch (error) {
+                console.error('Error flushing paste on submit:', error);
+            }
+            // Don't submit yet - let the paste complete first
+            // User can hit Enter again to submit
+            return;
+        }
+        // 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]);
+    }, [addToHistory, onSubmit, clearInput, expandPlaceholdersForSubmit, handlePasteComplete]);
     const handleInput = useCallback((inputChar, key) => {
         if (disabled)
             return;
@@ -158,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
@@ -175,17 +482,65 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
             onEscape?.();
             return;
         }
-        // Handle Enter/Return
+        // Handle Enter/Return - Phase 1: Configurable multi-line input
         if (key.return) {
-            if (isMultilineRef.current && key.shift) {
-                // Shift+Enter in multiline mode inserts newline
-                const result = insertText(input, cursorPosition, "\n");
-                setInputState(result.text);
-                setCursorPositionState(result.position);
-                setOriginalInput(result.text);
+            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(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();
+            else if (enterBehavior === 'submit') {
+                // Submit mode (legacy): Enter submits, Shift+Enter inserts newline
+                if (isShiftEnter) {
+                    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();
+                }
+            }
+            else if (enterBehavior === 'smart') {
+                // Smart mode: Auto-detect incomplete input
+                // Shift+Enter always submits, otherwise check if input is incomplete
+                if (isShiftEnter) {
+                    // Explicit submit with Shift+Enter
+                    handleSubmit();
+                }
+                else if (isIncompleteInput(currentInput, inputConfig.smartDetection)) {
+                    // Input appears incomplete, insert newline
+                    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
+                    handleSubmit();
+                }
             }
             return;
         }
@@ -195,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;
         }
@@ -203,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
@@ -247,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
@@ -299,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
@@ -339,48 +758,439 @@ 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)
+        // Check for Shift+Tab combination
+        if (key.shift && key.tab) {
+            onAutoAcceptToggle?.();
+            return;
+        }
+        // Handle Tab (alone): Toggle thinking mode (P2.4)
+        // Only if input is empty (to avoid interfering with autocomplete)
+        // 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?.(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
+            });
+            return;
+        }
+        // Handle ? key: Show keyboard shortcuts help (P1.4)
+        // Only trigger if input is empty (avoid interfering with normal typing)
+        // BUG FIX: Use inputRef.current to check current input length, avoiding stale closure
+        if (inputChar === "?" && inputRef.current.length === 0) {
+            onKeyboardHelp?.();
             return;
         }
         // Handle regular character input
         if (inputChar && !key.ctrl && !key.meta) {
-            // Detect paste operation
-            const isPaste = pasteDetectorRef.current.detectPaste(inputChar);
-            if (isPaste) {
-                // Clear any existing paste timeout
-                if (pasteTimeoutRef.current) {
-                    clearTimeout(pasteTimeoutRef.current);
+            // v3.8.0: Bracketed Paste Mode Detection
+            // Uses industry-standard escape sequences for reliable paste detection
+            // Falls back to simple batched detection if not supported
+            const { enableBracketedPaste, enableFallback } = pasteConfig;
+            // Use bracketed paste handler if enabled
+            if (enableBracketedPaste) {
+                // BUG FIX: Check for orphaned content from timeout first
+                const orphanedContent = bracketedPasteHandlerRef.current.retrieveOrphanedContent();
+                if (orphanedContent) {
+                    // Timeout occurred and we have accumulated content without end marker
+                    // Process it as a paste
+                    try {
+                        handlePasteComplete(orphanedContent);
+                    }
+                    catch (error) {
+                        console.error('Error handling orphaned paste:', error);
+                        // Continue despite error - don't block current input
+                    }
+                    // Continue processing current input normally
+                }
+                const result = bracketedPasteHandlerRef.current.handleInput(inputChar);
+                // Update pasting state for visual indicator
+                if (result.isAccumulating !== isPasting) {
+                    setIsPasting(result.isAccumulating);
+                }
+                // If still accumulating, don't process yet
+                if (result.isAccumulating) {
+                    return;
+                }
+                // If paste detected and complete via bracketed paste mode
+                if (result.isPaste && result.content) {
+                    const pastedContent = result.content;
+                    // Phase 3: Large paste handling with truncation
+                    const settingsManager = getSettingsManager();
+                    const pasteSettings = settingsManager.getPasteSettings();
+                    const { allowLargePaste, maxPasteLength, warningThreshold } = pasteSettings;
+                    // Check if paste exceeds warning threshold
+                    if (pastedContent.length >= warningThreshold) {
+                        onLargePaste?.(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);
+                    }
+                    // Handle entire paste at once
+                    handlePasteComplete(finalContent);
+                    return;
                 }
-                // Accumulate paste input
-                pasteDetectorRef.current.accumulatePasteInput(inputChar);
-                // Set timeout to finalize paste (50ms after last input)
-                pasteTimeoutRef.current = setTimeout(() => {
-                    const accumulated = pasteDetectorRef.current.getAccumulatedInput();
-                    if (accumulated) {
-                        handlePasteComplete(accumulated);
+                // Not detected via bracketed paste mode
+                // If fallback enabled AND looks like batched paste, accumulate chunks
+                if (enableFallback && result.content && result.content.length > 1) {
+                    // BUG FIX: Accumulate chunks with timeout instead of immediate processing
+                    // This prevents multiple blocks when paste arrives in chunks (SSH, tmux, etc)
+                    const now = Date.now();
+                    const isActiveAccumulation = fallbackPasteBufferRef.current.length > 0;
+                    const timeSinceLastChunk = now - fallbackPasteLastChunkTimeRef.current;
+                    // BUG FIX: Check buffer size to prevent overflow (100MB limit)
+                    const MAX_BUFFER_SIZE = 100 * 1024 * 1024;
+                    if (fallbackPasteBufferRef.current.length + result.content.length > MAX_BUFFER_SIZE) {
+                        // Buffer overflow - process what we have immediately
+                        const accumulatedContent = fallbackPasteBufferRef.current;
+                        fallbackPasteBufferRef.current = '';
+                        fallbackPasteLastChunkTimeRef.current = 0;
+                        if (fallbackPasteTimeoutRef.current) {
+                            clearTimeout(fallbackPasteTimeoutRef.current);
+                            fallbackPasteTimeoutRef.current = null;
+                        }
+                        // 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(finalContent);
+                        }
+                        catch (error) {
+                            console.error('Error handling oversized paste:', error);
+                        }
+                        return;
                     }
-                    pasteTimeoutRef.current = null;
-                }, 50);
+                    // Add to accumulation buffer
+                    fallbackPasteBufferRef.current += result.content;
+                    fallbackPasteLastChunkTimeRef.current = now;
+                    // Clear existing timeout
+                    if (fallbackPasteTimeoutRef.current) {
+                        clearTimeout(fallbackPasteTimeoutRef.current);
+                    }
+                    // Dynamic timeout: Use longer window if we're actively accumulating a paste
+                    // Initial chunk: 200ms (fast for single-burst pastes)
+                    // Subsequent chunks: 500ms (handles slow terminals/networks)
+                    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 = '';
+                        fallbackPasteLastChunkTimeRef.current = 0;
+                        fallbackPasteTimeoutRef.current = null;
+                        if (!accumulatedContent)
+                            return;
+                        const pastedContent = accumulatedContent.replace(/\r/g, '\n');
+                        // Phase 3: Large paste handling with truncation
+                        const settingsManager = getSettingsManager();
+                        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) {
+                            onLargePasteRef.current?.(pastedContent.length);
+                        }
+                        // Handle truncation if needed
+                        let finalContent = pastedContent;
+                        if (!allowLargePaste && pastedContent.length > maxPasteLength) {
+                            // Truncate the paste
+                            finalContent = pastedContent.slice(0, 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
+                        try {
+                            handlePasteComplete(finalContent);
+                        }
+                        catch (error) {
+                            // BUG FIX: Catch errors to prevent timeout callback crash
+                            console.error('Error handling paste:', error);
+                            // Don't attempt fallback - state might be inconsistent
+                            // The paste content is lost but system remains stable
+                        }
+                    }, timeoutMs); // Dynamic timeout: 200ms initial, 500ms for active accumulation
+                    return;
+                }
+                // Normal single character input
+                if (result.content) {
+                    // BUG FIX: If there's a pending paste accumulation, add character to it
+                    // This prevents splitting user input into paste + character
+                    if (fallbackPasteBufferRef.current.length > 0) {
+                        // Add single character to accumulation buffer
+                        fallbackPasteBufferRef.current += result.content;
+                        // Extend timeout slightly (paste likely complete, but give it 100ms more)
+                        if (fallbackPasteTimeoutRef.current) {
+                            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) {
+                                // 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
+                    // 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) {
+                // Fallback: Simple batched detection (legacy behavior when bracketed paste disabled)
+                // When inputChar.length > 1, it's likely pasted content
+                const isPaste = inputChar.length > 1;
+                if (isPaste) {
+                    // BUG FIX: Use same dynamic accumulation as bracketed paste fallback
+                    // This ensures consistent behavior regardless of bracketed paste support
+                    const now = Date.now();
+                    const isActiveAccumulation = fallbackPasteBufferRef.current.length > 0;
+                    const timeSinceLastChunk = now - fallbackPasteLastChunkTimeRef.current;
+                    // Normalize line endings: convert \r to \n
+                    const normalizedInput = inputChar.replace(/\r/g, '\n');
+                    // BUG FIX: Check buffer size to prevent overflow (100MB limit)
+                    const MAX_BUFFER_SIZE = 100 * 1024 * 1024;
+                    if (fallbackPasteBufferRef.current.length + normalizedInput.length > MAX_BUFFER_SIZE) {
+                        // Buffer overflow - process what we have immediately
+                        const accumulatedContent = fallbackPasteBufferRef.current;
+                        fallbackPasteBufferRef.current = '';
+                        fallbackPasteLastChunkTimeRef.current = 0;
+                        if (fallbackPasteTimeoutRef.current) {
+                            clearTimeout(fallbackPasteTimeoutRef.current);
+                            fallbackPasteTimeoutRef.current = null;
+                        }
+                        // 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(finalContent);
+                        }
+                        catch (error) {
+                            console.error('Error handling oversized paste:', error);
+                        }
+                        return;
+                    }
+                    // Add to accumulation buffer
+                    fallbackPasteBufferRef.current += normalizedInput;
+                    fallbackPasteLastChunkTimeRef.current = now;
+                    // Clear existing timeout
+                    if (fallbackPasteTimeoutRef.current) {
+                        clearTimeout(fallbackPasteTimeoutRef.current);
+                    }
+                    // Dynamic timeout: Use longer window if we're actively accumulating a paste
+                    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 = '';
+                        fallbackPasteLastChunkTimeRef.current = 0;
+                        fallbackPasteTimeoutRef.current = null;
+                        if (!accumulatedContent)
+                            return;
+                        // Phase 3: Large paste handling with truncation
+                        const settingsManager = getSettingsManager();
+                        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) {
+                            onLargePasteRef.current?.(accumulatedContent.length);
+                        }
+                        // Handle truncation if needed
+                        let finalContent = accumulatedContent;
+                        if (!allowLargePaste && accumulatedContent.length > maxPasteLength) {
+                            // Truncate the paste
+                            finalContent = accumulatedContent.slice(0, 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
+                        try {
+                            handlePasteComplete(finalContent);
+                        }
+                        catch (error) {
+                            // BUG FIX: Catch errors to prevent timeout callback crash
+                            console.error('Error handling paste:', error);
+                            // Don't attempt fallback - state might be inconsistent
+                            // The paste content is lost but system remains stable
+                        }
+                    }, timeoutMs);
+                    return;
+                }
+                else {
+                    // Normal single character input
+                    // 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 {
-                // Normal character input
-                const result = insertText(input, cursorPosition, inputChar);
+                // Both bracketed paste and fallback disabled - normal input only
+                // 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, input, cursorPosition, multiline, handleSubmit, navigateHistory, setOriginalInput, toggleBlockAtCursor, handlePasteComplete]);
+    }, [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);
         setCurrentBlockAtCursor(block);
     }, [input, cursorPosition, pastedBlocks]);
-    // Cleanup paste timeout on unmount
+    // 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);
+                pasteTimeoutRef.current = null;
+            }
+            if (fallbackPasteTimeoutRef.current) {
+                clearTimeout(fallbackPasteTimeoutRef.current);
+                fallbackPasteTimeoutRef.current = null;
             }
+            // Reset all detectors and handlers
+            pasteDetectorRef.current.reset();
+            bracketedPasteHandlerRef.current.dispose();
+            // Clear buffers
+            fallbackPasteBufferRef.current = '';
+            fallbackPasteLastChunkTimeRef.current = 0;
         };
     }, []);
     return {
@@ -389,6 +1199,7 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
         isMultiline: isMultilineRef.current,
         pastedBlocks,
         currentBlockAtCursor,
+        isPasting, // v3.8.0: Expose paste accumulation state for visual indicator
         setInput,
         setCursorPosition,
         clearInput,