@defai.digital/ax-cli 3.7.2 → 3.8.1

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

@@ -2,18 +2,107 @@ 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,
+        };
+        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['{']--;
+        }
+        // If any bracket is unclosed, input is incomplete
+        if (brackets['('] > 0 || brackets['['] > 0 || brackets['{'] > 0) {
+            return true;
+        }
+    }
+    // Check for trailing operators
+    if (smartDetection.checkOperators) {
+        const trailingOperators = [
+            '+', '-', '*', '/', '%', '=', '==', '===', '!=', '!==',
+            '<', '>', '<=', '>=', '&&', '||', '&', '|', '^',
+            '?', ':', ',', '.', '..', '...', '=>',
+        ];
+        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() || '';
+        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
+        const firstWord = words[0];
+        if (incompleteKeywords.includes(firstWord) && !lastLine.includes('{') && !lastLine.includes(';')) {
+            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);
     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
     // Keep ref in sync with prop to avoid stale closure
     isMultilineRef.current = multiline;
-    const { addToHistory, navigateHistory, resetHistory, setOriginalInput, isNavigatingHistory, } = useInputHistory();
+    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
@@ -39,8 +128,17 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
         setCursorPositionState(0);
         setOriginalInput("");
         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;
+        }
     }, [setOriginalInput]);
     const insertAtCursor = useCallback((text) => {
         const result = insertText(input, cursorPosition, text);
@@ -48,29 +146,44 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
         setCursorPositionState(result.position);
         setOriginalInput(result.text);
     }, [input, cursorPosition, setOriginalInput]);
-    // Handle paste completion (after accumulation timeout)
+    // 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]);
     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);
+            // 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);
             setPastedBlocks(prev => [...prev, block]);
             // 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);
         }
         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);
         }
-    }, [input, cursorPosition, pasteCounter, setOriginalInput]);
+    }, [setOriginalInput]);
     // Toggle collapse/expand for block at cursor
     const toggleBlockAtCursor = useCallback(() => {
         const block = findBlockAtCursor(input, cursorPosition, pastedBlocks);
@@ -142,6 +255,27 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
         return expandAllPlaceholders(text, pastedBlocks);
     }, [pastedBlocks]);
     const handleSubmit = useCallback(() => {
+        // BUG FIX: Check for pending 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;
+        }
         if (input.trim()) {
             // Expand all placeholders before submission
             const expandedInput = expandPlaceholdersForSubmit(input);
@@ -149,7 +283,7 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
             onSubmit?.(expandedInput);
             clearInput();
         }
-    }, [input, addToHistory, onSubmit, clearInput, expandPlaceholdersForSubmit]);
+    }, [input, addToHistory, onSubmit, clearInput, expandPlaceholdersForSubmit, handlePasteComplete]);
     const handleInput = useCallback((inputChar, key) => {
         if (disabled)
             return;
@@ -175,17 +309,53 @@ 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;
+            if (enterBehavior === 'newline') {
+                // Newline mode: Enter inserts newline, Shift+Enter submits
+                if (isShiftEnter) {
+                    handleSubmit();
+                }
+                else {
+                    const result = insertText(input, cursorPosition, "\n");
+                    setInputState(result.text);
+                    setCursorPositionState(result.position);
+                    setOriginalInput(result.text);
+                }
             }
-            else {
-                handleSubmit();
+            else if (enterBehavior === 'submit') {
+                // Submit mode (legacy): Enter submits, Shift+Enter inserts newline
+                if (isShiftEnter) {
+                    const result = insertText(input, cursorPosition, "\n");
+                    setInputState(result.text);
+                    setCursorPositionState(result.position);
+                    setOriginalInput(result.text);
+                }
+                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(input, inputConfig.smartDetection)) {
+                    // Input appears incomplete, insert newline
+                    const result = insertText(input, cursorPosition, "\n");
+                    setInputState(result.text);
+                    setCursorPositionState(result.position);
+                    setOriginalInput(result.text);
+                }
+                else {
+                    // Input looks complete, submit
+                    handleSubmit();
+                }
             }
             return;
         }
@@ -341,46 +511,320 @@ export function useEnhancedInput({ onSubmit, onEscape, onSpecialKey, onVerboseTo
             setOriginalInput("");
             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)
+        if (key.tab && !key.shift && !key.ctrl && !key.meta && input.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") {
+            // Call async external editor handler
+            onExternalEditor?.(input).then((editedContent) => {
+                if (editedContent !== null) {
+                    setInputState(editedContent);
+                    setCursorPositionState(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)
+        if (inputChar === "?" && input.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;
                 }
-                // 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);
+                // 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);
                     }
-                    pasteTimeoutRef.current = null;
-                }, 50);
+                    // 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;
+                }
+                // 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;
+                        }
+                        // Process accumulated content (truncated)
+                        try {
+                            handlePasteComplete(accumulatedContent);
+                        }
+                        catch (error) {
+                            console.error('Error handling oversized paste:', error);
+                        }
+                        return;
+                    }
+                    // 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: 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
+                        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 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(() => {
+                            const accumulatedContent = fallbackPasteBufferRef.current;
+                            fallbackPasteBufferRef.current = '';
+                            fallbackPasteTimeoutRef.current = null;
+                            fallbackPasteLastChunkTimeRef.current = 0;
+                            if (accumulatedContent) {
+                                handlePasteComplete(accumulatedContent);
+                            }
+                        }, 100); // Short timeout for single char after paste
+                        return;
+                    }
+                    // No pending paste - process normal input
+                    const result2 = insertText(input, cursorPosition, result.content);
+                    setInputState(result2.text);
+                    setCursorPositionState(result2.position);
+                    setOriginalInput(result2.text);
+                }
+            }
+            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;
+                        }
+                        // Process accumulated content (truncated)
+                        try {
+                            handlePasteComplete(accumulatedContent);
+                        }
+                        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: 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
+                        if (accumulatedContent.length >= warningThreshold) {
+                            onLargePaste?.(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);
+                        }
+                        // 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
+                    const result = insertText(input, cursorPosition, inputChar);
+                    setInputState(result.text);
+                    setCursorPositionState(result.position);
+                    setOriginalInput(result.text);
+                }
             }
             else {
-                // Normal character input
+                // Both bracketed paste and fallback disabled - normal input only
                 const result = insertText(input, cursorPosition, inputChar);
                 setInputState(result.text);
                 setCursorPositionState(result.position);
                 setOriginalInput(result.text);
             }
         }
-    }, [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, input, cursorPosition, 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(() => {
         return () => {
+            // 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 +833,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,