diff --git a/src/Framework/Console/Components/InteractiveMenu.php b/src/Framework/Console/Components/InteractiveMenu.php
index 77fb2d10..b545765d 100644
--- a/src/Framework/Console/Components/InteractiveMenu.php
+++ b/src/Framework/Console/Components/InteractiveMenu.php
@@ -7,6 +7,8 @@ namespace App\Framework\Console\Components;
 use App\Framework\Console\ConsoleColor;
 use App\Framework\Console\ConsoleOutput;
 use App\Framework\Console\ConsoleOutputInterface;
+use App\Framework\Console\Screen\CursorControlCode;
+use App\Framework\Console\Screen\LayoutAreas;
 
 /**
  * Klasse für interaktive Menüs in der Konsole.
@@ -15,7 +17,7 @@ use App\Framework\Console\ConsoleOutputInterface;
  */
 final class InteractiveMenu
 {
-    private ConsoleOutput $output;
+    private ConsoleOutputInterface $output;
 
     private array $menuItems = [];
 
@@ -25,11 +27,23 @@ final class InteractiveMenu
 
     private bool $showNumbers = true;
 
+    private ?LayoutAreas $layoutAreas = null;
+
     public function __construct(ConsoleOutputInterface $output)
     {
         $this->output = $output;
     }
 
+    /**
+     * Set layout areas for coordinated rendering (e.g., within TUI with menu bar).
+     * If null, menu operates in standalone mode (clears entire screen).
+     */
+    public function setLayoutAreas(?LayoutAreas $layoutAreas): self
+    {
+        $this->layoutAreas = $layoutAreas;
+        return $this;
+    }
+
     /**
      * Setzt den Titel des Menüs.
      */
@@ -88,8 +102,7 @@ final class InteractiveMenu
      */
     public function showSimple(): mixed
     {
-        // Verwende den ScreenManager anstelle des direkten clearScreen()
-        $this->output->screen->newMenu();
+        $this->prepareScreen();
 
         if ($this->title) {
             $this->output->writeLine($this->title, ConsoleColor::BRIGHT_CYAN);
@@ -175,8 +188,7 @@ final class InteractiveMenu
      */
     private function renderMenu(): void
     {
-        // Verwende den ScreenManager anstelle des direkten clearScreen()
-        $this->output->screen->newMenu();
+        $this->prepareScreen();
 
         if ($this->title) {
             $this->output->writeLine($this->title, ConsoleColor::BRIGHT_CYAN);
@@ -272,6 +284,23 @@ final class InteractiveMenu
         }
     }
 
-    // Die clearScreen-Methode wurde entfernt, da sie durch den ScreenManager ersetzt wurde.
-    // Verwende stattdessen $this->output->screen()->newScreen() oder $this->output->display()->clear().
+    /**
+     * Prepares the screen for rendering based on layout context.
+     * If layoutAreas is set, only clears content area and positions cursor correctly.
+     * Otherwise, clears entire screen (standalone mode).
+     */
+    private function prepareScreen(): void
+    {
+        if ($this->layoutAreas === null) {
+            // Standalone mode: clear entire screen
+            $this->output->screen->newMenu();
+        } else {
+            // Layout-aware mode: only clear content area
+            $contentArea = $this->layoutAreas->contentArea();
+            $this->output->screen->clearContentArea($contentArea->startLine);
+            
+            // Position cursor at content area start
+            $this->output->writeRaw(CursorControlCode::POSITION->format($contentArea->startLine, 1));
+        }
+    }
 }
diff --git a/src/Framework/Console/Screen/LayoutArea.php b/src/Framework/Console/Screen/LayoutArea.php
new file mode 100644
index 00000000..0a759ce1
--- /dev/null
+++ b/src/Framework/Console/Screen/LayoutArea.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Console\Screen;
+
+/**
+ * Represents a single layout area with its boundaries.
+ */
+final readonly class LayoutArea
+{
+    public function __construct(
+        public int $startLine,
+        public int $endLine,
+        public int $height
+    ) {
+        if ($startLine < 1 || $endLine < 1) {
+            throw new \InvalidArgumentException('Line numbers must be >= 1');
+        }
+        if ($startLine > $endLine) {
+            throw new \InvalidArgumentException('Start line must be <= end line');
+        }
+        if ($height < 1) {
+            throw new \InvalidArgumentException('Height must be >= 1');
+        }
+    }
+
+    /**
+     * Check if a line number is within this area
+     */
+    public function containsLine(int $line): bool
+    {
+        return $line >= $this->startLine && $line <= $this->endLine;
+    }
+}
+
diff --git a/src/Framework/Console/Screen/LayoutAreas.php b/src/Framework/Console/Screen/LayoutAreas.php
new file mode 100644
index 00000000..a4b4d023
--- /dev/null
+++ b/src/Framework/Console/Screen/LayoutAreas.php
@@ -0,0 +1,145 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Console\Screen;
+
+use App\Framework\Console\Layout\TerminalSize;
+
+/**
+ * Defines layout areas with their start lines for coordinated screen rendering.
+ * Used to prevent components from overwriting each other (e.g., menu bar vs content).
+ */
+final readonly class LayoutAreas
+{
+    /**
+     * @param int $menuBarStartLine Start line for menu bar (1-based)
+     * @param int $menuBarEndLine End line for menu bar (1-based, inclusive)
+     * @param int $contentStartLine Start line for content area (1-based)
+     * @param int $statusStartLine Start line for status area (1-based, 0 = no status area)
+     * @param TerminalSize $terminalSize Terminal size for calculations
+     */
+    public function __construct(
+        public int $menuBarStartLine,
+        public int $menuBarEndLine,
+        public int $contentStartLine,
+        public int $statusStartLine,
+        public TerminalSize $terminalSize
+    ) {
+        if ($menuBarStartLine < 1 || $contentStartLine < 1) {
+            throw new \InvalidArgumentException('Line numbers must be >= 1');
+        }
+        // If menu bar exists (endLine > 0), validate it
+        if ($menuBarEndLine > 0) {
+            if ($menuBarStartLine > $menuBarEndLine) {
+                throw new \InvalidArgumentException('Menu bar start line must be <= end line');
+            }
+            if ($contentStartLine <= $menuBarEndLine) {
+                throw new \InvalidArgumentException('Content area must start after menu bar');
+            }
+        }
+        if ($statusStartLine > 0 && $statusStartLine <= $contentStartLine) {
+            throw new \InvalidArgumentException('Status area must start after content area');
+        }
+    }
+
+    /**
+     * Get menu bar area definition (null if no menu bar)
+     */
+    public function menuBarArea(): ?LayoutArea
+    {
+        if ($this->menuBarEndLine === 0) {
+            return null;
+        }
+
+        return new LayoutArea(
+            startLine: $this->menuBarStartLine,
+            endLine: $this->menuBarEndLine,
+            height: $this->menuBarEndLine - $this->menuBarStartLine + 1
+        );
+    }
+
+    /**
+     * Get content area definition
+     */
+    public function contentArea(): LayoutArea
+    {
+        $endLine = $this->statusStartLine > 0
+            ? $this->statusStartLine - 1
+            : $this->terminalSize->height;
+
+        return new LayoutArea(
+            startLine: $this->contentStartLine,
+            endLine: $endLine,
+            height: $endLine - $this->contentStartLine + 1
+        );
+    }
+
+    /**
+     * Get status area definition (if available)
+     */
+    public function statusArea(): ?LayoutArea
+    {
+        if ($this->statusStartLine === 0) {
+            return null;
+        }
+
+        return new LayoutArea(
+            startLine: $this->statusStartLine,
+            endLine: $this->terminalSize->height,
+            height: $this->terminalSize->height - $this->statusStartLine + 1
+        );
+    }
+
+    /**
+     * Create layout areas for TUI mode (MenuBar: lines 1-3, Content: from line 4)
+     */
+    public static function forTui(?TerminalSize $terminalSize = null): self
+    {
+        $terminalSize = $terminalSize ?? TerminalSize::detect();
+        
+        return new self(
+            menuBarStartLine: 1,
+            menuBarEndLine: 3,
+            contentStartLine: 4,
+            statusStartLine: 0, // No status area by default
+            terminalSize: $terminalSize
+        );
+    }
+
+    /**
+     * Create layout areas for standalone mode (no menu bar, content from line 1)
+     */
+    public static function standalone(?TerminalSize $terminalSize = null): self
+    {
+        $terminalSize = $terminalSize ?? TerminalSize::detect();
+        
+        return new self(
+            menuBarStartLine: 1,
+            menuBarEndLine: 0, // No menu bar
+            contentStartLine: 1,
+            statusStartLine: 0,
+            terminalSize: $terminalSize
+        );
+    }
+
+    /**
+     * Create custom layout areas
+     */
+    public static function create(
+        int $menuBarStartLine,
+        int $menuBarEndLine,
+        int $contentStartLine,
+        int $statusStartLine = 0,
+        ?TerminalSize $terminalSize = null
+    ): self {
+        return new self(
+            menuBarStartLine: $menuBarStartLine,
+            menuBarEndLine: $menuBarEndLine,
+            contentStartLine: $contentStartLine,
+            statusStartLine: $statusStartLine,
+            terminalSize: $terminalSize ?? TerminalSize::detect()
+        );
+    }
+}
+
diff --git a/src/Framework/Console/Screen/ScreenManager.php b/src/Framework/Console/Screen/ScreenManager.php
index 649989b2..e64c57c6 100644
--- a/src/Framework/Console/Screen/ScreenManager.php
+++ b/src/Framework/Console/Screen/ScreenManager.php
@@ -114,6 +114,28 @@ final class ScreenManager
         return $this;
     }
 
+    /**
+     * Clear only the content area starting from a specific line, preserving content above.
+     * Useful when rendering within a layout (e.g., preserving menu bar).
+     */
+    public function clearContentArea(int $startLine): self
+    {
+        if (!$this->output->isTerminal()) {
+            return $this;
+        }
+
+        // Position cursor at the start line
+        $this->output->writeRaw(CursorControlCode::POSITION->format($startLine, 1));
+        
+        // Clear everything from cursor downwards
+        $this->output->writeRaw(ScreenControlCode::CLEAR_BELOW->format());
+        
+        // Position cursor back at start line for content rendering
+        $this->output->writeRaw(CursorControlCode::POSITION->format($startLine, 1));
+
+        return $this;
+    }
+
     /**
      * Entscheidet, ob der Bildschirm gelöscht werden soll.
      */
diff --git a/src/Framework/Console/Screen/ScreenRendererInterface.php b/src/Framework/Console/Screen/ScreenRendererInterface.php
new file mode 100644
index 00000000..af420d18
--- /dev/null
+++ b/src/Framework/Console/Screen/ScreenRendererInterface.php
@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Console\Screen;
+
+/**
+ * Interface for screen rendering operations.
+ * Allows mocking in tests for verification of screen operations.
+ */
+interface ScreenRendererInterface
+{
+    /**
+     * Clear the entire screen
+     */
+    public function clear(): void;
+
+    /**
+     * Clear content area starting from a specific line
+     */
+    public function clearContentArea(int $startLine): void;
+
+    /**
+     * Position cursor at specific line and column (1-based)
+     */
+    public function position(int $line, int $column = 1): void;
+
+    /**
+     * Write raw output (ANSI codes, etc.)
+     */
+    public function writeRaw(string $data): void;
+}
+
diff --git a/tests/Framework/Console/Components/InteractiveMenuRenderingTest.php b/tests/Framework/Console/Components/InteractiveMenuRenderingTest.php
new file mode 100644
index 00000000..ca64487d
--- /dev/null
+++ b/tests/Framework/Console/Components/InteractiveMenuRenderingTest.php
@@ -0,0 +1,138 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Framework\Console\Components;
+
+use App\Framework\Console\Components\InteractiveMenu;
+use App\Framework\Console\Layout\TerminalSize;
+use App\Framework\Console\Screen\LayoutAreas;
+use Tests\Framework\Console\Helpers\TestConsoleOutput;
+
+describe('InteractiveMenu Rendering', function () {
+    beforeEach(function () {
+        $this->output = new TestConsoleOutput();
+        $this->menu = new InteractiveMenu($this->output);
+    });
+
+    it('renders menu in standalone mode (clears entire screen)', function () {
+        $this->menu
+            ->setTitle('Test Menu')
+            ->addItem('Option 1')
+            ->addItem('Option 2');
+
+        // Note: showSimple() reads from STDIN, so we can't fully test it
+        // But we can verify the menu structure is correct
+        expect($this->menu)->toBeInstanceOf(InteractiveMenu::class);
+        
+        // When layoutAreas is null, menu operates in standalone mode
+        // This is the default behavior
+        expect(true)->toBeTrue(); // Placeholder assertion
+    });
+
+    it('uses layout areas to position content correctly', function () {
+        $terminalSize = new TerminalSize(80, 24);
+        $layoutAreas = LayoutAreas::forTui($terminalSize);
+        
+        $this->menu
+            ->setLayoutAreas($layoutAreas)
+            ->setTitle('Test Menu')
+            ->addItem('Option 1')
+            ->addItem('Option 2');
+
+        // The menu should use content area start line (4) for positioning
+        $contentArea = $layoutAreas->contentArea();
+        expect($contentArea->startLine)->toBe(4);
+    });
+
+    it('preserves menu bar when using layout areas', function () {
+        $terminalSize = new TerminalSize(80, 24);
+        $layoutAreas = LayoutAreas::forTui($terminalSize);
+        
+        $this->menu->setLayoutAreas($layoutAreas);
+        
+        // Menu bar should be lines 1-3
+        $menuBarArea = $layoutAreas->menuBarArea();
+        expect($menuBarArea)->not->toBeNull();
+        expect($menuBarArea->startLine)->toBe(1);
+        expect($menuBarArea->endLine)->toBe(3);
+        
+        // Content should start at line 4
+        $contentArea = $layoutAreas->contentArea();
+        expect($contentArea->startLine)->toBe(4);
+    });
+
+    it('correctly calculates content area when menu bar exists', function () {
+        $terminalSize = new TerminalSize(80, 24);
+        $layoutAreas = LayoutAreas::forTui($terminalSize);
+        
+        $contentArea = $layoutAreas->contentArea();
+        
+        // Content should start after menu bar (line 4)
+        expect($contentArea->startLine)->toBe(4);
+        // Content should end at terminal height (no status area)
+        expect($contentArea->endLine)->toBe(24);
+        expect($contentArea->height)->toBe(21); // 24 - 4 + 1
+    });
+
+    it('handles standalone layout (no menu bar)', function () {
+        $terminalSize = new TerminalSize(80, 24);
+        $layoutAreas = LayoutAreas::standalone($terminalSize);
+        
+        $menuBarArea = $layoutAreas->menuBarArea();
+        expect($menuBarArea)->toBeNull();
+        
+        $contentArea = $layoutAreas->contentArea();
+        expect($contentArea->startLine)->toBe(1);
+        expect($contentArea->endLine)->toBe(24);
+    });
+
+    it('validates layout areas constraints', function () {
+        $terminalSize = new TerminalSize(80, 24);
+        
+        // Content must start after menu bar
+        expect(fn() => LayoutAreas::create(
+            menuBarStartLine: 1,
+            menuBarEndLine: 3,
+            contentStartLine: 2, // Too early!
+            statusStartLine: 0,
+            terminalSize: $terminalSize
+        ))->toThrow(\InvalidArgumentException::class);
+    });
+
+    it('allows custom layout areas', function () {
+        $terminalSize = new TerminalSize(80, 24);
+        $layoutAreas = LayoutAreas::create(
+            menuBarStartLine: 1,
+            menuBarEndLine: 2,
+            contentStartLine: 3,
+            statusStartLine: 22,
+            terminalSize: $terminalSize
+        );
+        
+        $menuBarArea = $layoutAreas->menuBarArea();
+        expect($menuBarArea->startLine)->toBe(1);
+        expect($menuBarArea->endLine)->toBe(2);
+        
+        $contentArea = $layoutAreas->contentArea();
+        expect($contentArea->startLine)->toBe(3);
+        expect($contentArea->endLine)->toBe(21); // Before status area
+        
+        $statusArea = $layoutAreas->statusArea();
+        expect($statusArea)->not->toBeNull();
+        expect($statusArea->startLine)->toBe(22);
+        expect($statusArea->endLine)->toBe(24);
+    });
+
+    it('sets and retrieves layout areas correctly', function () {
+        $terminalSize = new TerminalSize(80, 24);
+        $layoutAreas = LayoutAreas::forTui($terminalSize);
+        
+        $this->menu->setLayoutAreas($layoutAreas);
+        
+        // We can't directly access private property, but we can verify
+        // the menu works correctly with layout areas by checking behavior
+        expect($layoutAreas->contentArea()->startLine)->toBe(4);
+    });
+});
+
diff --git a/tests/Framework/Console/Helpers/TestScreenRenderer.php b/tests/Framework/Console/Helpers/TestScreenRenderer.php
new file mode 100644
index 00000000..d2588846
--- /dev/null
+++ b/tests/Framework/Console/Helpers/TestScreenRenderer.php
@@ -0,0 +1,142 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Framework\Console\Helpers;
+
+use App\Framework\Console\Screen\ScreenRendererInterface;
+
+/**
+ * Test implementation of ScreenRendererInterface that captures all operations
+ * for assertions in tests.
+ */
+final class TestScreenRenderer implements ScreenRendererInterface
+{
+    /** @var array<int, array{operation: string, line?: int, column?: int, data?: string}> */
+    public array $operations = [];
+
+    /** @var array<int, string> Line-based buffer for assertions */
+    public array $buffer = [];
+
+    private int $currentLine = 1;
+    private int $currentColumn = 1;
+
+    public function clear(): void
+    {
+        $this->operations[] = ['operation' => 'clear'];
+        $this->buffer = [];
+        $this->currentLine = 1;
+        $this->currentColumn = 1;
+    }
+
+    public function clearContentArea(int $startLine): void
+    {
+        $this->operations[] = ['operation' => 'clearContentArea', 'line' => $startLine];
+        
+        // Clear buffer from startLine onwards
+        $this->buffer = array_slice($this->buffer, 0, $startLine - 1);
+        $this->currentLine = $startLine;
+        $this->currentColumn = 1;
+    }
+
+    public function position(int $line, int $column = 1): void
+    {
+        $this->operations[] = ['operation' => 'position', 'line' => $line, 'column' => $column];
+        $this->currentLine = $line;
+        $this->currentColumn = $column;
+    }
+
+    public function writeRaw(string $data): void
+    {
+        $this->operations[] = ['operation' => 'writeRaw', 'data' => $data];
+        
+        // Handle ANSI escape sequences
+        if (str_starts_with($data, "\033[")) {
+            // This is an ANSI code, we might want to parse it
+            // For now, just record it
+            return;
+        }
+        
+        // Handle regular text - append to current line in buffer
+        $lines = explode("\n", $data);
+        foreach ($lines as $index => $line) {
+            if ($index === 0) {
+                // First line: append to current line
+                if (!isset($this->buffer[$this->currentLine - 1])) {
+                    $this->buffer[$this->currentLine - 1] = '';
+                }
+                $this->buffer[$this->currentLine - 1] .= $line;
+                $this->currentColumn += mb_strlen($line);
+            } else {
+                // Subsequent lines: new line
+                $this->currentLine++;
+                $this->currentColumn = 1;
+                $this->buffer[$this->currentLine - 1] = $line;
+            }
+        }
+    }
+
+    /**
+     * Get the content of a specific line (1-based)
+     */
+    public function getLine(int $line): ?string
+    {
+        return $this->buffer[$line - 1] ?? null;
+    }
+
+    /**
+     * Get all lines as array
+     */
+    public function getLines(): array
+    {
+        return $this->buffer;
+    }
+
+    /**
+     * Get all operations
+     */
+    public function getOperations(): array
+    {
+        return $this->operations;
+    }
+
+    /**
+     * Clear all recorded operations and buffer
+     */
+    public function reset(): void
+    {
+        $this->operations = [];
+        $this->buffer = [];
+        $this->currentLine = 1;
+        $this->currentColumn = 1;
+    }
+
+    /**
+     * Check if a clearContentArea operation was called with specific start line
+     */
+    public function wasContentAreaCleared(int $startLine): bool
+    {
+        foreach ($this->operations as $op) {
+            if ($op['operation'] === 'clearContentArea' && ($op['line'] ?? 0) === $startLine) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Check if position was set to specific line/column
+     */
+    public function wasPositioned(int $line, int $column = 1): bool
+    {
+        foreach ($this->operations as $op) {
+            if ($op['operation'] === 'position' 
+                && ($op['line'] ?? 0) === $line 
+                && ($op['column'] ?? 1) === $column) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+