kollabor 0.4.9__py3-none-any.whl → 0.4.15__py3-none-any.whl

core/io/input_handler.py

@@ -1,41 +1,52 @@
-"""Input handling system for Kollabor CLI."""
+"""Input handling system for Kollabor CLI.
+
+This is a facade that coordinates between refactored input components:
+- InputLoopManager: Main loop, platform I/O, paste detection
+- KeyPressHandler: Key processing, Enter/Escape handling
+- CommandModeHandler: Slash commands, menus
+- ModalController: All modal types
+- HookRegistrar: Event hook registration
+- DisplayController: Display updates, pause/resume
+- PasteProcessor: Paste detection, placeholders
+- StatusModalRenderer: Status modal line generation
+"""
 
-import asyncio
 import logging
-import sys
-import time
-from typing import Dict, Any, List
+from typing import Dict, Any, Optional
 
-# Platform-specific imports for input handling
-IS_WINDOWS = sys.platform == "win32"
-
-if IS_WINDOWS:
-    import msvcrt
-else:
-    import select
-
-from ..events import EventType
 from ..events.models import CommandMode
 from ..commands.parser import SlashCommandParser
 from ..commands.registry import SlashCommandRegistry
 from ..commands.executor import SlashCommandExecutor
 from ..commands.menu_renderer import CommandMenuRenderer
-from .key_parser import KeyParser, KeyPress, KeyType as KeyTypeEnum
+from .key_parser import KeyParser
 from .buffer_manager import BufferManager
-from .input_errors import InputErrorHandler, ErrorType, ErrorSeverity
+from .input_errors import InputErrorHandler
+
+# Refactored components
+from .input.input_loop_manager import InputLoopManager
+from .input.key_press_handler import KeyPressHandler
+from .input.command_mode_handler import CommandModeHandler
+from .input.modal_controller import ModalController
+from .input.hook_registrar import HookRegistrar
+from .input.display_controller import DisplayController
+from .input.paste_processor import PasteProcessor
+from .input.status_modal_renderer import StatusModalRenderer
 
 logger = logging.getLogger(__name__)
 
 
 class InputHandler:
-    """Advanced terminal input handler with comprehensive key support.
+    """Facade for the input handling system.
 
-    Features:
+    This class coordinates between modular components that handle:
     - Extended key sequence support (arrow keys, function keys)
     - Robust buffer management with validation
     - Advanced error handling and recovery
     - Command history navigation
     - Cursor positioning and editing
+    - Slash command menus
+    - Modal interactions
     """
 
     def __init__(self, event_bus, renderer, config) -> None:
@@ -50,53 +61,25 @@ class InputHandler:
         self.renderer = renderer
         self.config = config
         self.running = False
-        self.rendering_paused = (
-            False  # Flag to pause rendering during special effects
-        )
+        self.rendering_paused = False
 
         # Load configurable parameters
-        self.polling_delay = config.get("input.polling_delay", 0.01)
-        self.error_delay = config.get("input.error_delay", 0.1)
-        buffer_limit = config.get(
-            "input.input_buffer_limit", 100000
-        )  # 100KB limit - wide open!
+        buffer_limit = config.get("input.input_buffer_limit", 100000)
         history_limit = config.get("input.history_limit", 100)
 
-        # NOTE: Paste detection has TWO systems:
-        # 1. PRIMARY (ALWAYS ON): Large chunk detection (>10 chars)
-        #    creates "[Pasted #N ...]" placeholders
-        #    - Located in _input_loop() around line 181
-        #    - Triggers automatically when terminal sends big chunks
-        #    - This is what users see when they paste
-        # 2. SECONDARY (DISABLED): Character-by-character timing fallback
-        #    - Located in _process_character() around line 265
-        #    - Alternative detection method for edge cases
-        #    - Currently disabled via this flag
-        self.paste_detection_enabled = False  # Only disables SECONDARY system
-
-        # Initialize components
+        # Initialize core components
         self.key_parser = KeyParser()
         self.buffer_manager = BufferManager(buffer_limit, history_limit)
 
         # Initialize slash command system
-        self.command_mode = CommandMode.NORMAL
+        self._command_mode_local = CommandMode.NORMAL  # Local fallback before components created
         self.slash_parser = SlashCommandParser()
         self.command_registry = SlashCommandRegistry()
         self.command_executor = SlashCommandExecutor(self.command_registry)
         self.command_menu_renderer = CommandMenuRenderer(self.renderer)
         self.command_menu_active = False
-        self.selected_command_index = 0
 
-        # Initialize modal renderer for modal command mode
-        self.modal_renderer = None  # Will be initialized when needed
-
-        # Initialize live modal state (for tmux, logs, etc.)
-        self.live_modal_renderer = None  # LiveModalRenderer instance when active
-        self.live_modal_content_generator = None  # Content generator function
-        self.live_modal_input_callback = None  # Input callback for passthrough
-
-        # Initialize status modal state
-        self.current_status_modal_config = None
+        # Initialize error handler
         self.error_handler = InputErrorHandler(
             {
                 "error_threshold": config.get("input.error_threshold", 10),
@@ -105,758 +88,185 @@ class InputHandler:
             }
         )
 
-        # State tracking
-        self._last_cursor_pos = 0
-        self._pending_save_confirm = False  # For modal save confirmation
-
-        # Simple paste detection state
-        self._paste_buffer = []
-        self._last_char_time = 0
-        # GENIUS PASTE SYSTEM - immediate synchronous storage
-        self._paste_bucket = {}  # {paste_id: actual_content}
-        self._paste_counter = 0  # Counter for paste numbering
-        self._current_paste_id = None  # Currently building paste ID
-        self._last_paste_time = 0  # Last chunk timestamp
-
-        logger.info("Input handler initialized with enhanced capabilities")
+        # Create refactored components
+        self._create_components(event_bus, renderer, config)
+        self._wire_component_callbacks()
 
-    async def start(self) -> None:
-        """Start the input handling loop."""
-        self.running = True
-        self.renderer.enter_raw_mode()
+        logger.info("Input handler initialized with modular components")
 
-        # No bracketed paste - your terminal doesn't support it
+    def _create_components(self, event_bus, renderer, config) -> None:
+        """Create all refactored components.
 
-        # Check if raw mode worked
-        if (
-            getattr(
-                self.renderer.terminal_state.current_mode,
-                "value",
-                self.renderer.terminal_state.current_mode,
-            )
-            != "raw"
-        ):
-            logger.warning("Raw mode failed - using fallback ESC detection")
-
-        # Register for COMMAND_MENU_RENDER events
-        # to provide command menu display
-        logger.info("About to register COMMAND_MENU_RENDER hook")
-        await self._register_command_menu_render_hook()
+        Args:
+            event_bus: Event bus for emitting events.
+            renderer: Terminal renderer.
+            config: Configuration manager.
+        """
+        # Phase 1: Foundation components
+        self._status_modal_renderer = StatusModalRenderer(renderer)
+        self._display_controller = DisplayController(
+            renderer, self.buffer_manager, self.error_handler
+        )
+        self._paste_processor = PasteProcessor(
+            self.buffer_manager, self._display_controller.update_display
+        )
 
-        # Register for modal trigger events
-        logger.info("About to register modal trigger hook")
-        await self._register_modal_trigger_hook()
+        # Phase 2: Core processing
+        self._input_loop_manager = InputLoopManager(
+            renderer, self.key_parser, self.error_handler,
+            self._paste_processor, config
+        )
 
-        # Register for status modal trigger events
-        logger.info("About to register status modal trigger hook")
-        await self._register_status_modal_trigger_hook()
+        # Phase 3: Command/Modal components
+        self._key_press_handler = KeyPressHandler(
+            self.buffer_manager, self.key_parser, event_bus,
+            self.error_handler, self._display_controller,
+            self._paste_processor, renderer
+        )
 
-        # Register for live modal trigger events
-        logger.info("About to register live modal trigger hook")
-        await self._register_live_modal_trigger_hook()
+        self._command_mode_handler = CommandModeHandler(
+            self.buffer_manager, renderer, event_bus,
+            self.command_registry, self.command_executor,
+            self.command_menu_renderer, self.slash_parser,
+            self.error_handler
+        )
 
-        # Register for status modal render events
-        logger.info("About to register status modal render hook")
-        await self._register_status_modal_render_hook()
+        # Connect KeyPressHandler to CommandModeHandler for state sync
+        self._key_press_handler.command_mode_handler = self._command_mode_handler
 
-        # Register for command output display events
-        logger.info("About to register command output display hook")
-        await self._register_command_output_display_hook()
+        self._modal_controller = ModalController(
+            renderer, event_bus, config, self._status_modal_renderer,
+            self._display_controller.update_display,
+            self._command_mode_handler.exit_command_mode,
+            self._sync_command_mode  # Callback to sync command_mode changes
+        )
 
-        logger.info("All hook registrations completed")
+        # Phase 4: Hook system
+        self._hook_registrar = HookRegistrar(
+            event_bus,
+            self._handle_command_menu_render,
+            self._modal_controller._handle_modal_trigger,
+            self._modal_controller._handle_status_modal_trigger,
+            self._modal_controller._handle_live_modal_trigger,
+            self._modal_controller._handle_status_modal_render,
+            self._handle_command_output_display,
+            self._handle_pause_rendering,
+            self._handle_resume_rendering,
+            self._modal_controller._handle_modal_hide
+        )
 
-        logger.info("Input handler started")
-        await self._input_loop()
+    def _wire_component_callbacks(self) -> None:
+        """Wire all component callbacks after construction."""
+        # CommandModeHandler callbacks
+        self._command_mode_handler.set_update_display_callback(
+            self._display_controller.update_display
+        )
+        self._command_mode_handler.set_exit_modal_callback(
+            self._modal_controller._exit_modal_mode
+        )
+        self._command_mode_handler.set_modal_callbacks(
+            self._modal_controller._handle_modal_keypress,
+            self._modal_controller._handle_status_modal_keypress,
+            self._modal_controller._handle_live_modal_keypress
+        )
 
-    async def stop(self) -> None:
-        """Stop the input handling loop with cleanup."""
-        self.running = False
+        # KeyPressHandler callbacks
+        self._key_press_handler.set_callbacks(
+            enter_command_mode=self._command_mode_handler.enter_command_mode,
+            handle_command_mode_keypress=self._command_mode_handler.handle_command_mode_keypress,
+            handle_status_view_previous=self._command_mode_handler.handle_status_view_previous,
+            handle_status_view_next=self._command_mode_handler.handle_status_view_next,
+            expand_paste_placeholders=self._paste_processor.expand_paste_placeholders
+        )
 
-        # No bracketed paste to disable
-
-        await self.cleanup()
-        self.renderer.exit_raw_mode()
-        logger.info("Input handler stopped")
-
-    async def _input_loop(self) -> None:
-        """Main input processing loop with enhanced error handling."""
-        while self.running:
-            try:
-                # Platform-specific input checking
-                has_input = await self._check_input_available()
-
-                if has_input:
-                    # Read input data
-                    chunk = await self._read_input_chunk()
-
-                    if not chunk:
-                        await asyncio.sleep(self.polling_delay)
-                        continue
-
-                    # Check if this is an escape sequence (arrow keys, etc.)
-                    def is_escape_sequence(text: str) -> bool:
-                        """Check if input is an escape sequence
-                        that should bypass paste detection."""
-                        if not text:
-                            return False
-                        # Common escape sequences start with ESC (\x1b)
-                        if text.startswith("\x1b"):
-                            return True
-                        return False
-
-                    # PRIMARY PASTE DETECTION:
-                    # Large chunk detection (ALWAYS ACTIVE)
-                    # When user pastes, terminal sends all chars
-                    # in one/few chunks
-                    # This creates "[Pasted #N X lines, Y chars]" placeholders
-                    if len(chunk) > 10 and not is_escape_sequence(chunk):
-
-                        import time
-
-                        current_time = time.time()
-
-                        # Check if this continues the current paste (within 100ms)
-                        if (
-                            self._current_paste_id
-                            and self._last_paste_time > 0
-                            and (current_time - self._last_paste_time) < 0.1
-                        ):
-
-                            # Merge with existing paste
-                            self._paste_bucket[self._current_paste_id] += chunk
-                            self._last_paste_time = current_time
-
-                            # Update the placeholder to show new size
-                            await self._update_paste_placeholder()
-                        else:
-                            # New paste - store immediately
-                            self._paste_counter += 1
-                            self._current_paste_id = f"PASTE_{self._paste_counter}"
-                            self._paste_bucket[self._current_paste_id] = chunk
-                            self._last_paste_time = current_time
-
-                            # Create placeholder immediately
-                            await self._create_paste_placeholder(
-                                self._current_paste_id
-                            )
-                    elif is_escape_sequence(chunk):
-                        # Escape sequence - process character by character
-                        # to allow key parser to handle it
-                        logger.debug(
-                            f"Processing escape sequence "
-                            f"character-by-character: {repr(chunk)}"
-                        )
-                        for char in chunk:
-                            await self._process_character(char)
-                    else:
-                        # Normal input (single or multi-character)
-                        # process each character individually
-                        logger.info(
-                            f"🔤 Processing normal input "
-                            f"character-by-character: {repr(chunk)}"
-                        )
-                        # await self._process_character(chunk)
-                        for char in chunk:
-                            await self._process_character(char)
-                else:
-                    # No input available - check for standalone ESC key
-                    esc_key = self.key_parser.check_for_standalone_escape()
-                    if esc_key:
-                        logger.info("DETECTED STANDALONE ESC KEY!")
-                        # CRITICAL FIX: Route escape to correct handler based on mode
-                        if self.command_mode == CommandMode.MODAL:
-                            await self._handle_command_mode_keypress(esc_key)
-                        elif self.command_mode == CommandMode.LIVE_MODAL:
-                            await self._handle_live_modal_keypress(esc_key)
-                        else:
-                            await self._handle_key_press(esc_key)
-
-                await asyncio.sleep(self.polling_delay)
-
-            except KeyboardInterrupt:
-                logger.info("Ctrl+C received")
-                raise
-            except OSError as e:
-                await self.error_handler.handle_error(
-                    ErrorType.IO_ERROR,
-                    f"I/O error in input loop: {e}",
-                    ErrorSeverity.HIGH,
-                    {"buffer_manager": self.buffer_manager},
-                )
-                await asyncio.sleep(self.error_delay)
-            except Exception as e:
-                await self.error_handler.handle_error(
-                    ErrorType.SYSTEM_ERROR,
-                    f"Unexpected error in input loop: {e}",
-                    ErrorSeverity.MEDIUM,
-                    {"buffer_manager": self.buffer_manager},
-                )
-                await asyncio.sleep(self.error_delay)
+        # InputLoopManager callbacks
+        self._input_loop_manager.set_callbacks(
+            process_character=self._key_press_handler.process_character,
+            handle_key_press=self._key_press_handler._handle_key_press,
+            handle_command_mode_keypress=self._command_mode_handler.handle_command_mode_keypress,
+            handle_live_modal_keypress=self._modal_controller._handle_live_modal_keypress,
+            register_hooks=self._hook_registrar.register_all_hooks,
+            get_command_mode=lambda: self._command_mode_handler.command_mode
+        )
+        self._input_loop_manager.set_buffer_manager(self.buffer_manager)
 
-    async def _check_input_available(self) -> bool:
-        """Check if input is available (cross-platform).
+    # ==================== COMMAND MODE PROPERTY ====================
 
-        Returns:
-            True if input is available, False otherwise.
-        """
-        if IS_WINDOWS:
-            # Windows: Use msvcrt.kbhit() to check for available input
-            return msvcrt.kbhit()
-        else:
-            # Unix: Use select with timeout
-            return bool(select.select([sys.stdin], [], [], self.polling_delay)[0])
+    @property
+    def command_mode(self) -> CommandMode:
+        """Get current command mode from handler."""
+        if hasattr(self, '_command_mode_handler') and self._command_mode_handler:
+            return self._command_mode_handler.command_mode
+        return self._command_mode_local
 
-    async def _read_input_chunk(self) -> str:
-        """Read available input data (cross-platform).
+    @command_mode.setter
+    def command_mode(self, value: CommandMode) -> None:
+        """Set command mode on handler."""
+        if hasattr(self, '_command_mode_handler') and self._command_mode_handler:
+            self._command_mode_handler.command_mode = value
+        self._command_mode_local = value
 
-        Returns:
-            Decoded input string, or empty string if no input.
-        """
-        import os
-
-        if IS_WINDOWS:
-            # Windows: Read all available characters using msvcrt
-            chunk = b""
-            while msvcrt.kbhit():
-                char = msvcrt.getch()
-                char_code = char[0] if isinstance(char, bytes) else ord(char)
-
-                # Handle Windows extended keys (arrow keys, function keys, etc.)
-                # Extended keys are prefixed with 0x00 or 0xE0 (224)
-                if char_code in (0, 224):
-                    # Read the actual key code
-                    ext_char = msvcrt.getch()
-                    ext_code = ext_char[0] if isinstance(ext_char, bytes) else ord(ext_char)
-                    # Map Windows extended key codes to ANSI escape sequences
-                    win_key_map = {
-                        72: b"\x1b[A",   # ArrowUp
-                        80: b"\x1b[B",   # ArrowDown
-                        75: b"\x1b[D",   # ArrowLeft
-                        77: b"\x1b[C",   # ArrowRight
-                        71: b"\x1b[H",   # Home
-                        79: b"\x1b[F",   # End
-                        73: b"\x1b[5~",  # PageUp
-                        81: b"\x1b[6~",  # PageDown
-                        82: b"\x1b[2~",  # Insert
-                        83: b"\x1b[3~",  # Delete
-                        59: b"\x1bOP",   # F1
-                        60: b"\x1bOQ",   # F2
-                        61: b"\x1bOR",   # F3
-                        62: b"\x1bOS",   # F4
-                        63: b"\x1b[15~", # F5
-                        64: b"\x1b[17~", # F6
-                        65: b"\x1b[18~", # F7
-                        66: b"\x1b[19~", # F8
-                        67: b"\x1b[20~", # F9
-                        68: b"\x1b[21~", # F10
-                        133: b"\x1b[23~", # F11
-                        134: b"\x1b[24~", # F12
-                    }
-                    if ext_code in win_key_map:
-                        chunk += win_key_map[ext_code]
-                    else:
-                        logger.debug(f"Unknown Windows extended key: {ext_code}")
-                else:
-                    chunk += char
-
-                # Small delay to allow for more input
-                await asyncio.sleep(0.001)
-                # Check if there's more data immediately available
-                if not msvcrt.kbhit():
-                    break
-            return chunk.decode("utf-8", errors="ignore") if chunk else ""
-        else:
-            # Unix: Read ALL available data using os.read
-            chunk = b""
-            while True:
-                try:
-                    # Read in 8KB chunks
-                    more_data = os.read(0, 8192)
-                    if not more_data:
-                        break
-                    chunk += more_data
-                    # Check if more data is immediately available
-                    if not select.select([sys.stdin], [], [], 0.001)[0]:
-                        break  # No more data waiting
-                except OSError:
-                    break  # No more data available
-            return chunk.decode("utf-8", errors="ignore") if chunk else ""
-
-    async def _process_character(self, char: str) -> None:
-        """Process a single character input.
+    def _sync_command_mode(self, value: CommandMode) -> None:
+        """Sync command_mode from ModalController to CommandModeHandler.
 
-        Args:
-            char: Character received from terminal.
+        Called by ModalController when it changes command_mode.
         """
-        try:
-            current_time = time.time()
+        if hasattr(self, '_command_mode_handler') and self._command_mode_handler:
+            self._command_mode_handler.command_mode = value
+        self._command_mode_local = value
 
-            # Check for slash command initiation
-            # (before parsing for immediate response)
-            if (
-                char == "/"
-                and self.buffer_manager.is_empty
-                and self.command_mode == CommandMode.NORMAL
-            ):
-                await self._enter_command_mode()
-                return
-
-            # SECONDARY PASTE DETECTION:
-            # Character-by-character timing (DISABLED)
-            # This is a fallback system - primary chunk detection
-            # above handles most cases
-            if self.paste_detection_enabled:
-                # Currently False - secondary system disabled
-                paste_handled = await self._simple_paste_detection(
-                    char, current_time
-                )
-                if paste_handled:
-                    # Character consumed by paste detection,
-                    # skip normal processing
-                    return
-
-            # Parse character into structured key press
-            # (this handles escape sequences)
-            key_press = self.key_parser.parse_char(char)
-            if not key_press:
-                # For modal mode, add timeout-based
-                # standalone escape detection
-                if self.command_mode == CommandMode.MODAL:
-                    # Schedule delayed check for standalone escape
-                    # (100ms delay)
-                    async def delayed_escape_check():
-                        await asyncio.sleep(0.1)
-                        standalone_escape = (
-                            self.key_parser.check_for_standalone_escape()
-                        )
-                        if standalone_escape:
-                            await self._handle_command_mode_keypress(
-                                standalone_escape
-                            )
-
-                    asyncio.create_task(delayed_escape_check())
-                # Incomplete escape sequence - wait for more characters
-                return
-
-            # Check for slash command mode handling AFTER parsing
-            # (so arrow keys work)
-            if self.command_mode != CommandMode.NORMAL:
-                logger.info(
-                    f"🎯 Processing key '{key_press.name}' "
-                    f"in command mode: {self.command_mode}"
-                )
-                handled = await self._handle_command_mode_keypress(key_press)
-                if handled:
-                    return
-
-            # Emit key press event for plugins
-            key_result = await self.event_bus.emit_with_hooks(
-                EventType.KEY_PRESS,
-                {
-                    "key": key_press.name,
-                    "char_code": key_press.code,
-                    "key_type": key_press.type.value,
-                    "modifiers": key_press.modifiers,
-                },
-                "input",
-            )
-
-            # Check if any plugin handled this key
-            prevent_default = self._check_prevent_default(key_result)
-
-            # Process key if not prevented by plugins
-            if not prevent_default:
-                await self._handle_key_press(key_press)
-
-            # Update renderer
-            await self._update_display()
+    @property
+    def current_status_modal_config(self):
+        """Get current status modal config from ModalController."""
+        if hasattr(self, '_modal_controller') and self._modal_controller:
+            return self._modal_controller.current_status_modal_config
+        return None
 
-        except Exception as e:
-            await self.error_handler.handle_error(
-                ErrorType.PARSING_ERROR,
-                f"Error processing character: {e}",
-                ErrorSeverity.MEDIUM,
-                {"char": repr(char), "buffer_manager": self.buffer_manager},
-            )
+    @current_status_modal_config.setter
+    def current_status_modal_config(self, value):
+        """Set current status modal config on ModalController."""
+        if hasattr(self, '_modal_controller') and self._modal_controller:
+            self._modal_controller.current_status_modal_config = value
 
-    def _check_prevent_default(self, key_result: Dict[str, Any]) -> bool:
-        """Check if plugins want to prevent default key handling.
+    # ==================== LIFECYCLE METHODS ====================
 
-        Args:
-            key_result: Result from key press event.
+    async def start(self) -> None:
+        """Start the input handling loop.
 
-        Returns:
-            True if default handling should be prevented.
+        Delegates to InputLoopManager which handles:
+        - Entering raw mode
+        - Registering hooks via callback
+        - Running the main input loop
         """
-        if "main" in key_result:
-            for hook_result in key_result["main"].values():
-                if isinstance(hook_result, dict) and hook_result.get(
-                    "prevent_default"
-                ):
-                    return True
-        return False
+        self.running = True
+        await self._input_loop_manager.start()
 
-    async def _handle_key_press(self, key_press: KeyPress) -> None:
-        """Handle a parsed key press.
+    async def stop(self) -> None:
+        """Stop the input handling loop with cleanup.
 
-        Args:
-            key_press: Parsed key press event.
+        Delegates to InputLoopManager which handles:
+        - Stopping the loop
+        - Cleanup
+        - Exiting raw mode
         """
-        # Process key press
-        try:
-            # Log all key presses for debugging
-            logger.info(
-                f"🔍 Key press: name='{key_press.name}', "
-                f"char='{key_press.char}', code={key_press.code}, "
-                f"type={key_press.type}, "
-                f"modifiers={getattr(key_press, 'modifiers', None)}"
-            )
-
-            # CRITICAL FIX: Modal input isolation
-            # capture ALL input when in modal mode
-            if self.command_mode == CommandMode.MODAL:
-                logger.info(
-                    f"🎯 Modal mode active - routing ALL input "
-                    f"to modal handler: {key_press.name}"
-                )
-                await self._handle_command_mode_keypress(key_press)
-                return
-
-            # Handle control keys
-            if self.key_parser.is_control_key(key_press, "Ctrl+C"):
-                logger.info("Ctrl+C received")
-                raise KeyboardInterrupt
-
-            elif self.key_parser.is_control_key(key_press, "Enter"):
-                await self._handle_enter()
-
-            elif self.key_parser.is_control_key(key_press, "Backspace"):
-                self.buffer_manager.delete_char()
-
-            elif key_press.name == "Escape":
-                await self._handle_escape()
-
-            elif key_press.name == "Delete":
-                self.buffer_manager.delete_forward()
-
-            # Handle arrow keys for cursor movement and history
-            elif key_press.name == "ArrowLeft":
-                moved = self.buffer_manager.move_cursor("left")
-                if moved:
-                    logger.debug(
-                        f"Arrow Left: cursor moved to position {self.buffer_manager.cursor_position}"
-                    )
-                    await self._update_display(force_render=True)
-
-            elif key_press.name == "ArrowRight":
-                moved = self.buffer_manager.move_cursor("right")
-                if moved:
-                    logger.debug(
-                        f"Arrow Right: cursor moved to position {self.buffer_manager.cursor_position}"
-                    )
-                    await self._update_display(force_render=True)
-
-            elif key_press.name == "ArrowUp":
-                self.buffer_manager.navigate_history("up")
-                await self._update_display(force_render=True)
-
-            elif key_press.name == "ArrowDown":
-                self.buffer_manager.navigate_history("down")
-                await self._update_display(force_render=True)
-
-            # Handle Home/End keys
-            elif key_press.name == "Home":
-                self.buffer_manager.move_to_start()
-                await self._update_display(force_render=True)
-
-            elif key_press.name == "End":
-                self.buffer_manager.move_to_end()
-                await self._update_display(force_render=True)
-
-            # Handle Option/Alt+comma/period keys for status view navigation
-            # macOS sends ≤/≥, Windows/Linux send Alt modifier or ESC+key
-            elif (key_press.char == "≤" or
-                  key_press.name == "Alt+," or
-                  (key_press.char == "," and key_press.modifiers.get("alt"))):
-                logger.info(
-                    "🔑 Alt+Comma detected - switching to previous status view"
-                )
-                await self._handle_status_view_previous()
-
-            elif (key_press.char == "≥" or
-                  key_press.name == "Alt+." or
-                  (key_press.char == "." and key_press.modifiers.get("alt"))):
-                logger.info(
-                    "🔑 Alt+Period detected - switching to next status view"
-                )
-                await self._handle_status_view_next()
-
-            # Handle Cmd key combinations (mapped to Ctrl sequences on macOS)
-            elif self.key_parser.is_control_key(key_press, "Ctrl+A"):
-                logger.info("🔑 Ctrl+A (Cmd+Left) - moving cursor to start")
-                self.buffer_manager.move_to_start()
-                await self._update_display(force_render=True)
-
-            elif self.key_parser.is_control_key(key_press, "Ctrl+E"):
-                logger.info("🔑 Ctrl+E (Cmd+Right) - moving cursor to end")
-                self.buffer_manager.move_to_end()
-                await self._update_display(force_render=True)
-
-            elif self.key_parser.is_control_key(key_press, "Ctrl+U"):
-                logger.info("🔑 Ctrl+U (Cmd+Backspace) - clearing line")
-                self.buffer_manager.clear()
-                await self._update_display(force_render=True)
-
-            # Handle printable characters
-            elif self.key_parser.is_printable_char(key_press):
-                # Normal character processing
-                success = self.buffer_manager.insert_char(key_press.char)
-                if not success:
-                    await self.error_handler.handle_error(
-                        ErrorType.BUFFER_ERROR,
-                        "Failed to insert character - buffer limit reached",
-                        ErrorSeverity.LOW,
-                        {
-                            "char": key_press.char,
-                            "buffer_manager": self.buffer_manager,
-                        },
-                    )
-
-            # Handle other special keys (F1-F12, etc.)
-            elif key_press.type == KeyTypeEnum.EXTENDED:
-                logger.debug(f"Extended key pressed: {key_press.name}")
-                # Could emit special events for function keys, etc.
-
-        except Exception as e:
-            await self.error_handler.handle_error(
-                ErrorType.EVENT_ERROR,
-                f"Error handling key press: {e}",
-                ErrorSeverity.MEDIUM,
-                {
-                    "key_press": key_press,
-                    "buffer_manager": self.buffer_manager,
-                },
-            )
-
-    async def _update_display(self, force_render: bool = False) -> None:
-        """Update the terminal display with current buffer state."""
-        try:
-            # Skip rendering if paused (during special effects like Matrix)
-            if self.rendering_paused and not force_render:
-                return
-
-            buffer_content, cursor_pos = self.buffer_manager.get_display_info()
-
-            # Update renderer with buffer content and cursor position
-            self.renderer.input_buffer = buffer_content
-            self.renderer.cursor_position = cursor_pos
-
-            # Force immediate rendering if requested (needed for paste operations)
-            if force_render:
-                try:
-                    if hasattr(
-                        self.renderer, "render_active_area"
-                    ) and asyncio.iscoroutinefunction(
-                        self.renderer.render_active_area
-                    ):
-                        await self.renderer.render_active_area()
-                    elif hasattr(
-                        self.renderer, "render_input"
-                    ) and asyncio.iscoroutinefunction(self.renderer.render_input):
-                        await self.renderer.render_input()
-                    elif hasattr(self.renderer, "render_active_area"):
-                        self.renderer.render_active_area()
-                    elif hasattr(self.renderer, "render_input"):
-                        self.renderer.render_input()
-                except Exception as e:
-                    logger.debug(f"Force render failed: {e}")
-                    # Continue without forced render
-
-            # Only update cursor if position changed
-            if cursor_pos != self._last_cursor_pos:
-                # Could implement cursor positioning in renderer
-                self._last_cursor_pos = cursor_pos
+        self.running = False
+        await self._input_loop_manager.stop()
 
-        except Exception as e:
-            await self.error_handler.handle_error(
-                ErrorType.SYSTEM_ERROR,
-                f"Error updating display: {e}",
-                ErrorSeverity.LOW,
-                {"buffer_manager": self.buffer_manager},
-            )
+    # ==================== RENDERING CONTROL ====================
 
     def pause_rendering(self):
         """Pause all UI rendering for special effects."""
         self.rendering_paused = True
+        self._display_controller.pause_rendering()
         logger.debug("Input rendering paused")
 
     def resume_rendering(self):
         """Resume normal UI rendering."""
         self.rendering_paused = False
+        self._display_controller.resume_rendering()
         logger.debug("Input rendering resumed")
 
-    async def _handle_enter(self) -> None:
-        """Handle Enter key press with enhanced validation."""
-        try:
-            if self.buffer_manager.is_empty:
-                return
-
-            # Validate input before processing
-            validation_errors = self.buffer_manager.validate_content()
-            if validation_errors:
-                for error in validation_errors:
-                    logger.warning(f"Input validation warning: {error}")
-
-            # Get message and clear buffer
-            message = self.buffer_manager.get_content_and_clear()
-
-            # Check if this is a slash command - handle immediately without paste expansion
-            if message.strip().startswith('/'):
-                logger.info(f"🎯 Detected slash command, bypassing paste expansion: '{message}'")
-                expanded_message = message
-            else:
-                # GENIUS PASTE BUCKET: Immediate expansion - no waiting needed!
-                logger.debug(f"GENIUS SUBMIT: Original message: '{message}'")
-                logger.debug(
-                    f"GENIUS SUBMIT: Paste bucket contains: {list(self._paste_bucket.keys())}"
-                )
-
-                expanded_message = self._expand_paste_placeholders(message)
-                logger.debug(
-                    f"GENIUS SUBMIT: Final expanded: '{expanded_message[:100]}...' ({len(expanded_message)} chars)"
-                )
-
-            # Add to history (with expanded content)
-            self.buffer_manager.add_to_history(expanded_message)
-
-            # Update renderer
-            self.renderer.input_buffer = ""
-            self.renderer.clear_active_area()
-
-            # Emit user input event (with expanded content!)
-            await self.event_bus.emit_with_hooks(
-                EventType.USER_INPUT,
-                {
-                    "message": expanded_message,
-                    "validation_errors": validation_errors,
-                },
-                "user",
-            )
-
-            logger.debug(
-                f"Processed user input: {message[:100]}..."
-                if len(message) > 100
-                else f"Processed user input: {message}"
-            )
-
-        except Exception as e:
-            await self.error_handler.handle_error(
-                ErrorType.EVENT_ERROR,
-                f"Error handling Enter key: {e}",
-                ErrorSeverity.HIGH,
-                {"buffer_manager": self.buffer_manager},
-            )
-
-    async def _handle_escape(self) -> None:
-        """Handle Escape key press for request cancellation."""
-        try:
-            logger.info("_handle_escape called - emitting CANCEL_REQUEST event")
-
-            # Emit cancellation event
-            result = await self.event_bus.emit_with_hooks(
-                EventType.CANCEL_REQUEST,
-                {"reason": "user_escape", "source": "input_handler"},
-                "input",
-            )
-
-            logger.info(
-                f"ESC key pressed - cancellation request sent, result: {result}"
-            )
-
-        except Exception as e:
-            await self.error_handler.handle_error(
-                ErrorType.EVENT_ERROR,
-                f"Error handling Escape key: {e}",
-                ErrorSeverity.MEDIUM,
-                {"buffer_manager": self.buffer_manager},
-            )
-
-    async def _handle_status_view_previous(self) -> None:
-        """Handle comma key press for previous status view."""
-        try:
-            logger.info("Attempting to switch to previous status view")
-            # Check if renderer has a status registry
-            if (
-                hasattr(self.renderer, "status_renderer")
-                and self.renderer.status_renderer
-            ):
-                status_renderer = self.renderer.status_renderer
-                logger.info(
-                    f"[OK] Found status_renderer: {type(status_renderer).__name__}"
-                )
-                if (
-                    hasattr(status_renderer, "status_registry")
-                    and status_renderer.status_registry
-                ):
-                    registry = status_renderer.status_registry
-                    logger.info(
-                        f"[OK] Found status_registry with {len(registry.views)} views"
-                    )
-                    if hasattr(registry, "cycle_previous"):
-                        previous_view = registry.cycle_previous()
-                        if previous_view:
-                            logger.info(
-                                f"[OK] Switched to previous status view: '{previous_view.name}'"
-                            )
-                        else:
-                            logger.info("No status views available to cycle to")
-                    else:
-                        logger.info("cycle_previous method not found in registry")
-                else:
-                    logger.info("No status registry available for view cycling")
-            else:
-                logger.info("No status renderer available for view cycling")
-
-        except Exception as e:
-            await self.error_handler.handle_error(
-                ErrorType.EVENT_ERROR,
-                f"Error handling status view previous: {e}",
-                ErrorSeverity.LOW,
-                {"key": "Ctrl+ArrowLeft"},
-            )
-
-    async def _handle_status_view_next(self) -> None:
-        """Handle Ctrl+Right arrow key press for next status view."""
-        try:
-            # Check if renderer has a status registry
-            if (
-                hasattr(self.renderer, "status_renderer")
-                and self.renderer.status_renderer
-            ):
-                status_renderer = self.renderer.status_renderer
-                if (
-                    hasattr(status_renderer, "status_registry")
-                    and status_renderer.status_registry
-                ):
-                    next_view = status_renderer.status_registry.cycle_next()
-                    if next_view:
-                        logger.debug(
-                            f"Switched to next status view: '{next_view.name}'"
-                        )
-                    else:
-                        logger.debug("No status views available to cycle to")
-                else:
-                    logger.debug("No status registry available for view cycling")
-            else:
-                logger.debug("No status renderer available for view cycling")
-
-        except Exception as e:
-            await self.error_handler.handle_error(
-                ErrorType.EVENT_ERROR,
-                f"Error handling status view next: {e}",
-                ErrorSeverity.LOW,
-                {"key": "Ctrl+ArrowRight"},
-            )
+    # ==================== STATUS ====================
 
     def get_status(self) -> Dict[str, Any]:
         """Get current input handler status for debugging.
@@ -877,226 +287,16 @@ class InputHandler:
             },
         }
 
-    async def cleanup(self) -> None:
-        """Perform cleanup operations."""
-        try:
-            # Clear old errors
-            cleared_errors = self.error_handler.clear_old_errors()
-            if cleared_errors > 0:
-                logger.info(f"Cleaned up {cleared_errors} old errors")
-
-            # Reset parser state
-            self.key_parser._reset_escape_state()
-
-            logger.debug("Input handler cleanup completed")
-
-        except Exception as e:
-            logger.error(f"Error during cleanup: {e}")
-
-    def _expand_paste_placeholders(self, message: str) -> str:
-        """Expand paste placeholders with actual content from paste bucket.
-
-        Your brilliant idea: Replace [⚡ Pasted #N ...] with actual pasted content!
-        """
-        logger.debug(f"PASTE DEBUG: Expanding message: '{message}'")
-        logger.debug(
-            f"PASTE DEBUG: Paste bucket contains: {list(self._paste_bucket.keys())}"
-        )
-
-        expanded = message
-
-        # Find and replace each paste placeholder
-        import re
-
-        for paste_id, content in self._paste_bucket.items():
-            # Extract paste number from paste_id (PASTE_1 -> 1)
-            paste_num = paste_id.split("_")[1]
-
-            # Pattern to match: [Pasted #N X lines, Y chars]
-            pattern = rf"\[Pasted #{paste_num} \d+ lines?, \d+ chars\]"
-
-            logger.debug(f"PASTE DEBUG: Looking for pattern: {pattern}")
-            logger.debug(
-                f"PASTE DEBUG: Will replace with content: '{content[:50]}...'"
-            )
-
-            # Replace with actual content
-            matches = re.findall(pattern, expanded)
-            logger.debug(f"PASTE DEBUG: Found {len(matches)} matches")
-
-            expanded = re.sub(pattern, content, expanded)
-
-        logger.debug(f"PASTE DEBUG: Final expanded message: '{expanded[:100]}...'")
-        logger.info(
-            f"Paste expansion: {len(self._paste_bucket)} placeholders expanded"
-        )
-
-        # Clear paste bucket after expansion (one-time use)
-        self._paste_bucket.clear()
-
-        return expanded
-
-    async def _create_paste_placeholder(self, paste_id: str) -> None:
-        """Create placeholder for paste - GENIUS IMMEDIATE VERSION."""
-        content = self._paste_bucket[paste_id]
-
-        # Create elegant placeholder for user to see
-        line_count = content.count("\n") + 1 if "\n" in content else 1
-        char_count = len(content)
-        paste_num = paste_id.split("_")[1]  # Extract number from PASTE_1
-        placeholder = f"[Pasted #{paste_num} {line_count} lines, {char_count} chars]"
-
-        # Insert placeholder into buffer (what user sees)
-        for char in placeholder:
-            self.buffer_manager.insert_char(char)
-
-        logger.info(
-            f"GENIUS: Created placeholder for {char_count} chars as {paste_id}"
-        )
-
-        # Update display once at the end
-        await self._update_display(force_render=True)
-
-    async def _update_paste_placeholder(self) -> None:
-        """Update existing placeholder when paste grows - GENIUS VERSION."""
-        # For now, just log - updating existing placeholder is complex
-        # The merge approach usually works fast enough that this isn't needed
-        content = self._paste_bucket[self._current_paste_id]
-        logger.info(
-            f"GENIUS: Updated {self._current_paste_id} to {len(content)} chars"
-        )
-
-    async def _simple_paste_detection(self, char: str, current_time: float) -> bool:
-        """Simple, reliable paste detection using timing only.
-
-        Returns:
-            True if character was consumed by paste detection, False otherwise.
-        """
-        # Check cooldown to prevent overlapping paste detections
-        if self._paste_cooldown > 0 and (current_time - self._paste_cooldown) < 1.0:
-            # Still in cooldown period, skip paste detection
-            self._last_char_time = current_time
-            return False
-
-        # Check if we have a pending paste buffer that timed out
-        if self._paste_buffer and self._last_char_time > 0:
-            gap_ms = (current_time - self._last_char_time) * 1000
-
-            if gap_ms > self._paste_timeout_ms:
-                # Buffer timed out, process it
-                if len(self._paste_buffer) >= self.paste_min_chars:
-                    self._process_simple_paste_sync()
-                    self._paste_cooldown = current_time  # Set cooldown
-                else:
-                    # Too few chars, process them as individual keystrokes
-                    self._flush_paste_buffer_as_keystrokes_sync()
-                self._paste_buffer = []
-
-        # Now handle the current character
-        if self._last_char_time > 0:
-            gap_ms = (current_time - self._last_char_time) * 1000
-
-            # If character arrived quickly, start/continue paste buffer
-            if gap_ms < self.paste_threshold_ms:
-                self._paste_buffer.append(char)
-                self._last_char_time = current_time
-                return True  # Character consumed by paste buffer
-
-        # Character not part of paste, process normally
-        self._last_char_time = current_time
-        return False
-
-    def _flush_paste_buffer_as_keystrokes_sync(self) -> None:
-        """Process paste buffer contents as individual keystrokes (sync version)."""
-        logger.debug(
-            f"Flushing {len(self._paste_buffer)} chars as individual keystrokes"
-        )
-
-        # Just add characters to buffer without async processing
-        for char in self._paste_buffer:
-            if char.isprintable() or char in [" ", "\t"]:
-                self.buffer_manager.insert_char(char)
-
-    def _process_simple_paste_sync(self) -> None:
-        """Process detected paste content (sync version with inline indicator)."""
-        if not self._paste_buffer:
-            return
-
-        # Get the content and clean any terminal markers
-        content = "".join(self._paste_buffer)
-
-        # Clean bracketed paste markers if present
-        if content.startswith("[200~"):
-            content = content[5:]
-        if content.endswith("01~"):
-            content = content[:-3]
-        elif content.endswith("[201~"):
-            content = content[:-6]
-
-        # Count lines
-        line_count = content.count("\n") + 1
-        char_count = len(content)
-
-        # Increment paste counter
-        self._paste_counter += 1
-
-        # Create inline paste indicator exactly as user requested
-        indicator = f"[⚡ Pasted #{self._paste_counter} {line_count} lines]"
-
-        # Insert the indicator into the buffer at current position
-        try:
-            for char in indicator:
-                self.buffer_manager.insert_char(char)
-            logger.info(
-                f"Paste #{self._paste_counter}: {char_count} chars, {line_count} lines"
-            )
-        except Exception as e:
-            logger.error(f"Paste processing error: {e}")
-
-        # Clear paste buffer
-        self._paste_buffer = []
-
-    async def _flush_paste_buffer_as_keystrokes(self) -> None:
-        """Process paste buffer contents as individual keystrokes."""
-        self._flush_paste_buffer_as_keystrokes_sync()
-
-    async def _process_simple_paste(self) -> None:
-        """Process detected paste content."""
-        self._process_simple_paste_sync()
-        await self._update_display(force_render=True)
-
-    # ==================== COMMAND MENU RENDER HOOK ====================
-
-    async def _register_command_menu_render_hook(self) -> None:
-        """Register hook to provide command menu content for COMMAND_MENU_RENDER events."""
-        try:
-            if self.event_bus:
-                from ..events.models import Hook, HookPriority
-
-                hook = Hook(
-                    name="command_menu_render",
-                    plugin_name="input_handler",
-                    event_type=EventType.COMMAND_MENU_RENDER,
-                    priority=HookPriority.DISPLAY.value,
-                    callback=self._handle_command_menu_render,
-                )
-                success = await self.event_bus.register_hook(hook)
-                if success:
-                    logger.info(
-                        "Successfully registered COMMAND_MENU_RENDER hook for command menu display"
-                    )
-                else:
-                    logger.error("Failed to register COMMAND_MENU_RENDER hook")
-        except Exception as e:
-            logger.error(f"Failed to register COMMAND_MENU_RENDER hook: {e}")
+    # ==================== HOOK HANDLERS (kept in facade) ====================
 
     async def _handle_command_menu_render(
-        self, event_data: Dict[str, Any], context: str = None
+        self, event_data: Dict[str, Any], context: Optional[str] = None
     ) -> Dict[str, Any]:
         """Handle COMMAND_MENU_RENDER events to provide command menu content.
 
         Args:
             event_data: Event data containing render request info.
+            context: Hook execution context.
 
         Returns:
             Dictionary with menu_lines if command mode is active.
@@ -1104,277 +304,41 @@ class InputHandler:
         try:
             # Only provide command menu if we're in menu popup mode
             if (
-                self.command_mode == CommandMode.MENU_POPUP
-                and self.command_menu_active
+                self._command_mode_handler.command_mode == CommandMode.MENU_POPUP
+                and self._command_mode_handler.command_menu_active
                 and hasattr(self.command_menu_renderer, "current_menu_lines")
                 and self.command_menu_renderer.current_menu_lines
             ):
-
                 return {"menu_lines": self.command_menu_renderer.current_menu_lines}
 
-            # No command menu to display
             return {}
 
         except Exception as e:
             logger.error(f"Error in COMMAND_MENU_RENDER handler: {e}")
             return {}
 
-    async def _register_modal_trigger_hook(self) -> None:
-        """Register hook to handle modal trigger events."""
-        try:
-            if self.event_bus:
-                from ..events.models import Hook, HookPriority, EventType
-
-                hook = Hook(
-                    name="modal_trigger",
-                    plugin_name="input_handler",
-                    event_type=EventType.MODAL_TRIGGER,
-                    priority=HookPriority.DISPLAY.value,
-                    callback=self._handle_modal_trigger,
-                )
-                success = await self.event_bus.register_hook(hook)
-                if success:
-                    logger.info("Successfully registered MODAL_TRIGGER hook")
-                else:
-                    logger.error("Failed to register MODAL_TRIGGER hook")
-        except Exception as e:
-            logger.error(f"Failed to register MODAL_TRIGGER hook: {e}")
-
-    async def _register_status_modal_trigger_hook(self) -> None:
-        """Register hook to handle status modal trigger events."""
-        try:
-            if self.event_bus:
-                from ..events.models import Hook, HookPriority, EventType
-
-                hook = Hook(
-                    name="status_modal_trigger",
-                    plugin_name="input_handler",
-                    event_type=EventType.STATUS_MODAL_TRIGGER,
-                    priority=HookPriority.DISPLAY.value,
-                    callback=self._handle_status_modal_trigger,
-                )
-                success = await self.event_bus.register_hook(hook)
-                if success:
-                    logger.info("Successfully registered STATUS_MODAL_TRIGGER hook")
-                else:
-                    logger.error("Failed to register STATUS_MODAL_TRIGGER hook")
-        except Exception as e:
-            logger.error(f"Failed to register STATUS_MODAL_TRIGGER hook: {e}")
-
-    async def _register_live_modal_trigger_hook(self) -> None:
-        """Register hook to handle live modal trigger events."""
-        try:
-            if self.event_bus:
-                from ..events.models import Hook, HookPriority, EventType
-
-                hook = Hook(
-                    name="live_modal_trigger",
-                    plugin_name="input_handler",
-                    event_type=EventType.LIVE_MODAL_TRIGGER,
-                    priority=HookPriority.DISPLAY.value,
-                    callback=self._handle_live_modal_trigger,
-                )
-                success = await self.event_bus.register_hook(hook)
-                if success:
-                    logger.info("Successfully registered LIVE_MODAL_TRIGGER hook")
-                else:
-                    logger.error("Failed to register LIVE_MODAL_TRIGGER hook")
-        except Exception as e:
-            logger.error(f"Failed to register LIVE_MODAL_TRIGGER hook: {e}")
-
-    async def _handle_live_modal_trigger(
-        self, event_data: Dict[str, Any], context: str = None
-    ) -> Dict[str, Any]:
-        """Handle live modal trigger events to show live modals.
-
-        Args:
-            event_data: Event data containing content_generator, config, input_callback.
-            context: Hook execution context.
-
-        Returns:
-            Dictionary with live modal result.
-        """
-        try:
-            content_generator = event_data.get("content_generator")
-            config = event_data.get("config")
-            input_callback = event_data.get("input_callback")
-
-            if content_generator:
-                logger.info(f"Live modal trigger received: {config.title if config else 'untitled'}")
-                # Enter live modal mode (this will block until modal closes)
-                result = await self.enter_live_modal_mode(
-                    content_generator,
-                    config,
-                    input_callback
-                )
-                return {"success": True, "live_modal_activated": True, "result": result}
-            else:
-                logger.warning("Live modal trigger received without content_generator")
-                return {"success": False, "error": "Missing content_generator"}
-        except Exception as e:
-            logger.error(f"Error handling live modal trigger: {e}")
-            return {"success": False, "error": str(e)}
-
-    async def _register_status_modal_render_hook(self) -> None:
-        """Register hook to handle status modal render events."""
-        try:
-            if self.event_bus:
-                from ..events.models import Hook, HookPriority, EventType
-
-                hook = Hook(
-                    name="status_modal_render",
-                    plugin_name="input_handler",
-                    event_type=EventType.STATUS_MODAL_RENDER,
-                    priority=HookPriority.DISPLAY.value,
-                    callback=self._handle_status_modal_render,
-                )
-                success = await self.event_bus.register_hook(hook)
-                if success:
-                    logger.info("Successfully registered STATUS_MODAL_RENDER hook")
-                else:
-                    logger.error("Failed to register STATUS_MODAL_RENDER hook")
-        except Exception as e:
-            logger.error(f"Failed to register STATUS_MODAL_RENDER hook: {e}")
-
-    async def _register_command_output_display_hook(self) -> None:
-        """Register hook to handle command output display events."""
-        try:
-            if self.event_bus:
-                from ..events.models import Hook, HookPriority, EventType
-
-                hook = Hook(
-                    name="command_output_display",
-                    plugin_name="input_handler",
-                    event_type=EventType.COMMAND_OUTPUT_DISPLAY,
-                    priority=HookPriority.DISPLAY.value,
-                    callback=self._handle_command_output_display,
-                )
-                success = await self.event_bus.register_hook(hook)
-                if success:
-                    logger.info(
-                        "Successfully registered COMMAND_OUTPUT_DISPLAY hook"
-                    )
-                else:
-                    logger.error("Failed to register COMMAND_OUTPUT_DISPLAY hook")
-        except Exception as e:
-            logger.error(f"Failed to register COMMAND_OUTPUT_DISPLAY hook: {e}")
-
-        # Register pause/resume rendering hooks
-        await self._register_pause_rendering_hook()
-        await self._register_resume_rendering_hook()
-
-        # Register modal hide hook for Matrix effect cleanup
-        await self._register_modal_hide_hook()
-
-    async def _register_pause_rendering_hook(self) -> None:
-        """Register hook for pause rendering events."""
-        try:
-            if self.event_bus:
-                from ..events.models import Hook, HookPriority, EventType
-
-                hook = Hook(
-                    name="pause_rendering",
-                    plugin_name="input_handler",
-                    event_type=EventType.PAUSE_RENDERING,
-                    priority=HookPriority.DISPLAY.value,
-                    callback=self._handle_pause_rendering,
-                )
-                success = await self.event_bus.register_hook(hook)
-                if success:
-                    logger.info("Successfully registered PAUSE_RENDERING hook")
-                else:
-                    logger.error("Failed to register PAUSE_RENDERING hook")
-        except Exception as e:
-            logger.error(f"Error registering PAUSE_RENDERING hook: {e}")
-
-    async def _register_resume_rendering_hook(self) -> None:
-        """Register hook for resume rendering events."""
-        try:
-            if self.event_bus:
-                from ..events.models import Hook, HookPriority, EventType
-
-                hook = Hook(
-                    name="resume_rendering",
-                    plugin_name="input_handler",
-                    event_type=EventType.RESUME_RENDERING,
-                    priority=HookPriority.DISPLAY.value,
-                    callback=self._handle_resume_rendering,
-                )
-                success = await self.event_bus.register_hook(hook)
-                if success:
-                    logger.info("Successfully registered RESUME_RENDERING hook")
-                else:
-                    logger.error("Failed to register RESUME_RENDERING hook")
-        except Exception as e:
-            logger.error(f"Error registering RESUME_RENDERING hook: {e}")
-
     async def _handle_pause_rendering(
-        self, event_data: Dict[str, Any], context: str = None
+        self, event_data: Dict[str, Any], context: Optional[str] = None
     ) -> Dict[str, Any]:
         """Handle pause rendering event."""
-        logger.info("🛑 PAUSE_RENDERING event received - pausing input rendering")
+        logger.info("PAUSE_RENDERING event received - pausing input rendering")
         self.rendering_paused = True
+        self._display_controller.pause_rendering()
         return {"status": "paused"}
 
     async def _handle_resume_rendering(
-        self, event_data: Dict[str, Any], context: str = None
+        self, event_data: Dict[str, Any], context: Optional[str] = None
     ) -> Dict[str, Any]:
         """Handle resume rendering event."""
-        logger.info("▶️ RESUME_RENDERING event received - resuming input rendering")
+        logger.info("RESUME_RENDERING event received - resuming input rendering")
         self.rendering_paused = False
+        self._display_controller.resume_rendering()
         # Force a refresh when resuming
-        await self._update_display(force_render=True)
+        await self._display_controller.update_display(force_render=True)
         return {"status": "resumed"}
 
-    async def _register_modal_hide_hook(self) -> None:
-        """Register hook for modal hide events."""
-        try:
-            if self.event_bus:
-                from ..events.models import Hook, HookPriority, EventType
-
-                hook = Hook(
-                    name="modal_hide",
-                    plugin_name="input_handler",
-                    event_type=EventType.MODAL_HIDE,
-                    priority=HookPriority.DISPLAY.value,
-                    callback=self._handle_modal_hide,
-                )
-                success = await self.event_bus.register_hook(hook)
-                if success:
-                    logger.info("Successfully registered MODAL_HIDE hook")
-                else:
-                    logger.error("Failed to register MODAL_HIDE hook")
-        except Exception as e:
-            logger.error(f"Error registering MODAL_HIDE hook: {e}")
-
-    async def _handle_modal_hide(
-        self, event_data: Dict[str, Any], context: str = None
-    ) -> Dict[str, Any]:
-        """Handle modal hide event to exit modal mode."""
-        logger.info("🔄 MODAL_HIDE event received - exiting modal mode")
-        try:
-            from ..events.models import CommandMode
-
-            # CRITICAL FIX: Clear input area before restoring (like config modal does)
-            self.renderer.clear_active_area()
-            self.renderer.writing_messages = False
-
-            self.command_mode = CommandMode.NORMAL
-            # CRITICAL FIX: Clear fullscreen session flag when exiting modal
-            if hasattr(self, "_fullscreen_session_active"):
-                self._fullscreen_session_active = False
-                logger.info("🔄 Fullscreen session marked as inactive")
-            logger.info("🔄 Command mode reset to NORMAL after modal hide")
-
-            # Force refresh of display when exiting modal mode
-            await self._update_display(force_render=True)
-            return {"success": True, "modal_deactivated": True}
-        except Exception as e:
-            logger.error(f"Error handling modal hide: {e}")
-            return {"success": False, "error": str(e)}
-
     async def _handle_command_output_display(
-        self, event_data: Dict[str, Any], context: str = None
+        self, event_data: Dict[str, Any], context: Optional[str] = None
     ) -> Dict[str, Any]:
         """Handle command output display events.
 
@@ -1388,35 +352,30 @@ class InputHandler:
         try:
             message = event_data.get("message", "")
             display_type = event_data.get("display_type", "info")
-            _ = event_data.get("success", True)
 
             if message:
                 # Format message based on display type
                 if display_type == "error":
-                    formatted_message = f"❌ {message}"
+                    formatted_message = f"[x] {message}"
                 elif display_type == "warning":
-                    formatted_message = f"⚠️  {message}"
+                    formatted_message = f"[!] {message}"
                 elif display_type == "success":
-                    formatted_message = f"✅ {message}"
-                else:  # info or default
-                    formatted_message = f"ℹ️  {message}"
+                    formatted_message = f"[ok] {message}"
+                else:
+                    formatted_message = f"[i] {message}"
 
-                # FIXED: Remove writing_messages management here - message_coordinator handles it
-                # The message_coordinator.display_message_sequence() properly manages the flag
-                
                 # Clear the active input area first
                 self.renderer.clear_active_area()
 
-                # CRITICAL FIX: Use write_hook_message to avoid ∴ prefix on command output
-                # This routes through message_coordinator which handles writing_messages flag properly
+                # Use write_hook_message to display command output
                 self.renderer.write_hook_message(
                     formatted_message,
                     display_type=display_type,
                     source="command",
                 )
 
-                # Force a display update to ensure message appears
-                await self._update_display(force_render=True)
+                # Force a display update
+                await self._display_controller.update_display(force_render=True)
 
                 logger.info(f"Command output displayed: {display_type}")
 
@@ -1430,1226 +389,26 @@ class InputHandler:
             logger.error(f"Error handling command output display: {e}")
             return {"success": False, "error": str(e)}
 
-    async def _handle_modal_trigger(
-        self, event_data: Dict[str, Any], context: str = None
-    ) -> Dict[str, Any]:
-        """Handle modal trigger events to show modals.
-
-        Args:
-            event_data: Event data containing modal configuration.
-
-        Returns:
-            Dictionary with modal result.
-        """
-        try:
-            # Check if this is a Matrix effect trigger
-            if event_data.get("matrix_effect"):
-                logger.info(
-                    "🎯 Matrix effect modal trigger received - setting modal mode for complete terminal control"
-                )
-                # Set modal mode directly for Matrix effect (no UI config needed)
-                from ..events.models import CommandMode
-
-                self.command_mode = CommandMode.MODAL
-                logger.info("🎯 Command mode set to MODAL for Matrix effect")
-                return {
-                    "success": True,
-                    "modal_activated": True,
-                    "matrix_mode": True,
-                }
-
-            # Check if this is a full-screen plugin trigger
-            if event_data.get("fullscreen_plugin"):
-                plugin_name = event_data.get("plugin_name", "unknown")
-                logger.info(
-                    f"🎯 Full-screen plugin modal trigger received: {plugin_name}"
-                )
-
-                # CRITICAL FIX: Clear input area before fullscreen mode (like config modal does)
-                self.renderer.writing_messages = True
-                self.renderer.clear_active_area()
-
-                # Set modal mode for full-screen plugin (no UI config needed)
-                from ..events.models import CommandMode
-
-                self.command_mode = CommandMode.MODAL
-                # CRITICAL FIX: Mark fullscreen session as active for input routing
-                self._fullscreen_session_active = True
-                logger.info(
-                    f"🎯 Command mode set to MODAL for full-screen plugin: {plugin_name}"
-                )
-                logger.info(
-                    "🎯 Fullscreen session marked as active for input routing"
-                )
-                return {
-                    "success": True,
-                    "modal_activated": True,
-                    "fullscreen_plugin": True,
-                    "plugin_name": plugin_name,
-                }
-
-            # Standard modal with UI config
-            ui_config = event_data.get("ui_config")
-            if ui_config:
-                logger.info(f"🎯 Modal trigger received: {ui_config.title}")
-                await self._enter_modal_mode(ui_config)
-                return {"success": True, "modal_activated": True}
-            else:
-                logger.warning("Modal trigger received without ui_config")
-                return {"success": False, "error": "Missing ui_config"}
-
-        except Exception as e:
-            logger.error(f"Error handling modal trigger: {e}")
-            return {"success": False, "error": str(e)}
-
-    # ==================== SLASH COMMAND SYSTEM ====================
-
-    async def _enter_command_mode(self) -> None:
-        """Enter slash command mode and show command menu."""
-        try:
-            logger.info("🎯 Entering slash command mode")
-            self.command_mode = CommandMode.MENU_POPUP
-            self.command_menu_active = True
-
-            # Reset selection to first command
-            self.selected_command_index = 0
-
-            # Add the '/' character to buffer for visual feedback
-            self.buffer_manager.insert_char("/")
-
-            # Show command menu via renderer
-            available_commands = self._get_available_commands()
-            self.command_menu_renderer.show_command_menu(available_commands, "")
-
-            # Emit command menu show event
-            await self.event_bus.emit_with_hooks(
-                EventType.COMMAND_MENU_SHOW,
-                {"available_commands": available_commands, "filter_text": ""},
-                "commands",
-            )
-
-            # Update display to show command mode
-            await self._update_display(force_render=True)
-
-            logger.info("Command menu activated")
-
-        except Exception as e:
-            logger.error(f"Error entering command mode: {e}")
-            await self._exit_command_mode()
-
-    async def _exit_command_mode(self) -> None:
-        """Exit command mode and restore normal input."""
-        try:
-            import traceback
-
-            logger.info("🚪 Exiting slash command mode")
-            logger.info(
-                f"🚪 Exit called from: {traceback.format_stack()[-2].strip()}"
-            )
-
-            # Hide command menu via renderer
-            self.command_menu_renderer.hide_menu()
-
-            # Emit command menu hide event
-            if self.command_menu_active:
-                await self.event_bus.emit_with_hooks(
-                    EventType.COMMAND_MENU_HIDE,
-                    {"reason": "manual_exit"},
-                    "commands",
-                )
-
-            self.command_mode = CommandMode.NORMAL
-            self.command_menu_active = False
-
-            # Clear command buffer (remove the '/' and any partial command)
-            self.buffer_manager.clear()
-
-            # Update display
-            await self._update_display(force_render=True)
-
-            logger.info("Returned to normal input mode")
-
-        except Exception as e:
-            logger.error(f"Error exiting command mode: {e}")
-
-    async def _handle_command_mode_keypress(self, key_press: KeyPress) -> bool:
-        """Handle KeyPress while in command mode (supports arrow keys).
-
-        Args:
-            key_press: Parsed key press to process.
-
-        Returns:
-            True if key was handled, False to fall through to normal processing.
-        """
-        try:
-            if self.command_mode == CommandMode.MENU_POPUP:
-                return await self._handle_menu_popup_keypress(key_press)
-            elif self.command_mode == CommandMode.STATUS_TAKEOVER:
-                return await self._handle_status_takeover_keypress(key_press)
-            elif self.command_mode == CommandMode.MODAL:
-                return await self._handle_modal_keypress(key_press)
-            elif self.command_mode == CommandMode.STATUS_MODAL:
-                return await self._handle_status_modal_keypress(key_press)
-            elif self.command_mode == CommandMode.LIVE_MODAL:
-                return await self._handle_live_modal_keypress(key_press)
-            else:
-                # Unknown command mode, exit to normal
-                await self._exit_command_mode()
-                return False
-
-        except Exception as e:
-            logger.error(f"Error handling command mode keypress: {e}")
-            await self._exit_command_mode()
-            return False
-
-    async def _handle_command_mode_input(self, char: str) -> bool:
-        """Handle input while in command mode.
-
-        Args:
-            char: Character input to process.
-
-        Returns:
-            True if input was handled, False to fall through to normal processing.
-        """
-        try:
-            if self.command_mode == CommandMode.MENU_POPUP:
-                return await self._handle_menu_popup_input(char)
-            elif self.command_mode == CommandMode.STATUS_TAKEOVER:
-                return await self._handle_status_takeover_input(char)
-            elif self.command_mode == CommandMode.STATUS_MODAL:
-                return await self._handle_status_modal_input(char)
-            elif self.command_mode == CommandMode.LIVE_MODAL:
-                return await self._handle_live_modal_input(char)
-            else:
-                # Unknown command mode, exit to normal
-                await self._exit_command_mode()
-                return False
-
-        except Exception as e:
-            logger.error(f"Error handling command mode input: {e}")
-            await self._exit_command_mode()
-            return False
-
-    async def _handle_menu_popup_input(self, char: str) -> bool:
-        """Handle input during menu popup mode.
-
-        Args:
-            char: Character input to process.
-
-        Returns:
-            True if input was handled.
-        """
-        # Handle special keys first
-        if ord(char) == 27:  # Escape key
-            await self._exit_command_mode()
-            return True
-        elif ord(char) == 13:  # Enter key
-            await self._execute_selected_command()
-            return True
-        elif ord(char) == 8 or ord(char) == 127:  # Backspace or Delete
-            # If buffer only has '/', exit command mode
-            if len(self.buffer_manager.content) <= 1:
-                await self._exit_command_mode()
-                return True
-            else:
-                # Remove character and update command filter
-                self.buffer_manager.delete_char()
-                await self._update_command_filter()
-                return True
-
-        # Handle printable characters (add to command filter)
-        if char.isprintable():
-            self.buffer_manager.insert_char(char)
-            await self._update_command_filter()
-            return True
-
-        # Let other keys fall through for now
-        return False
-
-    async def _handle_menu_popup_keypress(self, key_press: KeyPress) -> bool:
-        """Handle KeyPress during menu popup mode with arrow key navigation.
-
-        Args:
-            key_press: Parsed key press to process.
-
-        Returns:
-            True if key was handled.
-        """
-        try:
-            # Handle arrow key navigation
-            if key_press.name == "ArrowUp":
-                await self._navigate_menu("up")
-                return True
-            elif key_press.name == "ArrowDown":
-                await self._navigate_menu("down")
-                return True
-            elif key_press.name == "Enter":
-                await self._execute_selected_command()
-                return True
-            elif key_press.name == "Escape":
-                await self._exit_command_mode()
-                return True
-
-            # Handle printable characters (for filtering)
-            elif key_press.char and key_press.char.isprintable():
-                self.buffer_manager.insert_char(key_press.char)
-                await self._update_command_filter()
-                return True
-
-            # Handle backspace/delete
-            elif key_press.name in ["Backspace", "Delete"]:
-                # If buffer only has '/', exit command mode
-                if len(self.buffer_manager.content) <= 1:
-                    await self._exit_command_mode()
-                    return True
-                else:
-                    # Remove character and update command filter
-                    self.buffer_manager.delete_char()
-                    await self._update_command_filter()
-                    return True
-
-            # Other keys not handled
-            return False
-
-        except Exception as e:
-            logger.error(f"Error handling menu popup keypress: {e}")
-            await self._exit_command_mode()
-            return False
-
-    async def _handle_status_takeover_input(self, char: str) -> bool:
-        """Handle input during status area takeover mode.
-
-        Args:
-            char: Character input to process.
-
-        Returns:
-            True if input was handled.
-        """
-        # For now, just handle Escape to exit
-        if ord(char) == 27:  # Escape key
-            await self._exit_command_mode()
-            return True
-
-        # TODO: Implement status area navigation
-        return True
-
-    async def _handle_status_takeover_keypress(self, key_press: KeyPress) -> bool:
-        """Handle KeyPress during status area takeover mode.
-
-        Args:
-            key_press: Parsed key press to process.
-
-        Returns:
-            True if key was handled.
-        """
-        # For now, just handle Escape to exit
-        if key_press.name == "Escape":
-            await self._exit_command_mode()
-            return True
-
-        # TODO: Implement status area navigation
-        return True
-
-    async def _handle_modal_keypress(self, key_press: KeyPress) -> bool:
-        """Handle KeyPress during modal mode.
-
-        Args:
-            key_press: Parsed key press to process.
-
-        Returns:
-            True if key was handled.
-        """
-        try:
-            # CRITICAL FIX: Check if this is a fullscreen plugin session first
-            if (
-                hasattr(self, "_fullscreen_session_active")
-                and self._fullscreen_session_active
-            ):
-                # SIMPLE SOLUTION: Check for exit keys directly
-                if key_press.char in ["q", "\x1b"] or key_press.name == "Escape":
-                    # Exit fullscreen mode immediately
-                    self._fullscreen_session_active = False
-                    from ..events.models import CommandMode
-
-                    self.command_mode = CommandMode.NORMAL
-                    await self._update_display(force_render=True)
-                    return True
-
-                # Route input to fullscreen session through event bus
-                from ..events.models import EventType
-
-                await self.event_bus.emit_with_hooks(
-                    EventType.FULLSCREEN_INPUT,
-                    {"key_press": key_press, "source": "input_handler"},
-                    "input_handler",
-                )
-                return True
-
-            # Initialize modal renderer if needed
-            if not self.modal_renderer:
-                logger.warning(
-                    "Modal keypress received but no modal renderer active"
-                )
-                await self._exit_modal_mode()
-                return True
-
-            # Handle save confirmation if active
-            if self._pending_save_confirm:
-                handled = await self._handle_save_confirmation(key_press)
-                if handled:
-                    return True
-
-            # Handle navigation and widget interaction
-            logger.info(f"🔍 Modal processing key: {key_press.name}")
-
-            nav_handled = self.modal_renderer._handle_widget_navigation(key_press)
-            logger.info(f"🎯 Widget navigation handled: {nav_handled}")
-            if nav_handled:
-                # Re-render modal with updated focus
-                await self._refresh_modal_display()
-                return True
-
-            input_handled = self.modal_renderer._handle_widget_input(key_press)
-            logger.info(f"🎯 Widget input handled: {input_handled}")
-            if input_handled:
-                # Re-render modal with updated widget state
-                await self._refresh_modal_display()
-                return True
-
-            if key_press.name == "Escape":
-                logger.info("🚪 Processing Escape key for modal exit")
-                # Check for unsaved changes
-                if self.modal_renderer and self._has_pending_modal_changes():
-                    self._pending_save_confirm = True
-                    await self._show_save_confirmation()
-                    return True
-                await self._exit_modal_mode()
-                return True
-            elif key_press.name == "Ctrl+S":
-                logger.info("💾 Processing Ctrl+S for modal save")
-                await self._save_and_exit_modal()
-                return True
-            elif key_press.name == "Enter":
-                logger.info(
-                    "🔴 ENTER KEY HIJACKED - This should not happen if widget handled it!"
-                )
-                # Try to save modal changes and exit
-                await self._save_and_exit_modal()
-                return True
-
-            return True
-        except Exception as e:
-            logger.error(f"Error handling modal keypress: {e}")
-            await self._exit_modal_mode()
-            return False
-
-    async def _enter_modal_mode(self, ui_config):
-        """Enter modal mode and show modal renderer.
-
-        Args:
-            ui_config: Modal configuration.
-        """
-        try:
-            # Import modal renderer here to avoid circular imports
-            from ..ui.modal_renderer import ModalRenderer
-
-            # Create modal renderer instance with proper config service
-            self.modal_renderer = ModalRenderer(
-                terminal_renderer=self.renderer,
-                visual_effects=getattr(self.renderer, "visual_effects", None),
-                config_service=self.config,  # Use config as config service
-            )
-
-            # CRITICAL FIX: Clear input area before modal to prevent duplication
-            self.renderer.writing_messages = True
-            self.renderer.clear_active_area()
-
-            # Set modal mode FIRST
-            self.command_mode = CommandMode.MODAL
-            logger.info(f"🎯 Command mode set to: {self.command_mode}")
-
-            # Show the modal with alternate buffer
-            logger.info(
-                "🔧 DIRECT: About to call show_modal - this should trigger alternate buffer"
-            )
-            await self.modal_renderer.show_modal(ui_config)
-
-            # Reset writing flag (modal will handle its own rendering from here)
-            self.renderer.writing_messages = False
-
-            logger.info("🎯 Entered modal mode with persistent input loop")
-
-        except Exception as e:
-            logger.error(f"Error entering modal mode: {e}")
-            self.command_mode = CommandMode.NORMAL
-
-    async def _refresh_modal_display(self):
-        """Refresh modal display after widget interactions."""
-        try:
-            if self.modal_renderer and hasattr(
-                self.modal_renderer, "current_ui_config"
-            ):
-
-                # CRITICAL FIX: Force complete display clearing to prevent duplication
-                # Clear active area completely before refresh
-                self.renderer.clear_active_area()
-
-                # Clear any message buffers that might accumulate content
-                if hasattr(self.renderer, "message_renderer"):
-                    if hasattr(self.renderer.message_renderer, "buffer"):
-                        self.renderer.message_renderer.buffer.clear_buffer()
-                    # Also clear any accumulated messages in the renderer
-                    if hasattr(self.renderer.message_renderer, "clear_messages"):
-                        self.renderer.message_renderer.clear_messages()
-
-                # Re-render the modal with current widget states (preserve widgets!)
-                modal_lines = self.modal_renderer._render_modal_box(
-                    self.modal_renderer.current_ui_config,
-                    preserve_widgets=True,
-                )
-                # FIXED: Use state_manager.render_modal_content() instead of _render_modal_lines()
-                # to avoid re-calling prepare_modal_display() which causes buffer switching
-                if self.modal_renderer.state_manager:
-                    self.modal_renderer.state_manager.render_modal_content(
-                        modal_lines
-                    )
-                else:
-                    # Fallback to old method if state_manager not available
-                    await self.modal_renderer._render_modal_lines(modal_lines)
-            else:
-                pass
-        except Exception as e:
-            logger.error(f"Error refreshing modal display: {e}")
-
-    def _has_pending_modal_changes(self) -> bool:
-        """Check if there are unsaved changes in modal widgets."""
-        if not self.modal_renderer or not self.modal_renderer.widgets:
-            return False
-        for widget in self.modal_renderer.widgets:
-            if hasattr(widget, '_pending_value') and widget._pending_value is not None:
-                # Check if pending value differs from current config value
-                current = widget.get_value() if hasattr(widget, 'get_value') else None
-                if widget._pending_value != current:
-                    return True
-        return False
-
-    async def _show_save_confirmation(self):
-        """Show save confirmation prompt in modal."""
-        # Update modal footer to show confirmation prompt
-        if self.modal_renderer:
-            self.modal_renderer._save_confirm_active = True
-            await self._refresh_modal_display()
-
-    async def _handle_save_confirmation(self, key_press) -> bool:
-        """Handle y/n input for save confirmation."""
-        if key_press.char and key_press.char.lower() == 'y':
-            logger.info("💾 User confirmed save")
-            self._pending_save_confirm = False
-            if self.modal_renderer:
-                self.modal_renderer._save_confirm_active = False
-            await self._save_and_exit_modal()
-            return True
-        elif key_press.char and key_press.char.lower() == 'n':
-            logger.info("🚫 User declined save")
-            self._pending_save_confirm = False
-            if self.modal_renderer:
-                self.modal_renderer._save_confirm_active = False
-            await self._exit_modal_mode()
-            return True
-        elif key_press.name == "Escape":
-            # Cancel confirmation, stay in modal
-            logger.info("↩️ User cancelled confirmation")
-            self._pending_save_confirm = False
-            if self.modal_renderer:
-                self.modal_renderer._save_confirm_active = False
-            await self._refresh_modal_display()
-            return True
-        return False
-
-    async def _save_and_exit_modal(self):
-        """Save modal changes and exit modal mode."""
-        try:
-            if self.modal_renderer and hasattr(
-                self.modal_renderer, "action_handler"
-            ):
-                # Get widget values and save them using proper action handler interface
-                result = await self.modal_renderer.action_handler.handle_action(
-                    "save", self.modal_renderer.widgets
-                )
-                if result.get("success"):
-                    pass
-                else:
-                    logger.warning(
-                        f"Failed to save modal changes: {result.get('message', 'Unknown error')}"
-                    )
-
-            await self._exit_modal_mode()
-        except Exception as e:
-            logger.error(f"Error saving and exiting modal: {e}")
-            await self._exit_modal_mode()
-
-    async def _exit_modal_mode(self):
-        """Exit modal mode using existing patterns."""
-        try:
-
-            # CRITICAL FIX: Complete terminal state restoration
-            # Clear active area to remove modal artifacts
-            self.renderer.clear_active_area()
-
-            # Clear any buffered modal content that might persist
-            if hasattr(self.renderer, "message_renderer"):
-                if hasattr(self.renderer.message_renderer, "buffer"):
-                    self.renderer.message_renderer.buffer.clear_buffer()
-
-            # CRITICAL FIX: Properly close modal with alternate buffer restoration
-            if self.modal_renderer:
-                # FIRST: Close modal and restore terminal state (alternate buffer)
-                _ = self.modal_renderer.close_modal()
-
-                # THEN: Reset modal renderer widgets
-                self.modal_renderer.widgets = []
-                self.modal_renderer.focused_widget_index = 0
-                self.modal_renderer = None
-
-            # Return to normal mode
-            self.command_mode = CommandMode.NORMAL
-
-            # Complete display restoration with force refresh
-            self.renderer.clear_active_area()
-            await self._update_display(force_render=True)
-
-            # Ensure cursor is properly positioned
-            # Note: cursor management handled by terminal_state
-
-        except Exception as e:
-            logger.error(f"Error exiting modal mode: {e}")
-            self.command_mode = CommandMode.NORMAL
-            self.modal_renderer = None
-            # Emergency cleanup
-            self.renderer.clear_active_area()
-
-    async def _navigate_menu(self, direction: str) -> None:
-        """Navigate the command menu up or down.
-
-        Args:
-            direction: "up" or "down"
-        """
-        try:
-            # Get current filtered commands
-            current_input = self.buffer_manager.content
-            filter_text = (
-                current_input[1:] if current_input.startswith("/") else current_input
-            )
-            filtered_commands = self._filter_commands(filter_text)
-
-            if not filtered_commands:
-                return
-
-            # Update selection index
-            if direction == "up":
-                self.selected_command_index = max(0, self.selected_command_index - 1)
-            elif direction == "down":
-                self.selected_command_index = min(
-                    len(filtered_commands) - 1, self.selected_command_index + 1
-                )
-
-            # Update menu renderer with new selection (don't reset selection during navigation)
-            self.command_menu_renderer.set_selected_index(
-                self.selected_command_index
-            )
-            self.command_menu_renderer.filter_commands(
-                filtered_commands, filter_text, reset_selection=False
-            )
-
-            # Note: No need to call _update_display - filter_commands already renders the menu
-
-        except Exception as e:
-            logger.error(f"Error navigating menu: {e}")
-
-    async def _update_command_filter(self) -> None:
-        """Update command menu based on current buffer content."""
-        try:
-            # Get current input (minus the leading '/')
-            current_input = self.buffer_manager.content
-            filter_text = (
-                current_input[1:] if current_input.startswith("/") else current_input
-            )
-
-            # Update menu renderer with filtered commands
-            filtered_commands = self._filter_commands(filter_text)
-
-            # Reset selection when filtering
-            self.selected_command_index = 0
-            self.command_menu_renderer.set_selected_index(
-                self.selected_command_index
-            )
-            self.command_menu_renderer.filter_commands(
-                filtered_commands, filter_text
-            )
-
-            # Emit filter update event
-            await self.event_bus.emit_with_hooks(
-                EventType.COMMAND_MENU_FILTER,
-                {
-                    "filter_text": filter_text,
-                    "available_commands": self._get_available_commands(),
-                    "filtered_commands": filtered_commands,
-                },
-                "commands",
-            )
-
-            # Update display
-            await self._update_display(force_render=True)
-
-        except Exception as e:
-            logger.error(f"Error updating command filter: {e}")
-
-    async def _execute_selected_command(self) -> None:
-        """Execute the currently selected command."""
-        try:
-            # Get the full command string from buffer (includes arguments)
-            command_string = self.buffer_manager.content
-
-            # If buffer is empty or just '/', use the selected command from menu
-            if not command_string or command_string == "/":
-                selected_command = self.command_menu_renderer.get_selected_command()
-                if not selected_command:
-                    logger.warning("No command selected")
-                    await self._exit_command_mode()
-                    return
-                command_string = f"/{selected_command['name']}"
-
-            # Parse the command
-            command = self.slash_parser.parse_command(command_string)
-            if command:
-                logger.info(f"🚀 Executing selected command: {command.name}")
-
-                # Exit command mode first
-                await self._exit_command_mode()
-
-                # Execute the command
-                result = await self.command_executor.execute_command(
-                    command, self.event_bus
-                )
-
-                # Handle the result
-                if result.success:
-                    logger.info(f"✅ Command {command.name} completed successfully")
-
-                    # Modal display is handled by event bus trigger, not here
-                    if result.message:
-                        # Display success message in status area
-                        logger.info(f"Command result: {result.message}")
-                        # TODO: Display in status area
-                else:
-                    logger.warning(
-                        f"❌ Command {command.name} failed: {result.message}"
-                    )
-                    # TODO: Display error message in status area
-            else:
-                logger.warning("Failed to parse selected command")
-                await self._exit_command_mode()
-
-        except Exception as e:
-            logger.error(f"Error executing command: {e}")
-            await self._exit_command_mode()
-
-    def _get_available_commands(self) -> List[Dict[str, Any]]:
-        """Get list of available commands for menu display.
-
-        Returns:
-            List of command dictionaries for menu rendering.
-        """
-        commands = []
-        command_defs = self.command_registry.list_commands()
-
-        for cmd_def in command_defs:
-            commands.append(
-                {
-                    "name": cmd_def.name,
-                    "description": cmd_def.description,
-                    "aliases": cmd_def.aliases,
-                    "category": cmd_def.category.value,
-                    "plugin": cmd_def.plugin_name,
-                    "icon": cmd_def.icon,
-                }
-            )
-
-        return commands
-
-    def _filter_commands(self, filter_text: str) -> List[Dict[str, Any]]:
-        """Filter commands based on input text.
-
-        Args:
-            filter_text: Text to filter commands by.
-
-        Returns:
-            List of filtered command dictionaries.
-        """
-        if not filter_text:
-            return self._get_available_commands()
-
-        # Use registry search functionality
-        matching_defs = self.command_registry.search_commands(filter_text)
-
-        filtered_commands = []
-        for cmd_def in matching_defs:
-            filtered_commands.append(
-                {
-                    "name": cmd_def.name,
-                    "description": cmd_def.description,
-                    "aliases": cmd_def.aliases,
-                    "category": cmd_def.category.value,
-                    "plugin": cmd_def.plugin_name,
-                    "icon": cmd_def.icon,
-                }
-            )
-
-        return filtered_commands
-
-    # ==================== STATUS MODAL METHODS ====================
+    # ==================== DELEGATING METHODS (for backward compatibility) ====================
 
     async def _handle_status_modal_trigger(
-        self, event_data: Dict[str, Any], context: str = None
-    ) -> Dict[str, Any]:
-        """Handle status modal trigger events to show status modals.
-
-        Args:
-            event_data: Event data containing modal configuration.
-            context: Hook execution context.
-
-        Returns:
-            Dictionary with status modal result.
-        """
-        try:
-            ui_config = event_data.get("ui_config")
-            if ui_config:
-                logger.info(f"Status modal trigger received: {ui_config.title}")
-                logger.info(f"Status modal trigger UI config type: {ui_config.type}")
-                await self._enter_status_modal_mode(ui_config)
-                return {"success": True, "status_modal_activated": True}
-            else:
-                logger.warning("Status modal trigger received without ui_config")
-                return {"success": False, "error": "Missing ui_config"}
-        except Exception as e:
-            logger.error(f"Error handling status modal trigger: {e}")
-            return {"success": False, "error": str(e)}
-
-    async def _enter_status_modal_mode(self, ui_config):
-        """Enter status modal mode - modal confined to status area.
-
-        Args:
-            ui_config: Status modal configuration.
-        """
-        try:
-            # Set status modal mode
-            self.command_mode = CommandMode.STATUS_MODAL
-            self.current_status_modal_config = ui_config
-            logger.info(f"Entered status modal mode: {ui_config.title}")
-
-            # Unlike full modals, status modals don't take over the screen
-            # They just appear in the status area via the renderer
-            await self._update_display(force_render=True)
-
-        except Exception as e:
-            logger.error(f"Error entering status modal mode: {e}")
-            await self._exit_command_mode()
-
-    async def _handle_status_modal_keypress(self, key_press: KeyPress) -> bool:
-        """Handle keypress during status modal mode.
-
-        Args:
-            key_press: Parsed key press to process.
-
-        Returns:
-            True if key was handled, False otherwise.
-        """
-        try:
-            logger.info(
-                f"Status modal received key: name='{key_press.name}', char='{key_press.char}', code={key_press.code}"
-            )
-
-            if key_press.name == "Escape":
-                logger.info("Escape key detected, closing status modal")
-                await self._exit_status_modal_mode()
-                return True
-            elif key_press.name == "Enter":
-                logger.info("Enter key detected, closing status modal")
-                await self._exit_status_modal_mode()
-                return True
-            elif key_press.char and ord(key_press.char) == 3:  # Ctrl+C
-                logger.info("Ctrl+C detected, closing status modal")
-                await self._exit_status_modal_mode()
-                return True
-            else:
-                logger.info(f"Unhandled key in status modal: {key_press.name}")
-                return True
-
-        except Exception as e:
-            logger.error(f"Error handling status modal keypress: {e}")
-            await self._exit_status_modal_mode()
-            return False
-
-    async def _handle_status_modal_input(self, char: str) -> bool:
-        """Handle input during status modal mode.
-
-        Args:
-            char: Character input to process.
-
-        Returns:
-            True if input was handled, False otherwise.
-        """
-        try:
-            # For now, ignore character input in status modals
-            # Could add search/filter functionality later
-            return True
-        except Exception as e:
-            logger.error(f"Error handling status modal input: {e}")
-            await self._exit_status_modal_mode()
-            return False
-
-    async def _exit_status_modal_mode(self):
-        """Exit status modal mode and return to normal input."""
-        try:
-            logger.info("Exiting status modal mode...")
-            self.command_mode = CommandMode.NORMAL
-            self.current_status_modal_config = None
-            logger.info("Status modal mode exited successfully")
-
-            # Refresh display to remove the status modal
-            await self._update_display(force_render=True)
-            logger.info("Display updated after status modal exit")
-
-        except Exception as e:
-            logger.error(f"Error exiting status modal mode: {e}")
-            self.command_mode = CommandMode.NORMAL
-
-    # ==================== Live Modal Mode ====================
-    # For live-updating content like tmux sessions, log tailing, etc.
-
-    async def enter_live_modal_mode(
-        self,
-        content_generator,
-        config=None,
-        input_callback=None
+        self, event_data: Dict[str, Any], context: Optional[str] = None
     ) -> Dict[str, Any]:
-        """Enter live modal mode with continuously updating content.
-
-        This is non-blocking - it starts the modal and returns immediately.
-        The input loop continues to process keys, routing them to the modal.
-        Press Escape to exit the modal.
-
-        Args:
-            content_generator: Function returning List[str] of current content.
-            config: LiveModalConfig instance.
-            input_callback: Optional callback for input passthrough.
-
-        Returns:
-            Result dict indicating modal was started.
-        """
-        try:
-            from ..ui.live_modal_renderer import LiveModalRenderer, LiveModalConfig
-
-            # Store state
-            self.command_mode = CommandMode.LIVE_MODAL
-            self.live_modal_content_generator = content_generator
-            self.live_modal_input_callback = input_callback
-
-            # Create and store the live modal renderer
-            terminal_state = self.renderer.terminal_state
-            self.live_modal_renderer = LiveModalRenderer(terminal_state)
-
-            # Use default config if none provided
-            if config is None:
-                config = LiveModalConfig()
-
-            logger.info(f"Entering live modal mode: {config.title}")
-
-            # Start the live modal (non-blocking)
-            # The refresh loop runs as a background task
-            # Input will be handled by _handle_live_modal_keypress
-            success = self.live_modal_renderer.start_live_modal(
-                content_generator,
-                config,
-                input_callback
-            )
-
-            if success:
-                return {"success": True, "modal_started": True}
-            else:
-                await self._exit_live_modal_mode()
-                return {"success": False, "error": "Failed to start modal"}
-
-        except Exception as e:
-            logger.error(f"Error entering live modal mode: {e}")
-            await self._exit_live_modal_mode()
-            return {"success": False, "error": str(e)}
-
-    async def _handle_live_modal_keypress(self, key_press: "KeyPress") -> bool:
-        """Handle keypress during live modal mode.
-
-        Args:
-            key_press: Parsed key press to process.
-
-        Returns:
-            True if key was handled.
-        """
-        try:
-            logger.info(
-                f"LIVE_MODAL_KEY: name='{key_press.name}', char='{key_press.char}', code={key_press.code}"
-            )
-
-            # Forward to live modal renderer
-            if self.live_modal_renderer:
-                should_close = await self.live_modal_renderer.handle_input(key_press)
-                if should_close:
-                    await self._exit_live_modal_mode()
-                return True
-
-            # Fallback: Escape always exits
-            if key_press.name == "Escape":
-                await self._exit_live_modal_mode()
-                return True
-
-            return True
-
-        except Exception as e:
-            logger.error(f"Error handling live modal keypress: {e}")
-            await self._exit_live_modal_mode()
-            return False
-
-    async def _handle_live_modal_input(self, char: str) -> bool:
-        """Handle character input during live modal mode.
-
-        Args:
-            char: Character input to process.
-
-        Returns:
-            True if input was handled.
-        """
-        try:
-            # Convert char to KeyPress for consistent handling
-            from .key_parser import KeyPress
-            key_press = KeyPress(char=char, name=None, code=ord(char) if char else 0)
-            return await self._handle_live_modal_keypress(key_press)
-
-        except Exception as e:
-            logger.error(f"Error handling live modal input: {e}")
-            await self._exit_live_modal_mode()
-            return False
-
-    async def _exit_live_modal_mode(self):
-        """Exit live modal mode and restore terminal."""
-        try:
-            logger.info("Exiting live modal mode...")
-
-            # Close the live modal renderer (restores from alt buffer)
-            if self.live_modal_renderer:
-                await self.live_modal_renderer.close_modal()
-
-            # Reset state
-            self.command_mode = CommandMode.NORMAL
-            self.live_modal_renderer = None
-            self.live_modal_content_generator = None
-            self.live_modal_input_callback = None
-
-            # Force display refresh with full redraw
-            self.renderer.clear_active_area()
-            await self._update_display(force_render=True)
-
-            logger.info("Live modal mode exited successfully")
-
-        except Exception as e:
-            logger.error(f"Error exiting live modal mode: {e}")
-            self.command_mode = CommandMode.NORMAL
-
-    async def _handle_status_modal_render(
-        self, event_data: Dict[str, Any], context: str = None
-    ) -> Dict[str, Any]:
-        """Handle status modal render events to provide modal display lines.
-
-        Args:
-            event_data: Event data containing render request.
-            context: Hook execution context.
-
-        Returns:
-            Dictionary with status modal lines if active.
-        """
-        try:
-            if (
-                self.command_mode == CommandMode.STATUS_MODAL
-                and self.current_status_modal_config
-            ):
-
-                # Generate status modal display lines
-                modal_lines = self._generate_status_modal_lines(
-                    self.current_status_modal_config
-                )
-
-                return {"success": True, "status_modal_lines": modal_lines}
-            else:
-                return {"success": True, "status_modal_lines": []}
-
-        except Exception as e:
-            logger.error(f"Error handling status modal render: {e}")
-            return {"success": False, "status_modal_lines": []}
-
-    def _generate_status_modal_lines(self, ui_config) -> List[str]:
-        """Generate formatted lines for status modal display using visual effects.
-
-        Args:
-            ui_config: UI configuration for the status modal.
-
-        Returns:
-            List of formatted lines for display.
-        """
-        try:
-            # Get dynamic terminal width
-            terminal_width = getattr(self.renderer.terminal_state, "width", 80)
-            # Reserve space for borders and padding (│ content │ = 4 chars total)
-            content_width = terminal_width - 6  # Leave 6 for borders/padding
-            max_line_length = content_width - 4  # Additional safety margin
-
-            content_lines = []
-
-            # Modal content based on config (no duplicate headers)
-            modal_config = ui_config.modal_config or {}
-
-            if "sections" in modal_config:
-                for section in modal_config["sections"]:
-                    # Skip section title since it's redundant with modal title
-                    # Display commands directly
-                    commands = section.get("commands", [])
-                    for cmd in commands:
-                        name = cmd.get("name", "")
-                        description = cmd.get("description", "")
-
-                        # Format command line with better alignment, using dynamic width
-                        cmd_line = f"{name:<28} {description}"
-                        if len(cmd_line) > max_line_length:
-                            cmd_line = cmd_line[: max_line_length - 3] + "..."
-
-                        content_lines.append(cmd_line)
-
-            # Add spacing before footer
-            content_lines.append("")
-
-            # Modal footer with special styling marker
-            footer = modal_config.get(
-                "footer",
-                "Press Esc to close • Use /help <command> for detailed help",
-            )
-            content_lines.append(f"__FOOTER__{footer}")
-
-            # Clean content lines for box rendering (no ANSI codes)
-            clean_content = []
-            for line in content_lines:
-                if line.startswith("__FOOTER__"):
-                    footer_text = line.replace("__FOOTER__", "")
-                    clean_content.append(footer_text)
-                else:
-                    clean_content.append(line)
-
-            # Use BoxRenderer from enhanced input plugin if available
-            try:
-                from ..plugins.enhanced_input.box_renderer import BoxRenderer
-                from ..plugins.enhanced_input.box_styles import (
-                    BoxStyleRegistry,
-                )
-                from ..plugins.enhanced_input.color_engine import ColorEngine
-                from ..plugins.enhanced_input.geometry import (
-                    GeometryCalculator,
-                )
-                from ..plugins.enhanced_input.text_processor import (
-                    TextProcessor,
-                )
-
-                # Initialize components
-                style_registry = BoxStyleRegistry()
-                color_engine = ColorEngine()
-                geometry = GeometryCalculator()
-                text_processor = TextProcessor()
-                box_renderer = BoxRenderer(
-                    style_registry, color_engine, geometry, text_processor
-                )
-
-                # Render with clean rounded style first, using dynamic width
-                bordered_lines = box_renderer.render_box(
-                    clean_content, content_width, "rounded"
-                )
-
-                # Add title to top border
-                title = ui_config.title or "Status Modal"
-                if bordered_lines:
-                    _ = bordered_lines[0]
-                    # Create title border: ╭─ Title ─────...─╮
-                    title_text = f"─ {title} "
-                    remaining_width = max(
-                        0, content_width - 2 - len(title_text)
-                    )  # content_width - 2 border chars - title length
-                    titled_border = f"╭{title_text}{'─' * remaining_width}╮"
-                    bordered_lines[0] = titled_border
-
-                # Apply styling to content lines after border rendering
-                styled_lines = []
-                for i, line in enumerate(bordered_lines):
-                    if i == 0 or i == len(bordered_lines) - 1:
-                        # Border lines - keep as is
-                        styled_lines.append(line)
-                    elif line.strip() and "│" in line:
-                        # Content lines with borders
-                        if any(
-                            footer in line for footer in ["Press Esc", "Use /help"]
-                        ):
-                            # Footer line - apply cyan
-                            styled_line = line.replace("│", "│\033[2;36m", 1)
-                            styled_line = styled_line.replace("│", "\033[0m│", -1)
-                            styled_lines.append(styled_line)
-                        elif line.strip() != "│" + " " * 76 + "│":  # Not empty line
-                            # Command line - apply dim
-                            styled_line = line.replace("│", "│\033[2m", 1)
-                            styled_line = styled_line.replace("│", "\033[0m│", -1)
-                            styled_lines.append(styled_line)
-                        else:
-                            # Empty line
-                            styled_lines.append(line)
-                    else:
-                        styled_lines.append(line)
-
-                return styled_lines
-
-            except ImportError:
-                # Fallback to simple manual borders if enhanced input not available
-                return self._create_simple_bordered_content(clean_content)
-
-        except Exception as e:
-            logger.error(f"Error generating status modal lines: {e}")
-            return [f"Error displaying status modal: {e}"]
-
-    def _create_simple_bordered_content(self, content_lines: List[str]) -> List[str]:
-        """Create simple bordered content as fallback.
-
-        Args:
-            content_lines: Content lines to border.
-
-        Returns:
-            Lines with simple borders.
-        """
-        # Get dynamic terminal width
-        terminal_width = getattr(self.renderer.terminal_state, "width", 80)
-        # Reserve space for borders and padding
-        width = terminal_width - 6  # Leave 6 for borders/padding
-        lines = []
+        """Delegate to ModalController."""
+        return await self._modal_controller._handle_status_modal_trigger(event_data, context)
 
-        # Simple top border
-        lines.append("╭" + "─" * (width + 2) + "╮")
+    async def _enter_status_modal_mode(self, ui_config) -> None:
+        """Delegate to ModalController."""
+        return await self._modal_controller._enter_status_modal_mode(ui_config)
 
-        # Content with side borders
-        for line in content_lines:
-            padded_line = f"{line:<{width}}"
-            lines.append(f"│ {padded_line} │")
+    async def _handle_status_modal_keypress(self, key_press) -> bool:
+        """Delegate to ModalController."""
+        return await self._modal_controller._handle_status_modal_keypress(key_press)
 
-        # Simple bottom border
-        lines.append("╰" + "─" * (width + 2) + "╯")
+    async def _exit_status_modal_mode(self) -> None:
+        """Delegate to ModalController."""
+        return await self._modal_controller._exit_status_modal_mode()
 
-        return lines
+    def _generate_status_modal_lines(self, ui_config) -> list:
+        """Delegate to StatusModalRenderer."""
+        return self._status_modal_renderer.generate_status_modal_lines(ui_config)