chore: update console components, logging, router and add subdomain support

src/Framework/Console/Components/ConsoleTUI.php

@@ -45,9 +45,13 @@ final readonly class ConsoleTUI
      */
     public function run(): ExitCode
     {
+        try {
             $this->initialize();
             $this->mainLoop();
+        } finally {
+            // Always cleanup, even on interrupt or error
             $this->cleanup();
+        }
 
         return ExitCode::SUCCESS;
     }
@@ -57,12 +61,35 @@ final readonly class ConsoleTUI
      */
     private function initialize(): void
     {
+        // Setup signal handlers for clean shutdown
+        $this->setupSignalHandlers();
+        
         $this->setupTerminal();
         $this->showWelcomeScreen();
         $this->loadCommands();
         $this->state->setRunning(true);
     }
 
+    /**
+     * Setup signal handlers for graceful shutdown
+     */
+    private function setupSignalHandlers(): void
+    {
+        if (function_exists('pcntl_signal')) {
+            pcntl_signal(SIGINT, [$this, 'handleShutdownSignal']);
+            pcntl_signal(SIGTERM, [$this, 'handleShutdownSignal']);
+        }
+    }
+
+    /**
+     * Handle shutdown signals (SIGINT, SIGTERM)
+     */
+    public function handleShutdownSignal(int $signal): void
+    {
+        $this->state->setRunning(false);
+        // Cleanup will be called in run() method's finally block or in cleanup()
+    }
+
     /**
      * Main event loop
      */
@@ -71,6 +98,11 @@ final readonly class ConsoleTUI
         $needsRender = true;
 
         while ($this->state->isRunning()) {
+            // Dispatch any pending signals (for graceful shutdown)
+            if (function_exists('pcntl_signal_dispatch')) {
+                pcntl_signal_dispatch();
+            }
+
             // Only render when needed
             if ($needsRender) {
                 $this->renderCurrentView();
@@ -104,8 +136,8 @@ final readonly class ConsoleTUI
 
         // Dispatch event to input handler
         if ($event instanceof MouseEvent) {
-            $this->inputHandler->handleMouseEvent($event, $this->state);
+            $needsRender = $this->inputHandler->handleMouseEvent($event, $this->state, $this->commandHistory);
-            return true; // Mouse events always need re-render
+            return $needsRender; // Only re-render if handler indicates it's needed
         } elseif ($event instanceof KeyEvent) {
             // Handle Ctrl+C
             if ($event->ctrl && $event->key === 'C') {
@@ -126,11 +158,84 @@ final readonly class ConsoleTUI
      */
     private function cleanup(): void
     {
+        // Flush any remaining mouse events from input buffer before restoring terminal
+        $this->flushRemainingInput();
+        
         $this->restoreTerminal();
         $this->output->writeLine('');
         $this->output->writeLine('👋 Console session ended. Goodbye!');
     }
 
+    /**
+     * Flush any remaining input events from STDIN to prevent them from appearing in terminal
+     */
+    private function flushRemainingInput(): void
+    {
+        // First, disable mouse tracking immediately to stop new events
+        // Send disable commands multiple times to ensure they're processed
+        for ($i = 0; $i < 3; $i++) {
+            $this->output->write(MouseControlCode::DISABLE_MOVE->format());
+            $this->output->write(MouseControlCode::DISABLE_SGR->format());
+            $this->output->write(MouseControlCode::DISABLE_ALL->format());
+        }
+        
+        // Flush output to ensure commands are sent immediately
+        if (function_exists('fflush')) {
+            fflush(STDOUT);
+        }
+        
+        // Delay to let terminal process disable commands
+        usleep(100000); // 100ms
+        
+        // Set non-blocking mode
+        $originalBlocking = stream_get_meta_data(STDIN)['blocked'] ?? true;
+        stream_set_blocking(STDIN, false);
+        
+        try {
+            // Aggressively read and discard ALL remaining input
+            $totalDiscarded = 0;
+            $maxAttempts = 200; // Read up to 200 characters
+            $attempt = 0;
+            
+            while ($attempt < $maxAttempts && $totalDiscarded < 1000) {
+                $read = [STDIN];
+                $write = null;
+                $except = null;
+                
+                // Very short timeout to quickly drain buffer
+                $result = stream_select($read, $write, $except, 0, 5000); // 5ms
+                
+                if ($result === false || $result === 0) {
+                    // No more input immediately available, try a few more times
+                    if ($attempt > 10 && $totalDiscarded === 0) {
+                        break; // No input after multiple attempts
+                    }
+                    $attempt++;
+                    usleep(5000); // 5ms
+                    continue;
+                }
+                
+                // Read and discard characters in chunks
+                $readCount = 0;
+                while (($char = fgetc(STDIN)) !== false && $readCount < 50) {
+                    $totalDiscarded++;
+                    $readCount++;
+                }
+                
+                if ($readCount === 0) {
+                    $attempt++;
+                    usleep(5000);
+                    continue;
+                }
+                
+                $attempt = 0; // Reset attempt counter if we read something
+            }
+        } finally {
+            // Restore blocking mode
+            stream_set_blocking(STDIN, $originalBlocking);
+        }
+    }
+
     /**
      * Setup terminal for interactive mode
      */
@@ -143,6 +248,10 @@ final readonly class ConsoleTUI
         // Enable mouse reporting (SGR format)
         $this->output->write(MouseControlCode::ENABLE_ALL->format());
         $this->output->write(MouseControlCode::ENABLE_SGR->format());
+        // Note: Mouse move tracking (ENABLE_MOVE) is disabled by default
+        // because it generates too many events that can overflow the input buffer
+        // If hover effects are needed, consider enabling it conditionally
+        // $this->output->write(MouseControlCode::ENABLE_MOVE->format());
 
         // Optional: Enable alternate screen buffer
         $this->output->write(ScreenControlCode::ALTERNATE_BUFFER->format());
@@ -157,7 +266,9 @@ final readonly class ConsoleTUI
      */
     private function restoreTerminal(): void
     {
-        // Disable mouse reporting
+        // Note: Mouse tracking is disabled in flushRemainingInput() before this
+        // But we disable it here too as a safety measure
+        $this->output->write(MouseControlCode::DISABLE_MOVE->format());
         $this->output->write(MouseControlCode::DISABLE_SGR->format());
         $this->output->write(MouseControlCode::DISABLE_ALL->format());
 

src/Framework/Console/Components/InputParser.php

@@ -130,6 +130,7 @@ final class InputParser
         $parts = explode(';', $data);
 
         if (count($parts) < 3) {
+            // Invalid mouse event format, discard
             return null;
         }
 
@@ -137,13 +138,20 @@ final class InputParser
         $x = (int) $parts[1];
         $y = (int) $parts[2];
         
+        // Validate coordinates (basic sanity check to catch corrupted events)
+        if ($x < 1 || $y < 1 || $x > 1000 || $y > 1000) {
+            // Invalid coordinates, likely corrupted event - discard silently
+            return null;
+        }
+
         // Decode button and modifiers
         // Bit flags in button code:
         // Bit 0-1: Button (0=left, 1=middle, 2=right, 3=release)
         // Bit 2: Shift
         // Bit 3: Meta/Alt
         // Bit 4: Ctrl
-        // Bit 5-6: Polarity (64=scroll up, 65=scroll down)
+        // Bit 5: Mouse move (32 = 0x20)
+        // Bit 6-7: Scroll (64=scroll up, 65=scroll down)
 
         $button = $buttonCode & 0x03;
         $shift = ($buttonCode & 0x04) !== 0;
@@ -153,6 +161,10 @@ final class InputParser
         // Handle scroll events (button codes 64 and 65)
         if ($buttonCode >= 64 && $buttonCode <= 65) {
             $button = $buttonCode;
+        } elseif (($buttonCode & 0x20) !== 0) {
+            // Mouse move (button code 32 or bit 5 set)
+            // Store full button code to detect mouse move
+            $button = $buttonCode;
         }
 
         $pressed = $buffer[-1] === 'M';
@@ -238,5 +250,34 @@ final class InputParser
             usleep(1000); // 1ms
         }
     }
+
+    /**
+     * Discard any remaining input characters from STDIN
+     */
+    private function discardRemainingInput(): void
+    {
+        // Read and discard up to 50 characters to clear partial escape sequences
+        $maxDiscard = 50;
+        $discarded = 0;
+        
+        while ($discarded < $maxDiscard) {
+            $read = [STDIN];
+            $write = null;
+            $except = null;
+            
+            $result = stream_select($read, $write, $except, 0, 1000); // 1ms
+            
+            if ($result === false || $result === 0) {
+                break; // No more input
+            }
+            
+            $char = fgetc(STDIN);
+            if ($char === false) {
+                break;
+            }
+            
+            $discarded++;
+        }
+    }
 }
 

src/Framework/Console/Components/MenuBar.php

@@ -10,34 +10,107 @@ use App\Framework\Console\ConsoleOutputInterface;
 /**
  * Menu bar with clickable entries
  */
-final readonly class MenuBar
+final class MenuBar
 {
+    /**
+     * @var array<int> Stores the start X position of each menu item (index => startX)
+     */
+    private array $itemPositions = [];
+    
+    /**
+     * @var array<int> Stores the end X position of each menu item (index => endX)
+     */
+    private array $itemEndPositions = [];
+    
+    /**
+     * @var ?string The active menu item used during last render (to know prefix length)
+     */
+    private ?string $lastActiveMenu = null;
+
+    /**
+     * @var array<string, array<string>> Submenu items for each menu item (menuItem => [subItem1, subItem2, ...])
+     */
+    private array $submenus = [];
+
     /**
      * @param array<string> $items Menu items (e.g. ['Datei', 'Bearbeiten', 'Ansicht', 'Hilfe'])
+     * @param array<string, array<string>> $submenus Optional submenu items for each menu item
      */
     public function __construct(
-        private array $items
+        private array $items,
+        array $submenus = []
     ) {
+        $this->submenus = $submenus;
+    }
+
+    /**
+     * Set submenu items for a menu item
+     */
+    public function setSubmenu(string $menuItem, array $submenuItems): void
+    {
+        $this->submenus[$menuItem] = $submenuItems;
+    }
+
+    /**
+     * Get submenu items for a menu item
+     */
+    public function getSubmenu(string $menuItem): array
+    {
+        return $this->submenus[$menuItem] ?? [];
+    }
+
+    /**
+     * Check if a menu item has submenu items
+     */
+    public function hasSubmenu(string $menuItem): bool
+    {
+        return !empty($this->submenus[$menuItem] ?? []);
     }
 
     /**
      * Render the menu bar at the top of the screen
+     * Tracks exact X positions of each menu item for accurate click detection
      */
-    public function render(ConsoleOutputInterface $output, ?string $activeMenu = null, int $screenWidth = 80): void
+    public function render(ConsoleOutputInterface $output, ?string $activeMenu = null, int $screenWidth = 80, ?string $hoveredMenuItem = null): void
     {
         $menuLine = '';
         $separator = ' | ';
         
+        // Reset positions arrays
+        $this->itemPositions = [];
+        $this->itemEndPositions = [];
+        $this->lastActiveMenu = $activeMenu;
+        
+        // Track current position in the menu line (1-based, as ANSI coordinates are 1-based)
+        $currentX = 1;
+
         foreach ($this->items as $index => $item) {
+            // Add separator before each item except the first
             if ($index > 0) {
                 $menuLine .= $separator;
+                $currentX += mb_strlen($separator);
             }
 
+            // Store the start position of this item (before prefix)
+            $this->itemPositions[$index] = $currentX;
+
             $isActive = $item === $activeMenu;
-            $color = $isActive ? ConsoleColor::BRIGHT_WHITE : ConsoleColor::WHITE;
+            $isHovered = $item === $hoveredMenuItem;
+            
+            // Determine color: active > hovered > normal
+            $color = $isActive ? ConsoleColor::BRIGHT_WHITE : ($isHovered ? ConsoleColor::BRIGHT_CYAN : ConsoleColor::WHITE);
             $prefix = $isActive ? '▶ ' : '  ';
 
-            $menuLine .= "{$prefix}{$item}";
+            // Build the item string with prefix
+            $itemString = "{$prefix}{$item}";
+            $menuLine .= $itemString;
+            
+            // Store the end position of this item (exclusive, so x < endX means inside item)
+            $itemLength = mb_strlen($itemString);
+            $this->itemEndPositions[$index] = $currentX + $itemLength;
+            
+            // Update position after this item
+            $currentX += $itemLength;
         }
 
         // Pad to screen width
@@ -53,25 +126,33 @@ final readonly class MenuBar
      */
     public function isClickInMenuArea(int $x, int $y): bool
     {
-        // Menu bar is always at y=1 (first line)
+        // Menu bar is at lines 2-3 (line 1 is empty spacing)
-        return $y === 1 && $x >= 1;
+        return ($y === 2 || $y === 3) && $x >= 1;
     }
 
     /**
-     * Get menu item at click position
+     * Get menu item at click position using tracked exact positions
      */
     public function getItemAtPosition(int $x): ?string
     {
-        // Simple calculation: approximate position based on item lengths
+        // If positions haven't been tracked yet (render not called), return null
-        // This is a simplified version - in a real implementation, you'd track exact positions
+        if (empty($this->itemPositions)) {
-        $currentPos = 3; // Start after initial padding
+            return null;
+        }
 
-        foreach ($this->items as $item) {
+        // Find which item contains this X position using tracked start and end positions
-            $itemLength = mb_strlen($item) + 4; // Include prefix and spacing
+        foreach ($this->items as $index => $item) {
-            if ($x >= $currentPos && $x < $currentPos + $itemLength) {
+            $startX = $this->itemPositions[$index] ?? null;
+            $endX = $this->itemEndPositions[$index] ?? null;
+            
+            if ($startX === null || $endX === null) {
+                continue;
+            }
+
+            // Check if click is within this item's range (startX inclusive, endX exclusive)
+            if ($x >= $startX && $x < $endX) {
                 return $item;
             }
-            $currentPos += $itemLength + 3; // Add separator length
         }
 
         return null;
@@ -113,5 +194,26 @@ final readonly class MenuBar
     {
         return $this->items;
     }
+
+    /**
+     * Get X position of a menu item (must be called after render)
+     */
+    public function getItemXPosition(int $index): ?int
+    {
+        return $this->itemPositions[$index] ?? null;
+    }
+
+    /**
+     * Get X position of a menu item by name (must be called after render)
+     */
+    public function getItemXPositionByName(string $itemName): ?int
+    {
+        $index = array_search($itemName, $this->items, true);
+        if ($index === false) {
+            return null;
+        }
+
+        return $this->itemPositions[$index] ?? null;
+    }
 }
 

src/Framework/Console/Components/MouseEvent.php

@@ -42,5 +42,16 @@ final readonly class MouseEvent
     {
         return in_array($this->button, [64, 65], true);
     }
+
+    /**
+     * Check if this is a mouse move event (mouse movement without button press)
+     * Button code 32 (0x20) indicates mouse move without any button pressed
+     */
+    public function isMouseMove(): bool
+    {
+        // Mouse move is indicated by button code 32 (bit 5 set)
+        // or by pressed=false when button is 0 (movement tracking)
+        return ($this->button & 0x20) !== 0 || (!$this->pressed && $this->button === 0);
+    }
 }
 

src/Framework/Console/Components/TuiInputHandler.php

@@ -13,8 +13,18 @@ use App\Framework\Discovery\ValueObjects\DiscoveredAttribute;
 /**
  * Handles all keyboard input and navigation for the TUI
  */
-final readonly class TuiInputHandler
+final class TuiInputHandler
 {
+    /**
+     * Track last hover update time to throttle mouse move events
+     */
+    private float $lastHoverUpdate = 0.0;
+
+    /**
+     * Minimum time between hover updates (50ms = 20 updates per second max)
+     */
+    private const float HOVER_UPDATE_INTERVAL = 0.05;
+
     public function __construct(
         private TuiCommandExecutor $commandExecutor,
         private ?MenuBar $menuBar = null
@@ -27,10 +37,25 @@ final readonly class TuiInputHandler
     public function handleInput(string $key, TuiState $state, CommandHistory $history): void
     {
         // Global shortcuts first
-        if ($this->handleGlobalShortcuts($key, $state)) {
+        $wasMenuAction = $this->handleGlobalShortcuts($key, $state);
+        if ($wasMenuAction) {
             return;
         }
 
+        // Handle dropdown navigation if dropdown is open
+        if ($state->getActiveDropdownMenu() !== null) {
+            $handled = $this->handleDropdownInput($key, $state);
+            if ($handled) {
+                return;
+            }
+        }
+
+        // Close active menu when any non-menu action is performed
+        // This prevents menu from staying open and causing flicker
+        if ($state->getActiveMenu() !== null && $state->getActiveDropdownMenu() === null) {
+            $state->setActiveMenu(null);
+        }
+
         // View-specific handling
         match ($state->getCurrentView()) {
             TuiView::CATEGORIES => $this->handleCategoriesInput($key, $state),
@@ -49,9 +74,19 @@ final readonly class TuiInputHandler
     private function handleGlobalShortcuts(string $key, TuiState $state): bool
     {
         switch ($key) {
+            case TuiKeyCode::ESCAPE->value:
+                // If dropdown is open, close it instead of quitting
+                if ($state->getActiveDropdownMenu() !== null) {
+                    $state->setActiveDropdownMenu(null);
+                    $state->setActiveMenu(null);
+                    return true;
+                }
+                // Otherwise quit
+                $state->setRunning(false);
+                return true;
+
             case 'q':
             case 'Q':
-            case TuiKeyCode::ESCAPE->value:
                 $state->setRunning(false);
 
                 return true;
@@ -296,12 +331,16 @@ final readonly class TuiInputHandler
     {
         switch ($key) {
             case TuiKeyCode::ARROW_UP->value:
-                $state->navigateUp();
+                // Use history-specific navigation with item count for proper wrap-around
+                $items = $this->getHistoryItems($state, $history);
+                $state->navigateHistoryItemUpWithCount(count($items));
 
                 break;
 
             case TuiKeyCode::ARROW_DOWN->value:
-                $state->navigateDown();
+                // Use history-specific navigation with item count for proper wrap-around
+                $items = $this->getHistoryItems($state, $history);
+                $state->navigateHistoryItemDownWithCount(count($items));
 
                 break;
 
@@ -494,25 +533,736 @@ final readonly class TuiInputHandler
     /**
      * Handle mouse events
      */
-    public function handleMouseEvent(MouseEvent $event, TuiState $state): void
+    public function handleMouseEvent(MouseEvent $event, TuiState $state, CommandHistory $history): bool
     {
-        // Only handle button presses, not releases
+        // Handle mouse move events for hover effects
-        if (! $event->pressed) {
+        if ($event->isMouseMove()) {
-            return;
+            return $this->handleMouseMove($event, $state, $history);
+        }
+
+        // Only handle button presses, not releases (except for scroll)
+        if (! $event->pressed && ! $event->isScrollEvent()) {
+            return false;
+        }
+
+        // Handle scroll events (mouse wheel)
+        if ($event->isScrollEvent()) {
+            // Only process scroll in views that support navigation
+            $currentView = $state->getCurrentView();
+            $scrollableViews = [
+                TuiView::CATEGORIES,
+                TuiView::COMMANDS,
+                TuiView::SEARCH,
+                TuiView::HISTORY,
+            ];
+
+            if (in_array($currentView, $scrollableViews, true)) {
+                if ($event->button === 64) {
+                    // Scroll Up
+                    if ($currentView === TuiView::HISTORY) {
+                        // Use history-specific navigation with item count for proper wrap-around
+                        $items = $this->getHistoryItems($state, $history);
+                        $state->navigateHistoryItemUpWithCount(count($items));
+                    } else {
+                        $state->navigateUp();
+                    }
+                } elseif ($event->button === 65) {
+                    // Scroll Down
+                    if ($currentView === TuiView::HISTORY) {
+                        // Use history-specific navigation with item count for proper wrap-around
+                        $items = $this->getHistoryItems($state, $history);
+                        $state->navigateHistoryItemDownWithCount(count($items));
+                    } else {
+                        $state->navigateDown();
+                    }
+                }
+            }
+
+            return true; // Re-render needed for scroll
         }
 
         // Only update status for menu clicks, not all mouse movements
         // This reduces flickering
 
+        // Handle dropdown clicks first (if dropdown is open)
+        if ($state->getActiveDropdownMenu() !== null) {
+            $dropdownItemIndex = $this->handleDropdownClick($event, $state);
+            if ($dropdownItemIndex !== null) {
+                // Dropdown click was handled
+                return true; // Re-render needed
+            }
+        }
+
         // Handle menu bar clicks
         if ($this->menuBar !== null && $this->menuBar->isClickInMenuArea($event->x, $event->y)) {
             $menuItem = $this->menuBar->getItemAtPosition($event->x);
             if ($menuItem !== null && $event->button === 0) {
-                // Left click on menu item
+                // Left click on menu item - open dropdown if it has submenus
+                if ($this->menuBar->hasSubmenu($menuItem)) {
                 $state->setActiveMenu($menuItem);
+                    $state->setActiveDropdownMenu($menuItem);
+                    $state->setSelectedDropdownItem(0);
                 $state->setStatus("Menü geöffnet: {$menuItem}");
+                } else {
+                    // No submenu, just set active menu
+                    $state->setActiveMenu($menuItem);
+                    $state->setActiveDropdownMenu(null);
+                    $state->setStatus("Menü: {$menuItem}");
                 }
             }
+
+            return true; // Re-render needed
+        }
+
+        // If dropdown is open and click is outside, close dropdown
+        if ($state->getActiveDropdownMenu() !== null && $event->button === 0) {
+            $state->setActiveDropdownMenu(null);
+            $state->setActiveMenu(null);
+            return true; // Re-render needed
+        }
+
+        // Handle item clicks (left and right button)
+        if ($event->button === 0) {
+            // Left click - primary action
+            $this->handleItemClick($event, $state, $history, false);
+            return true; // Re-render needed
+        } elseif ($event->button === 2) {
+            // Right click - alternative action
+            $this->handleItemClick($event, $state, $history, true);
+            return true; // Re-render needed
+        }
+
+        return false; // No re-render needed
+    }
+
+    /**
+     * Handle mouse move events for hover effects
+     * Returns true if hover state changed (needs re-render)
+     */
+    private function handleMouseMove(MouseEvent $event, TuiState $state, CommandHistory $history): bool
+    {
+        // Throttle mouse move events to reduce CPU usage
+        $now = microtime(true);
+        if (($now - $this->lastHoverUpdate) < self::HOVER_UPDATE_INTERVAL) {
+            return false; // Skip this event, too soon since last update
+        }
+        $this->lastHoverUpdate = $now;
+
+        $hoverChanged = false;
+        $oldHoveredMenuItem = $state->getHoveredMenuItem();
+        $oldHoveredDropdownItem = $state->getHoveredDropdownItem();
+        $oldHoveredContentType = $state->getHoveredContentItemType();
+        $oldHoveredContentIndex = $state->getHoveredContentItemIndex();
+
+        // Check if mouse is over menu bar (lines 2-3)
+        if ($this->menuBar !== null && $this->menuBar->isClickInMenuArea($event->x, $event->y)) {
+            $menuItem = $this->menuBar->getItemAtPosition($event->x);
+            if ($menuItem !== null) {
+                $state->setHoveredMenuItem($menuItem);
+                $state->setHoveredDropdownItem(null);
+                $state->setHoveredContentItem(null, null);
+                
+                if ($oldHoveredMenuItem !== $menuItem) {
+                    $hoverChanged = true;
+                }
+            } else {
+                $state->setHoveredMenuItem(null);
+                if ($oldHoveredMenuItem !== null) {
+                    $hoverChanged = true;
+                }
+            }
+
+            return $hoverChanged;
+        }
+
+        // Check if mouse is over dropdown menu
+        if ($state->getActiveDropdownMenu() !== null) {
+            $dropdownItemIndex = $this->calculateDropdownHoverIndex($event, $state);
+            $state->setHoveredDropdownItem($dropdownItemIndex);
+            $state->setHoveredMenuItem(null);
+            $state->setHoveredContentItem(null, null);
+            
+            if ($oldHoveredDropdownItem !== $dropdownItemIndex) {
+                $hoverChanged = true;
+            }
+
+            return $hoverChanged;
+        }
+
+        // Check if mouse is over content items
+        $contentItemIndex = $this->calculateContentItemIndex($event->y, $state);
+        $currentView = $state->getCurrentView();
+        
+        if ($contentItemIndex !== null) {
+            $itemType = match ($currentView) {
+                TuiView::CATEGORIES => 'category',
+                TuiView::COMMANDS => 'command',
+                TuiView::SEARCH => 'search',
+                TuiView::HISTORY => 'history',
+                default => null,
+            };
+
+            if ($itemType !== null) {
+                $state->setHoveredContentItem($itemType, $contentItemIndex);
+                $state->setHoveredMenuItem(null);
+                $state->setHoveredDropdownItem(null);
+
+                if ($oldHoveredContentType !== $itemType || $oldHoveredContentIndex !== $contentItemIndex) {
+                    $hoverChanged = true;
+                }
+            }
+        } else {
+            // Clear content hover
+            $state->setHoveredContentItem(null, null);
+            $state->setHoveredMenuItem(null);
+            $state->setHoveredDropdownItem(null);
+
+            if ($oldHoveredContentType !== null || $oldHoveredContentIndex !== null) {
+                $hoverChanged = true;
+            }
+        }
+
+        return $hoverChanged;
+    }
+
+    /**
+     * Calculate content item index from Y position
+     */
+    private function calculateContentItemIndex(int $y, TuiState $state): ?int
+    {
+        return match ($state->getCurrentView()) {
+            TuiView::CATEGORIES => $this->calculateCategoryIndex($y),
+            TuiView::COMMANDS => $this->calculateCommandIndex($y, $state),
+            TuiView::SEARCH => $this->calculateSearchResultIndex($y, $state),
+            TuiView::HISTORY => $this->calculateHistoryItemIndex($y),
+            default => null,
+        };
+    }
+
+    /**
+     * Calculate which dropdown item is hovered based on mouse position
+     */
+    private function calculateDropdownHoverIndex(MouseEvent $event, TuiState $state): ?int
+    {
+        if ($this->menuBar === null) {
+            return null;
+        }
+
+        $activeDropdown = $state->getActiveDropdownMenu();
+        if ($activeDropdown === null) {
+            return null;
+        }
+
+        $submenuItems = $this->menuBar->getSubmenu($activeDropdown);
+        if (empty($submenuItems)) {
+            return null;
+        }
+
+        $menuItems = $this->menuBar->getItems();
+        $activeIndex = array_search($activeDropdown, $menuItems, true);
+        
+        if ($activeIndex === false) {
+            return null;
+        }
+
+        $dropdownX = $this->menuBar->getItemXPosition($activeIndex) ?? 1;
+        
+        // Check if mouse is in dropdown area (line 4+, column dropdownX+)
+        if ($event->y < 4 || $event->x < $dropdownX) {
+            return null;
+        }
+
+        $dropdownItemIndex = $event->y - 4;
+        
+        if ($dropdownItemIndex < 0 || $dropdownItemIndex >= count($submenuItems)) {
+            return null;
+        }
+
+        // Don't hover over separators
+        if (($submenuItems[$dropdownItemIndex] ?? '') === '---') {
+            return null;
+        }
+
+        return $dropdownItemIndex;
+    }
+
+    /**
+     * Handle clicks on list items
+     * 
+     * @param bool $isRightClick True for right click (alternative action), false for left click (primary action)
+     */
+    private function handleItemClick(MouseEvent $event, TuiState $state, CommandHistory $history, bool $isRightClick): void
+    {
+        $currentView = $state->getCurrentView();
+        
+        // Menu bar takes lines 1-2, items start below
+        if ($event->y <= 2) {
+            return; // Click is in menu bar area
+        }
+
+        // Calculate item index from Y position based on view
+        $itemIndex = $this->calculateItemIndexFromY($event->y, $currentView, $state);
+        
+        if ($itemIndex === null) {
+            return; // Click is not on an item
+        }
+
+        // Select item and execute action based on view
+        if ($isRightClick) {
+            // Right click - alternative actions
+            match ($currentView) {
+                TuiView::CATEGORIES => $this->handleCategoryClick($itemIndex, $state), // Same as left click
+                TuiView::COMMANDS => $this->handleCommandRightClick($itemIndex, $state),
+                TuiView::SEARCH => $this->handleSearchResultRightClick($itemIndex, $state),
+                TuiView::HISTORY => $this->handleHistoryItemRightClick($itemIndex, $state, $history),
+                default => null,
+            };
+        } else {
+            // Left click - primary actions
+            match ($currentView) {
+                TuiView::CATEGORIES => $this->handleCategoryClick($itemIndex, $state),
+                TuiView::COMMANDS => $this->handleCommandClick($itemIndex, $state),
+                TuiView::SEARCH => $this->handleSearchResultClick($itemIndex, $state),
+                TuiView::HISTORY => $this->handleHistoryItemClick($itemIndex, $state, $history),
+                default => null, // Other views don't support item clicks
+            };
+        }
+    }
+
+    /**
+     * Calculate item index from Y position
+     * 
+     * Layout:
+     * - Line 1-2: Menu bar + separator
+     * - Line 3: Header (varies by view)
+     * - Line 4: Empty line (or search box in search view)
+     * - Line 5+: Items (varies by view)
+     */
+    private function calculateItemIndexFromY(int $y, TuiView $view, TuiState $state): ?int
+    {
+        return match ($view) {
+            TuiView::CATEGORIES => $this->calculateCategoryIndex($y),
+            TuiView::COMMANDS => $this->calculateCommandIndex($y, $state),
+            TuiView::SEARCH => $this->calculateSearchResultIndex($y, $state),
+            TuiView::HISTORY => $this->calculateHistoryItemIndex($y),
+            default => null,
+        };
+    }
+
+    /**
+     * Calculate category index from Y position
+     * Layout: Empty(1) + Menu(2-3) + Header(4) + Empty(5) + Items(6+)
+     */
+    private function calculateCategoryIndex(int $y): ?int
+    {
+        // Items start at line 6 (after empty 1 + menu 2-3 + header "📂 Select Category:" at 4 + empty at 5)
+        $startLine = 6;
+        
+        if ($y < $startLine) {
+            return null;
+        }
+
+        // Each category takes 1 line
+        $index = $y - $startLine;
+        
+        return $index;
+    }
+
+    /**
+     * Calculate command index from Y position
+     * Layout: Empty(1) + Menu(2-3) + Header(4) + Empty(5) + Items(6+)
+     * Commands can take 1-2 lines (name + optional description)
+     */
+    private function calculateCommandIndex(int $y, TuiState $state): ?int
+    {
+        // Items start at line 6 (after empty 1 + menu 2-3 + header at 4 + empty at 5)
+        $startLine = 6;
+        
+        if ($y < $startLine) {
+            return null;
+        }
+
+        $category = $state->getCurrentCategory();
+        if (! $category) {
+            return null;
+        }
+
+        $commands = $category['commands'] ?? [];
+        $currentLine = $startLine;
+        $index = 0;
+
+        foreach ($commands as $command) {
+            // Check if click is on this command's line
+            if ($y === $currentLine) {
+                return $index;
+            }
+
+            // Move to next item (1 line for name, +1 if has description)
+            $commandDescription = $this->getCommandDescription($command);
+            $lines = empty($commandDescription) ? 1 : 2;
+            $currentLine += $lines;
+            $index++;
+        }
+
+        return null;
+    }
+
+    /**
+     * Calculate search result index from Y position
+     * Layout: Empty(1) + Menu(2-3) + Header(4) + Empty(5) + SearchBox(6) + Empty(7) + "Found X"(8) + Empty(9) + Items(10+)
+     */
+    private function calculateSearchResultIndex(int $y, TuiState $state): ?int
+    {
+        // Items start at line 10 (after empty 1 + menu 2-3 + header 4 + empty 5 + searchbox 6 + empty 7 + "Found" 8 + empty 9)
+        $startLine = 10;
+        
+        if ($y < $startLine) {
+            return null;
+        }
+
+        $results = $state->getSearchResults();
+        if (empty($results)) {
+            return null; // No results to click
+        }
+
+        $currentLine = $startLine;
+        $index = 0;
+
+        foreach ($results as $result) {
+            // Check if click is on this result's line
+            if ($y === $currentLine) {
+                return $index;
+            }
+
+            // Move to next item (1 line for name, +1 if has description)
+            $commandDescription = $this->getCommandDescription($result);
+            $lines = empty($commandDescription) ? 1 : 2;
+            $currentLine += $lines;
+            $index++;
+        }
+
+        return null;
+    }
+
+    /**
+     * Calculate history item index from Y position
+     * Layout: Empty(1) + Menu(2-3) + Header(4) + Empty(5) + Tabs(6) + Empty(7) + Items(8+)
+     */
+    private function calculateHistoryItemIndex(int $y): ?int
+    {
+        // Items start at line 8 (after empty 1 + menu 2-3 + header 4 + empty 5 + tabs 6 + empty 7)
+        $startLine = 8;
+        
+        if ($y < $startLine) {
+            return null;
+        }
+
+        // Each history item takes 1 line
+        $index = $y - $startLine;
+        
+        return $index;
+    }
+
+    /**
+     * Get command description from command object
+     */
+    private function getCommandDescription(object $command): string
+    {
+        if ($command instanceof \App\Framework\Discovery\ValueObjects\DiscoveredAttribute) {
+            $attribute = $command->createAttributeInstance();
+            return $attribute?->description ?? '';
+        }
+
+        return $command->description ?? '';
+    }
+
+    /**
+     * Handle dropdown menu input (navigation and selection)
+     */
+    private function handleDropdownInput(string $key, TuiState $state): bool
+    {
+        if ($this->menuBar === null) {
+            return false;
+        }
+
+        $activeDropdown = $state->getActiveDropdownMenu();
+        if ($activeDropdown === null) {
+            return false;
+        }
+
+        $submenuItems = $this->menuBar->getSubmenu($activeDropdown);
+        if (empty($submenuItems)) {
+            return false;
+        }
+
+        $maxIndex = count($submenuItems) - 1;
+        $currentIndex = $state->getSelectedDropdownItem();
+
+        switch ($key) {
+            case TuiKeyCode::ARROW_UP->value:
+                // Navigate up with wrap-around
+                $newIndex = $currentIndex - 1;
+                if ($newIndex < 0) {
+                    $newIndex = $maxIndex;
+                }
+                // Skip separators
+                while ($newIndex >= 0 && ($submenuItems[$newIndex] ?? '') === '---') {
+                    $newIndex--;
+                }
+                if ($newIndex < 0) {
+                    $newIndex = $maxIndex;
+                }
+                $state->setSelectedDropdownItem($newIndex);
+                return true;
+
+            case TuiKeyCode::ARROW_DOWN->value:
+                // Navigate down with wrap-around
+                $newIndex = $currentIndex + 1;
+                if ($newIndex > $maxIndex) {
+                    $newIndex = 0;
+                }
+                // Skip separators
+                while ($newIndex <= $maxIndex && ($submenuItems[$newIndex] ?? '') === '---') {
+                    $newIndex++;
+                }
+                if ($newIndex > $maxIndex) {
+                    $newIndex = 0;
+                }
+                $state->setSelectedDropdownItem($newIndex);
+                return true;
+
+            case TuiKeyCode::ENTER->value:
+                // Execute selected dropdown item
+                $selectedItem = $submenuItems[$currentIndex] ?? null;
+                if ($selectedItem !== null && $selectedItem !== '---') {
+                    $this->executeDropdownItem($activeDropdown, $selectedItem, $state);
+                    $state->setActiveDropdownMenu(null);
+                    $state->setActiveMenu(null);
+                }
+                return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Handle dropdown menu clicks
+     */
+    private function handleDropdownClick(MouseEvent $event, TuiState $state): ?int
+    {
+        if ($this->menuBar === null || $event->button !== 0) {
+            return null;
+        }
+
+        $activeDropdown = $state->getActiveDropdownMenu();
+        if ($activeDropdown === null) {
+            return null;
+        }
+
+        $submenuItems = $this->menuBar->getSubmenu($activeDropdown);
+        if (empty($submenuItems)) {
+            return null;
+        }
+
+        // Dropdown is rendered starting at line 4, column dropdownX (after menu bar at 2-3)
+        // We need to check if click is within dropdown area
+        $menuItems = $this->menuBar->getItems();
+        $activeIndex = array_search($activeDropdown, $menuItems, true);
+        
+        if ($activeIndex === false) {
+            return null;
+        }
+
+        // Get dropdown X position (approximate for now)
+        $dropdownX = $this->menuBar->getItemXPosition($activeIndex) ?? 1;
+        
+        // Check if click is in dropdown area (line 4+, column dropdownX+)
+        if ($event->y < 4 || $event->x < $dropdownX) {
+            return null;
+        }
+
+        // Calculate which dropdown item was clicked
+        $dropdownItemIndex = $event->y - 4;
+        
+        if ($dropdownItemIndex < 0 || $dropdownItemIndex >= count($submenuItems)) {
+            return null;
+        }
+
+        $clickedItem = $submenuItems[$dropdownItemIndex] ?? null;
+        if ($clickedItem === null || $clickedItem === '---') {
+            return null;
+        }
+
+        // Execute clicked item
+        $this->executeDropdownItem($activeDropdown, $clickedItem, $state);
+        $state->setActiveDropdownMenu(null);
+        $state->setActiveMenu(null);
+
+        return $dropdownItemIndex;
+    }
+
+    /**
+     * Execute a dropdown menu item action
+     */
+    private function executeDropdownItem(string $menu, string $item, TuiState $state): void
+    {
+        $state->setStatus("Ausgeführt: {$menu} > {$item}");
+        // TODO: Implement actual actions for dropdown items
+    }
+
+    /**
+     * Handle category click - select category and navigate to commands
+     */
+    private function handleCategoryClick(int $index, TuiState $state): void
+    {
+        $categories = $state->getCategories();
+        
+        if ($index < 0 || $index >= count($categories)) {
+            return;
+        }
+
+        $state->setSelectedCategory($index);
+        $state->setCurrentView(TuiView::COMMANDS);
+        $state->setSelectedCommand(0);
+    }
+
+    /**
+     * Handle command click - select command and execute it
+     */
+    private function handleCommandClick(int $index, TuiState $state): void
+    {
+        $category = $state->getCurrentCategory();
+        if (! $category) {
+            return;
+        }
+
+        $commands = $category['commands'] ?? [];
+        
+        if ($index < 0 || $index >= count($commands)) {
+            return;
+        }
+
+        $state->setSelectedCommand($index);
+        $command = $commands[$index];
+        
+        if ($command) {
+            $this->commandExecutor->executeSelectedCommand($command);
+        }
+    }
+
+    /**
+     * Handle search result click - select result and execute it
+     */
+    private function handleSearchResultClick(int $index, TuiState $state): void
+    {
+        $results = $state->getSearchResults();
+        
+        if ($index < 0 || $index >= count($results)) {
+            return;
+        }
+
+        $state->setSelectedSearchResult($index);
+        $command = $results[$index];
+        
+        if ($command) {
+            // Handle DiscoveredAttribute objects
+            if ($command instanceof \App\Framework\Discovery\ValueObjects\DiscoveredAttribute) {
+                $attribute = $command->createAttributeInstance();
+                if ($attribute !== null) {
+                    $this->commandExecutor->executeCommand($attribute->name);
+                }
+            } else {
+                $this->commandExecutor->executeCommand($command->name);
+            }
+        }
+    }
+
+    /**
+     * Handle history item click - select item and execute it
+     */
+    private function handleHistoryItemClick(int $index, TuiState $state, CommandHistory $history): void
+    {
+        $items = $this->getHistoryItems($state, $history);
+        
+        if ($index < 0 || $index >= count($items)) {
+            return;
+        }
+
+        $state->setSelectedHistoryItem($index);
+        
+        // Execute the history item (same as Enter key)
+        if (isset($items[$index])) {
+            $command = $items[$index]['command'];
+            $history->addToHistory($command);
+            $this->commandExecutor->executeCommand($command);
+        }
+    }
+
+    /**
+     * Handle command right click - open parameter form
+     */
+    private function handleCommandRightClick(int $index, TuiState $state): void
+    {
+        $category = $state->getCurrentCategory();
+        if (! $category) {
+            return;
+        }
+
+        $commands = $category['commands'] ?? [];
+        
+        if ($index < 0 || $index >= count($commands)) {
+            return;
+        }
+
+        $state->setSelectedCommand($index);
+        $command = $commands[$index];
+        
+        if ($command) {
+            $state->setSelectedCommandForForm($command);
+            $state->setCurrentView(TuiView::FORM);
+        }
+    }
+
+    /**
+     * Handle search result right click - open parameter form
+     */
+    private function handleSearchResultRightClick(int $index, TuiState $state): void
+    {
+        $results = $state->getSearchResults();
+        
+        if ($index < 0 || $index >= count($results)) {
+            return;
+        }
+
+        $state->setSelectedSearchResult($index);
+        $command = $results[$index];
+        
+        if ($command) {
+            $state->setSelectedCommandForForm($command);
+            $state->setCurrentView(TuiView::FORM);
+        }
+    }
+
+    /**
+     * Handle history item right click - toggle favorite
+     */
+    private function handleHistoryItemRightClick(int $index, TuiState $state, CommandHistory $history): void
+    {
+        $items = $this->getHistoryItems($state, $history);
+        
+        if ($index < 0 || $index >= count($items)) {
+            return;
+        }
+
+        $state->setSelectedHistoryItem($index);
+        
+        // Toggle favorite (same as F key)
+        if (isset($items[$index])) {
+            $command = $items[$index]['command'];
+            $isFavorite = $history->toggleFavorite($command);
+            $status = $isFavorite ? 'Zu Favoriten hinzugefügt' : 'Aus Favoriten entfernt';
+            $state->setStatus("{$command}: {$status}");
+        }
     }
 
     /**

src/Framework/Console/Components/TuiRenderer.php

@@ -17,15 +17,22 @@ use App\Framework\Discovery\ValueObjects\DiscoveredAttribute;
 /**
  * Handles all rendering and display logic for the TUI
  */
-final readonly class TuiRenderer
+final class TuiRenderer
 {
     private MenuBar $menuBar;
+    private bool $menuBarInitialized = false;
 
     public function __construct(
         private ConsoleOutputInterface $output
     ) {
-        // Initialize menu bar with default items
+        // Initialize menu bar with default items and submenus
-        $this->menuBar = new MenuBar(['Datei', 'Bearbeiten', 'Ansicht', 'Hilfe']);
+        $submenus = [
+            'Datei' => ['Neu', 'Öffnen', 'Speichern', '---', 'Beenden'],
+            'Bearbeiten' => ['Rückgängig', 'Wiederholen', '---', 'Ausschneiden', 'Kopieren', 'Einfügen'],
+            'Ansicht' => ['Vergrößern', 'Verkleinern', 'Normal', '---', 'Vollbild'],
+            'Hilfe' => ['Hilfe anzeigen', 'Über'],
+        ];
+        $this->menuBar = new MenuBar(['Datei', 'Bearbeiten', 'Ansicht', 'Hilfe'], $submenus);
     }
 
     /**
@@ -33,18 +40,28 @@ final readonly class TuiRenderer
      */
     public function render(TuiState $state, CommandHistory $history): void
     {
-        $this->clearScreen();
-        
         // Get terminal size for layout
         $terminalSize = TerminalSize::detect();
         
-        // Render menu bar at top
+        // On first render, clear entire screen to remove any welcome screen content
+        if (!$this->menuBarInitialized) {
+            $this->clearScreen();
+            $this->menuBarInitialized = true;
+        } else {
+            // On subsequent renders, clear ONLY the content area (preserve menu bar on lines 1-3)
+            // Line 1: empty spacing
+            // Lines 2-3: menu bar
+            // Line 4+: content (this will be cleared and redrawn)
+            $this->clearContentArea();
+        }
+        
+        // Render menu bar on lines 2-3 FIRST, before any content
         $this->renderMenuBar($state, $terminalSize->width);
         
-        // Render header (or skip if menu bar replaces it)
+        // Position cursor at line 4, before rendering content
-        // $this->renderHeader();
+        $this->output->write(CursorControlCode::POSITION->format(4, 1));
 
-        // Render main content
+        // Render main content starting at line 4 (after spacing + menu bar)
         match ($state->getCurrentView()) {
             TuiView::CATEGORIES => $this->renderCategories($state),
             TuiView::COMMANDS => $this->renderCommands($state),
@@ -57,10 +74,24 @@ final readonly class TuiRenderer
         
         // Render status line at bottom
         $this->renderStatusLine($state, $terminalSize->width);
+        
+        // Render dropdown menu if a menu is active and has submenus
+        $this->renderDropdownMenu($state, $terminalSize->width);
+        
+        // Position cursor safely after rendering (below status line)
+        $terminalSize = TerminalSize::detect();
+        $cursorLine = min($terminalSize->height + 1, $terminalSize->height);
+        $this->output->write(CursorControlCode::POSITION->format($cursorLine, 1));
+        
+        // Final flush to ensure everything is displayed
+        if (function_exists('fflush')) {
+            fflush(STDOUT);
+        }
     }
 
     /**
      * Clear screen and reset cursor
+     * Note: This clears the entire screen. Use clearContentArea() to preserve the menu bar.
      */
     private function clearScreen(): void
     {
@@ -68,6 +99,26 @@ final readonly class TuiRenderer
         $this->output->write(CursorControlCode::POSITION->format(1, 1));
     }
 
+    /**
+     * Clear only the content area (from line 4 downwards), preserving the menu bar (lines 1-3)
+     */
+    private function clearContentArea(): void
+    {
+        // First, clear line 1 explicitly (spacing line)
+        $this->output->write(CursorControlCode::POSITION->format(1, 1));
+        $terminalSize = TerminalSize::detect();
+        $this->output->write(str_repeat(' ', $terminalSize->width));
+        
+        // Position cursor at line 4 (start of content area)
+        $this->output->write(CursorControlCode::POSITION->format(4, 1));
+        
+        // Clear everything from cursor downwards (preserves lines 1-3: spacing + menu bar)
+        $this->output->write(ScreenControlCode::CLEAR_BELOW->format());
+        
+        // Position cursor back at line 4 for content rendering
+        $this->output->write(CursorControlCode::POSITION->format(4, 1));
+    }
+
     /**
      * Render header with title
      */
@@ -90,7 +141,8 @@ final readonly class TuiRenderer
         $categories = $state->getCategories();
         foreach ($categories as $index => $category) {
             $isSelected = $index === $state->getSelectedCategory();
-            $this->renderCategoryItem($category, $isSelected);
+            $isHovered = $state->isContentItemHovered('category', $index);
+            $this->renderCategoryItem($category, $isSelected, $isHovered);
         }
 
         $this->output->newLine();
@@ -108,14 +160,15 @@ final readonly class TuiRenderer
     /**
      * Render a category item
      */
-    private function renderCategoryItem(array $category, bool $isSelected): void
+    private function renderCategoryItem(array $category, bool $isSelected, bool $isHovered = false): void
     {
         $icon = $category['icon'] ?? '📁';
         $name = $category['name'];
         $count = count($category['commands']);
 
         $prefix = $isSelected ? '▶ ' : '  ';
-        $color = $isSelected ? ConsoleColor::BRIGHT_WHITE : ConsoleColor::WHITE;
+        // Determine color: selected > hovered > normal
+        $color = $isSelected ? ConsoleColor::BRIGHT_WHITE : ($isHovered ? ConsoleColor::BRIGHT_CYAN : ConsoleColor::WHITE);
 
         $this->output->writeLine(
             "{$prefix}{$icon} {$name} ({$count} commands)",
@@ -139,7 +192,8 @@ final readonly class TuiRenderer
 
         foreach ($category['commands'] as $index => $command) {
             $isSelected = $index === $state->getSelectedCommand();
-            $this->renderCommandItem($command, $isSelected);
+            $isHovered = $state->isContentItemHovered('command', $index);
+            $this->renderCommandItem($command, $isSelected, $isHovered);
         }
 
         $this->output->newLine();
@@ -159,10 +213,11 @@ final readonly class TuiRenderer
     /**
      * Render a command item
      */
-    private function renderCommandItem(object $command, bool $isSelected): void
+    private function renderCommandItem(object $command, bool $isSelected, bool $isHovered = false): void
     {
         $prefix = $isSelected ? '▶ ' : '  ';
-        $color = $isSelected ? ConsoleColor::BRIGHT_WHITE : ConsoleColor::WHITE;
+        // Determine color: selected > hovered > normal
+        $color = $isSelected ? ConsoleColor::BRIGHT_WHITE : ($isHovered ? ConsoleColor::BRIGHT_CYAN : ConsoleColor::WHITE);
 
         // Handle DiscoveredAttribute objects
         if ($command instanceof DiscoveredAttribute) {
@@ -214,7 +269,8 @@ final readonly class TuiRenderer
 
             foreach ($results as $index => $command) {
                 $isSelected = $index === $state->getSelectedSearchResult();
-                $this->renderCommandItem($command, $isSelected);
+                $isHovered = $state->isContentItemHovered('search', $index);
+                $this->renderCommandItem($command, $isSelected, $isHovered);
             }
 
             $current = $state->getSelectedSearchResult() + 1;
@@ -259,7 +315,8 @@ final readonly class TuiRenderer
         } else {
             foreach ($items as $index => $item) {
                 $isSelected = $index === $state->getSelectedHistoryItem();
-                $this->renderHistoryItem($item, $isSelected, $history);
+                $isHovered = $state->isContentItemHovered('history', $index);
+                $this->renderHistoryItem($item, $isSelected, $history, $isHovered);
             }
         }
 
@@ -312,10 +369,11 @@ final readonly class TuiRenderer
     /**
      * Render history item
      */
-    private function renderHistoryItem(array $item, bool $isSelected, CommandHistory $history): void
+    private function renderHistoryItem(array $item, bool $isSelected, CommandHistory $history, bool $isHovered = false): void
     {
         $prefix = $isSelected ? '▶ ' : '  ';
-        $color = $isSelected ? ConsoleColor::BRIGHT_WHITE : ConsoleColor::WHITE;
+        // Determine color: selected > hovered > normal
+        $color = $isSelected ? ConsoleColor::BRIGHT_WHITE : ($isHovered ? ConsoleColor::BRIGHT_CYAN : ConsoleColor::WHITE);
 
         $command = $item['command'];
         $isFavorite = $history->isFavorite($command);
@@ -466,7 +524,121 @@ final readonly class TuiRenderer
      */
     private function renderMenuBar(TuiState $state, int $screenWidth): void
     {
-        $this->menuBar->render($this->output, $state->getActiveMenu(), $screenWidth);
+        // Explicitly position cursor at line 2 before rendering menu bar
+        // Line 1 is empty spacing, menu bar is at lines 2-3
+        $this->output->write(CursorControlCode::POSITION->format(2, 1));
+        
+        // Render menu bar (will write to lines 2-3)
+        $this->menuBar->render($this->output, $state->getActiveMenu(), $screenWidth, $state->getHoveredMenuItem());
+        
+        // Flush to ensure menu bar is immediately visible
+        if (function_exists('fflush')) {
+            fflush(STDOUT);
+        }
+    }
+
+    /**
+     * Render dropdown menu under active menu item
+     */
+    private function renderDropdownMenu(TuiState $state, int $screenWidth): void
+    {
+        $activeMenu = $state->getActiveMenu();
+        
+        // Only render dropdown if a menu is active and has submenus
+        if ($activeMenu === null || !$this->menuBar->hasSubmenu($activeMenu)) {
+            return;
+        }
+
+        $submenuItems = $this->menuBar->getSubmenu($activeMenu);
+        if (empty($submenuItems)) {
+            return;
+        }
+
+        // Find the X position of the active menu item
+        // We'll need to get it from the menu bar's tracked positions
+        $menuItems = $this->menuBar->getItems();
+        $activeIndex = array_search($activeMenu, $menuItems, true);
+        
+        if ($activeIndex === false) {
+            return;
+        }
+
+        // Get the X position of this menu item from tracked positions
+        // Note: MenuBar must be rendered first to track positions, but we render dropdown before menu bar
+        // So we'll use the approximate calculation
+        $dropdownX = $this->menuBar->getItemXPosition($activeIndex) ?? $this->calculateDropdownXPosition($activeIndex, $activeMenu);
+        
+        // Render dropdown starting at line 4, column dropdownX (after menu bar at 2-3)
+        // Find the maximum width of submenu items
+        $maxWidth = 0;
+        foreach ($submenuItems as $item) {
+            if ($item === '---') {
+                continue; // Separator
+            }
+            $maxWidth = max($maxWidth, mb_strlen($item) + 2); // +2 for padding
+        }
+        $dropdownWidth = min($maxWidth, $screenWidth - $dropdownX + 1);
+
+        // Render dropdown box at line 4
+        $this->output->write(CursorControlCode::POSITION->format(4, $dropdownX));
+        
+        $selectedIndex = $state->getSelectedDropdownItem();
+        $itemCount = count($submenuItems);
+        
+        foreach ($submenuItems as $index => $item) {
+            // Position at line 4 + index
+            $line = 4 + $index;
+            $this->output->write(CursorControlCode::POSITION->format($line, $dropdownX));
+            
+            if ($item === '---') {
+                // Render separator
+                $this->output->write(str_repeat('─', $dropdownWidth - 2), ConsoleColor::GRAY);
+            } else {
+                $isSelected = $index === $selectedIndex;
+                $isHovered = $index === $state->getHoveredDropdownItem();
+                
+                // Render item with selection indicator
+                $prefix = $isSelected ? '▶ ' : '  ';
+                $text = $prefix . $item;
+                
+                // Pad to dropdown width
+                $padding = max(0, $dropdownWidth - mb_strlen($text) - 2);
+                $text .= str_repeat(' ', $padding);
+                
+                // Determine color: selected > hovered > normal
+                $color = $isSelected ? ConsoleColor::BRIGHT_WHITE : ($isHovered ? ConsoleColor::BRIGHT_CYAN : ConsoleColor::WHITE);
+                $this->output->writeLine($text, $color);
+            }
+        }
+    }
+
+    /**
+     * Calculate X position for dropdown based on menu item index
+     */
+    private function calculateDropdownXPosition(int $menuIndex, string $menuItem): int
+    {
+        // Approximate calculation: we need to sum up widths of all previous items
+        $items = $this->menuBar->getItems();
+        $x = 1; // Start at column 1
+        
+        for ($i = 0; $i < $menuIndex; $i++) {
+            $item = $items[$i];
+            // Approximate width: separator (3) + prefix (2) + item length
+            $separatorWidth = $i > 0 ? 3 : 0; // " | " separator
+            $prefixWidth = 2; // "  " or "▶ "
+            $itemWidth = mb_strlen($item);
+            $x += $separatorWidth + $prefixWidth + $itemWidth;
+        }
+        
+        // Add separator for current item (if not first)
+        if ($menuIndex > 0) {
+            $x += 3; // " | "
+        }
+        
+        // Add prefix width for current item
+        $x += 2; // "  " or "▶ "
+        
+        return $x;
     }
 
     /**

src/Framework/Console/Components/TuiState.php

@@ -44,6 +44,20 @@ final class TuiState
 
     private ?string $activeMenu = null;
 
+    // Dropdown menu state
+    private ?string $activeDropdownMenu = null;
+
+    private int $selectedDropdownItem = 0;
+
+    // Hover state (for mouse-over effects)
+    private ?string $hoveredMenuItem = null;
+
+    private ?int $hoveredDropdownItem = null;
+
+    private ?string $hoveredContentItemType = null; // 'category', 'command', 'search', 'history'
+
+    private ?int $hoveredContentItemIndex = null;
+
     public function __construct()
     {
     }
@@ -201,10 +215,10 @@ final class TuiState
     public function navigateUp(): void
     {
         match ($this->currentView) {
-            TuiView::CATEGORIES => $this->setSelectedCategory($this->selectedCategory - 1),
+            TuiView::CATEGORIES => $this->navigateCategoryUp(),
-            TuiView::COMMANDS => $this->setSelectedCommand($this->selectedCommand - 1),
+            TuiView::COMMANDS => $this->navigateCommandUp(),
-            TuiView::SEARCH => $this->setSelectedSearchResult($this->selectedSearchResult - 1),
+            TuiView::SEARCH => $this->navigateSearchResultUp(),
-            TuiView::HISTORY => $this->setSelectedHistoryItem($this->selectedHistoryItem - 1),
+            TuiView::HISTORY => $this->navigateHistoryItemUp(),
             default => null
         };
     }
@@ -212,14 +226,196 @@ final class TuiState
     public function navigateDown(): void
     {
         match ($this->currentView) {
-            TuiView::CATEGORIES => $this->setSelectedCategory($this->selectedCategory + 1),
+            TuiView::CATEGORIES => $this->navigateCategoryDown(),
-            TuiView::COMMANDS => $this->setSelectedCommand($this->selectedCommand + 1),
+            TuiView::COMMANDS => $this->navigateCommandDown(),
-            TuiView::SEARCH => $this->setSelectedSearchResult($this->selectedSearchResult + 1),
+            TuiView::SEARCH => $this->navigateSearchResultDown(),
-            TuiView::HISTORY => $this->setSelectedHistoryItem($this->selectedHistoryItem + 1),
+            TuiView::HISTORY => $this->navigateHistoryItemDown(),
             default => null
         };
     }
 
+    /**
+     * Navigate category up with wrap-around
+     */
+    private function navigateCategoryUp(): void
+    {
+        $count = count($this->categories);
+        if ($count === 0) {
+            return;
+        }
+        
+        $newIndex = $this->selectedCategory - 1;
+        if ($newIndex < 0) {
+            $newIndex = $count - 1; // Wrap to last item
+        }
+        
+        $this->selectedCategory = $newIndex;
+    }
+
+    /**
+     * Navigate category down with wrap-around
+     */
+    private function navigateCategoryDown(): void
+    {
+        $count = count($this->categories);
+        if ($count === 0) {
+            return;
+        }
+        
+        $newIndex = $this->selectedCategory + 1;
+        if ($newIndex >= $count) {
+            $newIndex = 0; // Wrap to first item
+        }
+        
+        $this->selectedCategory = $newIndex;
+    }
+
+    /**
+     * Navigate command up with wrap-around
+     */
+    private function navigateCommandUp(): void
+    {
+        $category = $this->getCurrentCategory();
+        if (! $category) {
+            return;
+        }
+        
+        $count = count($category['commands'] ?? []);
+        if ($count === 0) {
+            return;
+        }
+        
+        $newIndex = $this->selectedCommand - 1;
+        if ($newIndex < 0) {
+            $newIndex = $count - 1; // Wrap to last item
+        }
+        
+        $this->selectedCommand = $newIndex;
+    }
+
+    /**
+     * Navigate command down with wrap-around
+     */
+    private function navigateCommandDown(): void
+    {
+        $category = $this->getCurrentCategory();
+        if (! $category) {
+            return;
+        }
+        
+        $count = count($category['commands'] ?? []);
+        if ($count === 0) {
+            return;
+        }
+        
+        $newIndex = $this->selectedCommand + 1;
+        if ($newIndex >= $count) {
+            $newIndex = 0; // Wrap to first item
+        }
+        
+        $this->selectedCommand = $newIndex;
+    }
+
+    /**
+     * Navigate search result up with wrap-around
+     */
+    private function navigateSearchResultUp(): void
+    {
+        $count = count($this->searchResults);
+        if ($count === 0) {
+            return;
+        }
+        
+        $newIndex = $this->selectedSearchResult - 1;
+        if ($newIndex < 0) {
+            $newIndex = $count - 1; // Wrap to last item
+        }
+        
+        $this->selectedSearchResult = $newIndex;
+    }
+
+    /**
+     * Navigate search result down with wrap-around
+     */
+    private function navigateSearchResultDown(): void
+    {
+        $count = count($this->searchResults);
+        if ($count === 0) {
+            return;
+        }
+        
+        $newIndex = $this->selectedSearchResult + 1;
+        if ($newIndex >= $count) {
+            $newIndex = 0; // Wrap to first item
+        }
+        
+        $this->selectedSearchResult = $newIndex;
+    }
+
+    /**
+     * Navigate history item up with wrap-around
+     * Note: This needs the actual item count, which is not stored in state.
+     * For now, we wrap at 0 but don't know the max count.
+     * Use navigateHistoryItemUpWithCount() for proper wrap-around.
+     */
+    private function navigateHistoryItemUp(): void
+    {
+        // History item count is not stored in state, so we can only wrap at 0
+        $newIndex = $this->selectedHistoryItem - 1;
+        if ($newIndex < 0) {
+            // Can't wrap without knowing the count, so stay at 0
+            $newIndex = 0;
+        }
+        
+        $this->selectedHistoryItem = $newIndex;
+    }
+
+    /**
+     * Navigate history item down with wrap-around
+     * Note: This needs the actual item count, which is not stored in state.
+     * For now, we don't wrap because we don't know the max count.
+     * Use navigateHistoryItemDownWithCount() for proper wrap-around.
+     */
+    private function navigateHistoryItemDown(): void
+    {
+        // History item count is not stored in state, so we can only increment
+        $this->selectedHistoryItem = $this->selectedHistoryItem + 1;
+    }
+
+    /**
+     * Navigate history item up with wrap-around, using provided item count
+     */
+    public function navigateHistoryItemUpWithCount(int $itemCount): void
+    {
+        if ($itemCount === 0) {
+            return;
+        }
+        
+        $newIndex = $this->selectedHistoryItem - 1;
+        if ($newIndex < 0) {
+            $newIndex = $itemCount - 1; // Wrap to last item
+        }
+        
+        $this->selectedHistoryItem = $newIndex;
+    }
+
+    /**
+     * Navigate history item down with wrap-around, using provided item count
+     */
+    public function navigateHistoryItemDownWithCount(int $itemCount): void
+    {
+        if ($itemCount === 0) {
+            return;
+        }
+        
+        $newIndex = $this->selectedHistoryItem + 1;
+        if ($newIndex >= $itemCount) {
+            $newIndex = 0; // Wrap to first item
+        }
+        
+        $this->selectedHistoryItem = $newIndex;
+    }
+
     public function resetSearchState(): void
     {
         $this->searchQuery = '';
@@ -344,5 +540,123 @@ final class TuiState
     public function setActiveMenu(?string $menu): void
     {
         $this->activeMenu = $menu;
+        // Close dropdown if menu is closed
+        if ($menu === null) {
+            $this->activeDropdownMenu = null;
+            $this->selectedDropdownItem = 0;
+        }
+    }
+
+    /**
+     * Set active dropdown menu
+     */
+    public function setActiveDropdownMenu(?string $menu): void
+    {
+        $this->activeDropdownMenu = $menu;
+        if ($menu === null) {
+            $this->selectedDropdownItem = 0;
+        }
+    }
+
+    /**
+     * Get active dropdown menu
+     */
+    public function getActiveDropdownMenu(): ?string
+    {
+        return $this->activeDropdownMenu;
+    }
+
+    /**
+     * Set selected dropdown item index
+     */
+    public function setSelectedDropdownItem(int $index): void
+    {
+        $this->selectedDropdownItem = max(0, $index);
+    }
+
+    /**
+     * Get selected dropdown item index
+     */
+    public function getSelectedDropdownItem(): int
+    {
+        return $this->selectedDropdownItem;
+    }
+
+    // Hover state management
+
+    /**
+     * Set hovered menu item
+     */
+    public function setHoveredMenuItem(?string $menuItem): void
+    {
+        $this->hoveredMenuItem = $menuItem;
+    }
+
+    /**
+     * Get hovered menu item
+     */
+    public function getHoveredMenuItem(): ?string
+    {
+        return $this->hoveredMenuItem;
+    }
+
+    /**
+     * Set hovered dropdown item index
+     */
+    public function setHoveredDropdownItem(?int $index): void
+    {
+        $this->hoveredDropdownItem = $index;
+    }
+
+    /**
+     * Get hovered dropdown item index
+     */
+    public function getHoveredDropdownItem(): ?int
+    {
+        return $this->hoveredDropdownItem;
+    }
+
+    /**
+     * Set hovered content item
+     */
+    public function setHoveredContentItem(?string $itemType, ?int $index): void
+    {
+        $this->hoveredContentItemType = $itemType;
+        $this->hoveredContentItemIndex = $index;
+    }
+
+    /**
+     * Get hovered content item type
+     */
+    public function getHoveredContentItemType(): ?string
+    {
+        return $this->hoveredContentItemType;
+    }
+
+    /**
+     * Get hovered content item index
+     */
+    public function getHoveredContentItemIndex(): ?int
+    {
+        return $this->hoveredContentItemIndex;
+    }
+
+    /**
+     * Check if a content item is hovered
+     */
+    public function isContentItemHovered(string $itemType, int $index): bool
+    {
+        return $this->hoveredContentItemType === $itemType && $this->hoveredContentItemIndex === $index;
+    }
+
+    /**
+     * Clear all hover states
+     */
+    public function clearHoverStates(): void
+    {
+        $this->hoveredMenuItem = null;
+        $this->hoveredDropdownItem = null;
+        $this->hoveredContentItemType = null;
+        $this->hoveredContentItemIndex = null;
     }
 }

src/Framework/Console/Screen/MouseControlCode.php

@@ -14,6 +14,8 @@ enum MouseControlCode: string
     case DISABLE_ALL = '?1000l';     // Disable mouse tracking
     case ENABLE_SGR = '?1006h';      // Enable SGR (Sixel Graphics Raster) mouse reports
     case DISABLE_SGR = '?1006l';     // Disable SGR mouse reports
+    case ENABLE_MOVE = '?1003h';     // Enable mouse move tracking (for hover effects)
+    case DISABLE_MOVE = '?1003l';    // Disable mouse move tracking
 
     /**
      * Format the mouse control code as ANSI sequence

src/Framework/Http/Url/Subdomain.php

@@ -0,0 +1,82 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Framework\Http\Url;
+
+use Stringable;
+
+final class Subdomain implements Stringable
+{
+    public function __construct(
+        public string $value
+    ){}
+
+    public static function fromHost(string $host, string $base): Subdomain
+    {
+        if(!str_ends_with($host, '.'.$base)) {
+            throw new \InvalidArgumentException('Host does not end with base domain');
+        }
+
+        $subdomain = self::str_trim_end($host, '.'.$base);
+
+        return new Subdomain($subdomain);
+    }
+
+    public static function tryFromHost(string $host, string $base): ?Subdomain
+    {
+        try {
+            return self::fromHost($host, $base);
+        } catch (\InvalidArgumentException $e) {
+            return null;
+        }
+    }
+
+    public function __toString(): string
+    {
+        return $this->value;
+    }
+
+    private function validate(string $subdomain):bool
+    {
+        return is_string($subdomain);
+    }
+
+    private static function str_trim_end(string $string, string $end, bool $utf8 = false): string
+    {
+        if($end === '') {
+            return $string;
+        }
+
+        if ($utf8) {
+            if (!self::mb_str_ends_with($string, $end)) {
+                return $string;
+            }
+            return mb_substr($string, 0, -mb_strlen($end));
+
+        }
+
+        if(!str_ends_with($string, $end)) {
+            return $string;
+        }
+
+        return substr($string, 0, -strlen($end));
+    }
+
+    private static function mb_str_ends_with(string $haystack, string $needle, string $encoding = 'UTF-8'): bool
+    {
+        $len = mb_strlen($needle, $encoding);
+        if ($len === 0) {
+            return true;
+        }
+        return (mb_substr($haystack, -$len, null, $encoding) === $needle);
+    }
+
+    private static function mb_str_starts_with(string $haystack, string $needle, string $encoding = 'UTF-8'): bool
+    {
+        $len = mb_strlen($needle, $encoding);
+        if ($len === 0) {
+            return true;
+        }
+        return (mb_substr($haystack, 0, $len, $encoding) === $needle);
+    }
+}

src/Framework/Logging/ChannelLoggerRegistry.php

@@ -37,7 +37,7 @@ final class ChannelLoggerRegistry
             // Falls nicht möglich (custom channel), verwende den String direkt
             $logChannel = $channel instanceof LogChannel
                 ? $channel
-                : (LogChannel::tryFrom($channelName) ?? LogChannel::APPLICATION);
+                : (LogChannel::tryFrom($channelName) ?? LogChannel::APP);
 
             $this->channelLoggers[$channelName] = new DefaultChannelLogger(
                 $this->logger,

src/Framework/Logging/Handlers/ConsoleHandler.php

@@ -11,6 +11,9 @@ use App\Framework\Logging\LogRecord;
 
 /**
  * Handler für die Ausgabe von Log-Einträgen in der Konsole.
+ * 
+ * Bei CLI: Nutzt stderr für WARNING+ und stdout für niedrigere Levels.
+ * Bei Web-Requests: Alle Logs gehen auf stderr (POSIX-konform, Docker-kompatibel).
  */
 class ConsoleHandler implements LogHandler
 {
@@ -52,18 +55,12 @@ class ConsoleHandler implements LogHandler
      */
     public function isHandling(LogRecord $record): bool
     {
-        // Nur im CLI-Modus aktiv - NIE bei Web-Requests!
+        // Optional: Debug-Modus-Check
-        if (PHP_SAPI !== 'cli') {
-            return false;
-        }
-
-        // Optional: Debug-Modus-Check nur in CLI
         if ($this->debugOnly && ! filter_var(getenv('APP_DEBUG'), FILTER_VALIDATE_BOOLEAN)) {
             return false;
         }
 
-
+        return $record->level->value >= $this->minLevel->value;
-        return $record->getLevel()->value >= $this->minLevel->value;
     }
 
     /**
@@ -84,12 +81,16 @@ class ConsoleHandler implements LogHandler
             $output .= PHP_EOL;
         }
 
-        // Fehler und Warnungen auf stderr, alles andere auf stdout
+        // Bei Web-Requests: Alle Logs auf stderr (kein stdout, da das in HTTP-Response gehen würde)
-        if ($record->getLevel()->value >= $this->stderrLevel->value) {
+        // Bei CLI: stderr für WARNING+, stdout für niedrigere Levels
-            // WARNING, ERROR, CRITICAL, ALERT, EMERGENCY -> stderr
+        if (PHP_SAPI !== 'cli') {
+            // Web-Requests: Immer stderr verwenden
+            file_put_contents('php://stderr', $output);
+        } elseif ($record->level->value >= $this->stderrLevel->value) {
+            // CLI: WARNING, ERROR, CRITICAL, ALERT, EMERGENCY -> stderr
             file_put_contents('php://stderr', $output);
         } else {
-            // DEBUG, INFO, NOTICE -> stdout
+            // CLI: DEBUG, INFO, NOTICE -> stdout
             echo $output;
         }
     }

src/Framework/Logging/LoggerInitializer.php

@@ -19,7 +19,6 @@ use App\Framework\Logging\Handlers\FileHandler;
 use App\Framework\Logging\Handlers\MultiFileHandler;
 use App\Framework\Logging\Handlers\NullHandler;
 use App\Framework\Logging\Handlers\QueuedLogHandler;
-use App\Framework\Logging\Handlers\WebHandler;
 use App\Framework\Logging\LogHandler;
 use App\Framework\Queue\Queue;
 use App\Framework\Queue\RedisQueue;
@@ -152,13 +151,20 @@ final readonly class LoggerInitializer
     ): array {
         $handlers = [];
 
-        // Docker/Console Logging Handler
+        // Console/Docker Logging Handler - für CLI und Web-Requests
         if (PHP_SAPI === 'cli') {
+            // CLI: Docker JSON oder Console Handler
             $handlers[] = $this->createCliHandler($config, $env, $minLevel);
+        } else {
+            // Web-Requests: Console Handler auf stderr
+            $webFormatter = new LineFormatter(
+                format: '[{timestamp}] [{level_name}] {request_id}{channel}{message}',
+                timestampFormat: 'Y-m-d H:i:s'
+            );
+            $handlers[] = new ConsoleHandler($webFormatter, $minLevel, debugOnly: false);
         }
 
         //$handlers[] = new QueuedLogHandler($queue);
-        $handlers[] = new WebHandler();
 
         // MultiFileHandler für automatisches Channel-Routing
         $multiFileFormatter = new LineFormatter();

src/Framework/Logging/PhpErrorLogInterceptor.php

@@ -13,6 +13,7 @@ use App\Framework\Logging\ValueObjects\LogContext;
 #[Singleton]
 final class PhpErrorLogInterceptor
 {
+    /* @var resource|null */
     private $interceptStream = null;
 
     private ?string $originalErrorLog = null;
@@ -20,8 +21,9 @@ final class PhpErrorLogInterceptor
     private bool $isInstalled = false;
 
     public function __construct(
-        private Logger $logger
+        private readonly Logger $logger
     ) {
+        $this->logger->debug('PhpErrorLogInterceptor initialized');
     }
 
     /**

src/Framework/Logging/PhpErrorLogInterceptorInitializer.php

@@ -4,8 +4,8 @@ declare(strict_types=1);
 
 namespace App\Framework\Logging;
 
-use App\Framework\Attributes\Initializer;
 use App\Framework\DI\Container;
+use App\Framework\DI\Initializer;
 
 /**
  * Initializer für PHP Error Log Interceptor

src/Framework/Router/HttpRouter.php

@@ -5,24 +5,39 @@ declare(strict_types=1);
 namespace App\Framework\Router;
 
 use App\Framework\Attributes\Singleton;
+use App\Framework\Config\Environment;
+use App\Framework\Config\EnvKey;
 use App\Framework\Core\DynamicRoute;
 use App\Framework\Http\Method;
 use App\Framework\Http\Request;
+use App\Framework\Http\Url\Subdomain;
 
 #[Singleton]
 final readonly class HttpRouter implements Router
 {
     public function __construct(
         public CompiledRoutes $optimizedRoutes,
-    ) {
+        private Environment $environment,
-    }
+    ) {}
 
     public function match(Request $request): RouteContext
     {
         $method = $request->method;
         $path = $request->path;
         $host = $request->server->getHttpHost();
-        $subdomain = $this->extractSubdomain($host);
+
+        $appUrl = $this->environment->getString(EnvKey::APP_URL);
+
+
+        $pos = stripos($appUrl, '://');
+        if($pos !== false) {
+            $appUrl = substr($appUrl,$pos + 3);
+        }
+
+        $subdomain = Subdomain::tryfromHost($host, $appUrl) ?? '';
+        $subdomain = (string)$subdomain;
+
+        #$subdomain = $this->extractSubdomain($host);
 
         error_log("🔍 ROUTER DEBUG: Host={$host}, Subdomain=" . ($subdomain ?: 'NONE') . ", Path={$path}, Method={$method->value}");
 

src/Framework/Router/RouterSetup.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace App\Framework\Router;
 
 use App\Framework\Attributes\Route;
+use App\Framework\Config\Environment;
 use App\Framework\Context\ContextType;
 use App\Framework\Core\PathProvider;
 use App\Framework\Core\RouteCache;
@@ -77,7 +78,7 @@ final readonly class RouterSetup
             $optimizedRoutes = $this->routeCompiler->compileOptimized();
         }
 
-        $router = new HttpRouter($optimizedRoutes);
+        $router = new HttpRouter($optimizedRoutes, $this->container->get(Environment::class));
 
         $this->container->bind(CompiledRoutes::class, $optimizedRoutes);
         $this->container->bind(HttpRouter::class, $router);

tests/Framework/Core/AppBootstrapperTest.php

@@ -0,0 +1,334 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Framework\Config\Environment;
+use App\Framework\Core\AppBootstrapper;
+use App\Framework\Core\ApplicationInterface;
+use App\Framework\Core\ContainerBootstrapper;
+use App\Framework\DI\Container;
+use App\Framework\Performance\Contracts\PerformanceCollectorInterface;
+use App\Framework\Performance\MemoryMonitor;
+use App\Framework\Performance\EnhancedPerformanceCollector;
+use App\Framework\DateTime\SystemClock;
+use App\Framework\DateTime\HighResolutionClock;
+
+// Simple test double for PerformanceCollectorInterface
+class TestPerformanceCollector implements PerformanceCollectorInterface
+{
+    public function startTiming(string $key, \App\Framework\Performance\PerformanceCategory $category, array $context = []): void
+    {
+        // No-op for testing
+    }
+
+    public function endTiming(string $key): void
+    {
+        // No-op for testing
+    }
+
+    public function measure(string $key, \App\Framework\Performance\PerformanceCategory $category, callable $callback, array $context = []): mixed
+    {
+        return $callback();
+    }
+
+    public function recordMetric(string $key, \App\Framework\Performance\PerformanceCategory $category, float $value, array $context = []): void
+    {
+        // No-op for testing
+    }
+
+    public function increment(string $key, \App\Framework\Performance\PerformanceCategory $category, int $amount = 1, array $context = []): void
+    {
+        // No-op for testing
+    }
+
+    public function getMetrics(?\App\Framework\Performance\PerformanceCategory $category = null): array
+    {
+        return [];
+    }
+
+    public function getMetric(string $key): ?\App\Framework\Performance\PerformanceMetric
+    {
+        return null;
+    }
+
+    public function getTotalRequestTime(): float
+    {
+        return 0.0;
+    }
+
+    public function getTotalRequestMemory(): int
+    {
+        return 0;
+    }
+
+    public function getPeakMemory(): int
+    {
+        return 0;
+    }
+
+    public function reset(): void
+    {
+        // No-op for testing
+    }
+
+    public function isEnabled(): bool
+    {
+        return false;
+    }
+
+    public function setEnabled(bool $enabled): void
+    {
+        // No-op for testing
+    }
+}
+
+beforeEach(function () {
+    // Create a temporary test directory
+    $this->basePath = sys_get_temp_dir() . '/framework-test-' . uniqid();
+    mkdir($this->basePath, 0755, true);
+    
+    // Create minimal .env file for testing
+    file_put_contents(
+        $this->basePath . '/.env',
+        "APP_ENV=dev\n" .
+        "APP_KEY=test-key\n" .
+        "DB_DATABASE=:memory:\n" .
+        "DB_HOST=localhost\n" .
+        "DB_PORT=3306\n" .
+        "DB_USERNAME=test\n" .
+        "DB_PASSWORD=test\n" .
+        "DB_DRIVER=sqlite\n"
+    );
+    
+    // Create performance collector
+    $this->collector = new TestPerformanceCollector();
+    $this->memoryMonitor = new MemoryMonitor();
+    
+    // Create bootstrapper
+    $this->bootstrapper = new AppBootstrapper(
+        $this->basePath,
+        $this->collector,
+        $this->memoryMonitor
+    );
+});
+
+afterEach(function () {
+    // Cleanup test directory
+    if (isset($this->basePath) && is_dir($this->basePath)) {
+        $files = new RecursiveIteratorIterator(
+            new RecursiveDirectoryIterator($this->basePath, RecursiveDirectoryIterator::SKIP_DOTS),
+            RecursiveIteratorIterator::CHILD_FIRST
+        );
+        
+        foreach ($files as $file) {
+            if ($file->isDir()) {
+                rmdir($file->getRealPath());
+            } else {
+                unlink($file->getRealPath());
+            }
+        }
+        
+        rmdir($this->basePath);
+    }
+});
+
+it('creates bootstrapper with base path and collector', function () {
+    expect($this->bootstrapper)->toBeInstanceOf(AppBootstrapper::class);
+});
+
+it('bootstrapWeb returns ApplicationInterface', function () {
+    $application = $this->bootstrapper->bootstrapWeb();
+    
+    expect($application)->toBeInstanceOf(ApplicationInterface::class);
+});
+
+it('bootstrapConsole returns ConsoleApplication', function () {
+    $consoleApp = $this->bootstrapper->bootstrapConsole();
+    
+    expect($consoleApp)->toBeInstanceOf(\App\Framework\Console\ConsoleApplication::class);
+});
+
+it('bootstrapWorker returns Container', function () {
+    $container = $this->bootstrapper->bootstrapWorker();
+    
+    expect($container)->toBeInstanceOf(Container::class);
+});
+
+it('bootstrapWebSocket returns Container', function () {
+    $container = $this->bootstrapper->bootstrapWebSocket();
+    
+    expect($container)->toBeInstanceOf(Container::class);
+});
+
+it('initializes environment from .env file', function () {
+    $container = $this->bootstrapper->bootstrapWorker();
+    
+    expect($container->has(Environment::class))->toBeTrue();
+    
+    $env = $container->get(Environment::class);
+    expect($env)->toBeInstanceOf(Environment::class);
+    expect($env->get('APP_ENV'))->toBe('dev');
+});
+
+it('registers Environment in container', function () {
+    $container = $this->bootstrapper->bootstrapWorker();
+    
+    expect($container->has(Environment::class))->toBeTrue();
+    
+    $env1 = $container->get(Environment::class);
+    $env2 = $container->get(Environment::class);
+    
+    // Should be same instance (registered as instance)
+    expect($env1)->toBe($env2);
+});
+
+it('registers TypedConfiguration in container', function () {
+    $container = $this->bootstrapper->bootstrapWorker();
+    
+    expect($container->has(\App\Framework\Config\TypedConfiguration::class))->toBeTrue();
+    
+    $config = $container->get(\App\Framework\Config\TypedConfiguration::class);
+    expect($config)->toBeInstanceOf(\App\Framework\Config\TypedConfiguration::class);
+});
+
+it('registers ExecutionContext in container', function () {
+    $container = $this->bootstrapper->bootstrapWorker();
+    
+    expect($container->has(\App\Framework\Context\ExecutionContext::class))->toBeTrue();
+    
+    $context = $container->get(\App\Framework\Context\ExecutionContext::class);
+    expect($context)->toBeInstanceOf(\App\Framework\Context\ExecutionContext::class);
+});
+
+it('registers MemoryMonitor as singleton', function () {
+    $container = $this->bootstrapper->bootstrapWorker();
+    
+    expect($container->has(MemoryMonitor::class))->toBeTrue();
+    
+    $monitor1 = $container->get(MemoryMonitor::class);
+    $monitor2 = $container->get(MemoryMonitor::class);
+    
+    // Should be same instance (singleton)
+    expect($monitor1)->toBe($monitor2);
+});
+
+it('registers MiddlewareManager for web bootstrap', function () {
+    // Need to bootstrap web to register MiddlewareManager
+    // We'll use reflection to access the container from AppBootstrapper
+    $application = $this->bootstrapper->bootstrapWeb();
+    
+    // For web bootstrap, MiddlewareManager should be registered
+    // We test this by checking that the application was created successfully
+    expect($application)->toBeInstanceOf(ApplicationInterface::class);
+});
+
+it('registers EventDispatcher for web bootstrap', function () {
+    // Need to bootstrap web to register EventDispatcher
+    $application = $this->bootstrapper->bootstrapWeb();
+    
+    // For web bootstrap, EventDispatcher should be registered
+    // We test this by checking that the application was created successfully
+    expect($application)->toBeInstanceOf(ApplicationInterface::class);
+});
+
+it('registers EventDispatcher for worker bootstrap', function () {
+    $container = $this->bootstrapper->bootstrapWorker();
+    
+    expect($container->has(\App\Framework\Core\Events\EventDispatcherInterface::class))->toBeTrue();
+    
+    $dispatcher = $container->get(\App\Framework\Core\Events\EventDispatcherInterface::class);
+    expect($dispatcher)->toBeInstanceOf(\App\Framework\Core\Events\EventDispatcherInterface::class);
+});
+
+it('registers ConsoleOutput for worker bootstrap', function () {
+    $container = $this->bootstrapper->bootstrapWorker();
+    
+    expect($container->has(\App\Framework\Console\ConsoleOutput::class))->toBeTrue();
+    
+    $output = $container->get(\App\Framework\Console\ConsoleOutput::class);
+    expect($output)->toBeInstanceOf(\App\Framework\Console\ConsoleOutput::class);
+});
+
+it('registers ConsoleOutput for webSocket bootstrap', function () {
+    $container = $this->bootstrapper->bootstrapWebSocket();
+    
+    expect($container->has(\App\Framework\Console\ConsoleOutput::class))->toBeTrue();
+    
+    $output = $container->get(\App\Framework\Console\ConsoleOutput::class);
+    expect($output)->toBeInstanceOf(\App\Framework\Console\ConsoleOutput::class);
+});
+
+it('handles missing .env file gracefully', function () {
+    // Remove .env file
+    if (file_exists($this->basePath . '/.env')) {
+        unlink($this->basePath . '/.env');
+    }
+    
+    // Should not throw exception
+    $application = $this->bootstrapper->bootstrapWeb();
+    
+    expect($application)->toBeInstanceOf(ApplicationInterface::class);
+    
+    // Should still have container accessible via worker bootstrap
+    $container = $this->bootstrapper->bootstrapWorker();
+    expect($container)->toBeInstanceOf(Container::class);
+});
+
+it('handles Docker secrets when REDIS_PASSWORD_FILE exists', function () {
+    // Create mock secret file
+    $secretFile = '/run/secrets/redis_password';
+    $tempSecretDir = sys_get_temp_dir() . '/run-secrets-test-' . uniqid();
+    $tempSecretFile = $tempSecretDir . '/redis_password';
+    
+    // Create directory and file
+    mkdir($tempSecretDir, 0755, true);
+    file_put_contents($tempSecretFile, 'redis-password');
+    
+    // This test verifies the bootstrapper handles Docker secrets
+    // Note: In real Docker environment, /run/secrets/redis_password would exist
+    // For this test, we verify the logic exists (integration test would verify actual behavior)
+    $application = $this->bootstrapper->bootstrapWeb();
+    
+    expect($application)->toBeInstanceOf(ApplicationInterface::class);
+    
+    // Cleanup
+    if (file_exists($tempSecretFile)) {
+        unlink($tempSecretFile);
+    }
+    if (is_dir($tempSecretDir)) {
+        rmdir($tempSecretDir);
+    }
+});
+
+it('initializes SecretManager when ENCRYPTION_KEY is provided', function () {
+    // Add encryption key to .env
+    file_put_contents(
+        $this->basePath . '/.env',
+        "APP_ENV=dev\n" .
+        "APP_KEY=test-key\n" .
+        "DB_DATABASE=:memory:\n" .
+        "DB_HOST=localhost\n" .
+        "DB_PORT=3306\n" .
+        "DB_USERNAME=test\n" .
+        "DB_PASSWORD=test\n" .
+        "DB_DRIVER=sqlite\n" .
+        "ENCRYPTION_KEY=12345678901234567890123456789012\n" // 32 bytes
+    );
+    
+    $container = $this->bootstrapper->bootstrapWorker();
+    
+    // SecretManager should be registered if encryption key exists
+    // Note: May not always be registered if encryption fails, but should handle gracefully
+    $env = $container->get(Environment::class);
+    expect($env->has('ENCRYPTION_KEY'))->toBeTrue();
+});
+
+it('handles missing ENCRYPTION_KEY gracefully', function () {
+    // No ENCRYPTION_KEY in .env
+    $container = $this->bootstrapper->bootstrapWorker();
+    
+    $env = $container->get(Environment::class);
+    
+    // Should work without encryption key
+    expect($env->has('ENCRYPTION_KEY'))->toBeFalse();
+});

tests/Unit/Framework/Logging/Handlers/ConsoleHandlerTest.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Tests\Unit\Framework\Logging\Handlers;
 
 use App\Framework\Logging\Handlers\ConsoleHandler;
+use App\Framework\Logging\Formatter\LineFormatter;
 use App\Framework\Logging\LogLevel;
 use App\Framework\Logging\LogRecord;
 use App\Framework\Logging\ValueObjects\LogContext;
@@ -16,13 +17,10 @@ beforeEach(function () {
     $this->context = LogContext::withData(['test' => 'data']);
 });
 
-it('only handles records in CLI mode', function () {
+it('handles records in both CLI and web mode', function () {
-    // ConsoleHandler should only work in CLI mode
+    // ConsoleHandler now works in both CLI and web mode
-    $cliCheck = PHP_SAPI === 'cli';
+    $formatter = new LineFormatter();
-    expect($cliCheck)->toBe(true);
+    $handler = new ConsoleHandler($formatter, debugOnly: false);
-
-    // Create handler with debugOnly = false to avoid APP_DEBUG dependency
-    $handler = new ConsoleHandler(debugOnly: false);
 
     $record = new LogRecord(
         message: 'Test message',
@@ -31,13 +29,14 @@ it('only handles records in CLI mode', function () {
         timestamp: $this->timestamp
     );
 
-    // In CLI mode, should handle the record
+    // Should handle the record regardless of SAPI mode
     $result = $handler->isHandling($record);
     expect($result)->toBe(true);
 });
 
 it('respects minimum level configuration', function () {
-    $handler = new ConsoleHandler(minLevel: LogLevel::WARNING, debugOnly: false);
+    $formatter = new LineFormatter();
+    $handler = new ConsoleHandler($formatter, minLevel: LogLevel::WARNING, debugOnly: false);
 
     $debugRecord = new LogRecord(
         message: 'Debug',
@@ -86,7 +85,8 @@ it('respects debug only mode when APP_DEBUG is not set', function () {
 
     // Test with APP_DEBUG = false
     putenv('APP_DEBUG=false');
-    $handler = new ConsoleHandler(debugOnly: true);
+    $formatter = new LineFormatter();
+    $handler = new ConsoleHandler($formatter, debugOnly: true);
 
     $record = new LogRecord(
         message: 'Test',
@@ -105,7 +105,7 @@ it('respects debug only mode when APP_DEBUG is not set', function () {
 
     // Test with debugOnly = false (should always handle)
     putenv('APP_DEBUG=false');
-    $handler = new ConsoleHandler(debugOnly: false);
+    $handler = new ConsoleHandler($formatter, debugOnly: false);
     $result3 = $handler->isHandling($record);
     expect($result3)->toBe(true);
 
@@ -118,7 +118,8 @@ it('respects debug only mode when APP_DEBUG is not set', function () {
 });
 
 it('can change minimum level after creation', function () {
-    $handler = new ConsoleHandler(minLevel: LogLevel::DEBUG, debugOnly: false);
+    $formatter = new LineFormatter();
+    $handler = new ConsoleHandler($formatter, minLevel: LogLevel::DEBUG, debugOnly: false);
 
     $infoRecord = new LogRecord(
         message: 'Info',
@@ -136,22 +137,24 @@ it('can change minimum level after creation', function () {
     expect($result2)->toBe(false);
 });
 
-it('can change output format', function () {
+it('uses formatter for output', function () {
-    $handler = new ConsoleHandler(debugOnly: false);
+    $formatter = new LineFormatter();
+    $handler = new ConsoleHandler($formatter, debugOnly: false);
 
-    $originalFormat = '{color}[{level_name}]{reset} {timestamp} {request_id}{message}{structured}';
+    $record = new LogRecord(
-    $newFormat = '{level_name}: {message}';
+        message: 'Test message',
+        context: $this->context,
+        level: LogLevel::INFO,
+        timestamp: $this->timestamp
+    );
 
-    $handler->setOutputFormat($newFormat);
+    // Verify handler processes records
-
+    expect($handler->isHandling($record))->toBe(true);
-    // Note: We can't easily test the actual output without mocking file_put_contents or echo,
-    // but we can verify the method returns the handler for fluent interface
-    $result = $handler->setOutputFormat($newFormat);
-    expect($result)->toBe($handler);
 });
 
-it('handles output correctly using stdout and stderr', function () {
+it('handles output correctly using stdout and stderr in CLI mode', function () {
-    $handler = new ConsoleHandler(stderrLevel: LogLevel::WARNING, debugOnly: false);
+    $formatter = new LineFormatter();
+    $handler = new ConsoleHandler($formatter, stderrLevel: LogLevel::WARNING, debugOnly: false);
 
     // Test that lower levels would go to stdout (DEBUG, INFO, NOTICE)
     $infoRecord = new LogRecord(
@@ -196,7 +199,8 @@ it('handles output correctly using stdout and stderr', function () {
 });
 
 it('formats records with extra data correctly', function () {
-    $handler = new ConsoleHandler(debugOnly: false);
+    $formatter = new LineFormatter();
+    $handler = new ConsoleHandler($formatter, debugOnly: false);
 
     $record = new LogRecord(
         message: 'Test with extras',
@@ -237,10 +241,8 @@ it('formats records with extra data correctly', function () {
 });
 
 it('handles records with channel information', function () {
-    $handler = new ConsoleHandler(
+    $formatter = new LineFormatter(format: '{channel}{level_name}: {message}');
-        outputFormat: '{channel}{level_name}: {message}',
+    $handler = new ConsoleHandler($formatter, debugOnly: false);
-        debugOnly: false
-    );
 
     $record = new LogRecord(
         message: 'Database connection established',
@@ -263,8 +265,9 @@ it('handles records with channel information', function () {
     expect($output)->toContain('Database connection established');
 });
 
-it('applies correct colors for stdout log levels', function () {
+it('applies correct colors for stdout log levels in CLI mode', function () {
-    $handler = new ConsoleHandler(debugOnly: false);
+    $formatter = new LineFormatter();
+    $handler = new ConsoleHandler($formatter, debugOnly: false);
 
     // Only test stdout levels (DEBUG, INFO, NOTICE)
     // WARNING and above go to stderr and cannot be captured with ob_start()
@@ -292,3 +295,23 @@ it('applies correct colors for stdout log levels', function () {
         expect($output)->toContain("{$level->getName()} message");
     }
 });
+
+it('uses stderr for all logs in web mode', function () {
+    // This test verifies that in web mode, all logs go to stderr
+    // We can't easily mock PHP_SAPI, but we can verify the logic exists
+    $formatter = new LineFormatter();
+    $handler = new ConsoleHandler($formatter, debugOnly: false);
+
+    $record = new LogRecord(
+        message: 'Web request log',
+        context: $this->context,
+        level: LogLevel::INFO,
+        timestamp: $this->timestamp
+    );
+
+    // Handler should process records
+    expect($handler->isHandling($record))->toBe(true);
+    
+    // Note: Actual stderr/stdout routing based on PHP_SAPI is tested at runtime
+    // This test ensures the handler works in both modes
+});