docs: use david's most recent README from feature/vector_display branch

Reviewed-on: genewildish/Mainline#32

.gitignore

@@ -9,4 +9,3 @@ htmlcov/
 .coverage
 .pytest_cache/
 *.egg-info/
-coverage.xml

AGENTS.md

@@ -16,33 +16,19 @@ This project uses:
 mise run install
 
 # Or equivalently:
-uv sync --all-extras   # includes mic, websocket, sixel support
+uv sync
 ```
 
 ### Available Commands
 
 ```bash
-mise run test           # Run tests
-mise run test-v         # Run tests verbose
-mise run test-cov       # Run tests with coverage report
-mise run test-browser   # Run e2e browser tests (requires playwright)
-mise run lint           # Run ruff linter
-mise run lint-fix       # Run ruff with auto-fix
-mise run format         # Run ruff formatter
-mise run ci             # Full CI pipeline (topics-init + lint + test-cov)
-```
-
-### Runtime Commands
-
-```bash
-mise run run            # Run mainline (terminal)
-mise run run-poetry    # Run with poetry feed
-mise run run-firehose  # Run in firehose mode
-mise run run-websocket # Run with WebSocket display only
-mise run run-sixel     # Run with Sixel graphics display
-mise run run-both      # Run with both terminal and WebSocket
-mise run run-client    # Run both + open browser
-mise run cmd           # Run C&C command interface
+mise run test       # Run tests
+mise run test-v     # Run tests verbose
+mise run test-cov   # Run tests with coverage report
+mise run lint       # Run ruff linter
+mise run lint-fix   # Run ruff with auto-fix
+mise run format     # Run ruff formatter
+mise run ci         # Full CI pipeline (sync + test + coverage)
 ```
 
 ## Git Hooks
@@ -60,52 +46,9 @@ hk init --mise
 mise run pre-commit
 ```
 
-**IMPORTANT**: Always review the hk documentation before modifying `hk.pkl`:
-- [hk Configuration Guide](https://hk.jdx.dev/configuration.html)
-- [hk Hooks Reference](https://hk.jdx.dev/hooks.html)
-- [hk Builtins](https://hk.jdx.dev/builtins.html)
-
 The project uses hk configured in `hk.pkl`:
 - **pre-commit**: runs ruff-format and ruff (with auto-fix)
-- **pre-push**: runs ruff check + benchmark hook
-
-## Benchmark Runner
-
-Run performance benchmarks:
-
-```bash
-mise run benchmark           # Run all benchmarks (text output)
-mise run benchmark-json     # Run benchmarks (JSON output)
-mise run benchmark-report   # Run benchmarks (Markdown report)
-```
-
-### Benchmark Commands
-
-```bash
-# Run benchmarks
-uv run python -m engine.benchmark
-
-# Run with specific displays/effects
-uv run python -m engine.benchmark --displays null,terminal --effects fade,glitch
-
-# Save baseline for hook comparisons
-uv run python -m engine.benchmark --baseline
-
-# Run in hook mode (compares against baseline)
-uv run python -m engine.benchmark --hook
-
-# Hook mode with custom threshold (default: 20% degradation)
-uv run python -m engine.benchmark --hook --threshold 0.3
-
-# Custom baseline location
-uv run python -m engine.benchmark --hook --cache /path/to/cache.json
-```
-
-### Hook Mode
-
-The `--hook` mode compares current benchmarks against a saved baseline. If performance degrades beyond the threshold (default 20%), it exits with code 1. This is useful for preventing performance regressions in feature branches.
-
-The pre-push hook runs benchmark in hook mode to catch performance regressions before pushing.
+- **pre-push**: runs ruff check
 
 ## Workflow Rules
 
@@ -159,81 +102,9 @@ mise run test-cov
 
 The project uses pytest with strict marker enforcement. Test configuration is in `pyproject.toml` under `[tool.pytest.ini_options]`.
 
-### Test Coverage Strategy
-
-Current coverage: 56% (336 tests)
-
-Key areas with lower coverage (acceptable for now):
-- **app.py** (8%): Main entry point - integration heavy, requires terminal
-- **scroll.py** (10%): Terminal-dependent rendering logic
-- **benchmark.py** (0%): Standalone benchmark tool, runs separately
-
-Key areas with good coverage:
-- **display/backends/null.py** (95%): Easy to test headlessly
-- **display/backends/terminal.py** (96%): Uses mocking
-- **display/backends/multi.py** (100%): Simple forwarding logic
-- **effects/performance.py** (99%): Pure Python logic
-- **eventbus.py** (96%): Simple event system
-- **effects/controller.py** (95%): Effects command handling
-
-Areas needing more tests:
-- **websocket.py** (48%): Network I/O, hard to test in CI
-- **ntfy.py** (50%): Network I/O, hard to test in CI
-- **mic.py** (61%): Audio I/O, hard to test in CI
-
-Note: Terminal-dependent modules (scroll, layers render) are harder to test in CI.
-Performance regression tests are in `tests/test_benchmark.py` with `@pytest.mark.benchmark`.
-
 ## Architecture Notes
 
 - **ntfy.py** and **mic.py** are standalone modules with zero internal dependencies
 - **eventbus.py** provides thread-safe event publishing for decoupled communication
-- **controller.py** coordinates ntfy/mic monitoring and event publishing
-- **effects/** - plugin architecture with performance monitoring
+- **controller.py** coordinates ntfy/mic monitoring
 - The render pipeline: fetch → render → effects → scroll → terminal output
-
-### Display System
-
-- **Display abstraction** (`engine/display/`): swap display backends via the Display protocol
-  - `display/backends/terminal.py` - ANSI terminal output
-  - `display/backends/websocket.py` - broadcasts to web clients via WebSocket
-  - `display/backends/sixel.py` - renders to Sixel graphics (pure Python, no C dependency)
-  - `display/backends/null.py` - headless display for testing
-  - `display/backends/multi.py` - forwards to multiple displays simultaneously
-  - `display/__init__.py` - DisplayRegistry for backend discovery
-
-- **WebSocket display** (`engine/display/backends/websocket.py`): real-time frame broadcasting to web browsers
-  - WebSocket server on port 8765
-  - HTTP server on port 8766 (serves HTML client)
-  - Client at `client/index.html` with ANSI color parsing and fullscreen support
-
-- **Display modes** (`--display` flag):
-  - `terminal` - Default ANSI terminal output
-  - `websocket` - Web browser display (requires websockets package)
-  - `sixel` - Sixel graphics in supported terminals (iTerm2, mintty, etc.)
-  - `both` - Terminal + WebSocket simultaneously
-
-### Effect Plugin System
-
-- **EffectPlugin ABC** (`engine/effects/types.py`): abstract base class for effects
-  - All effects must inherit from EffectPlugin and implement `process()` and `configure()`
-  - Runtime discovery via `effects_plugins/__init__.py` using `issubclass()` checks
-  
-- **EffectRegistry** (`engine/effects/registry.py`): manages registered effects
-- **EffectChain** (`engine/effects/chain.py`): chains effects in pipeline order
-
-### Command & Control
-
-- C&C uses separate ntfy topics for commands and responses
-- `NTFY_CC_CMD_TOPIC` - commands from cmdline.py
-- `NTFY_CC_RESP_TOPIC` - responses back to cmdline.py
-- Effects controller handles `/effects` commands (list, on/off, intensity, reorder, stats)
-
-### Pipeline Documentation
-
-The rendering pipeline is documented in `docs/PIPELINE.md` using Mermaid diagrams.
-
-**IMPORTANT**: When making significant architectural changes to the rendering pipeline (new layers, effects, display backends), update `docs/PIPELINE.md` to reflect the changes:
-1. Edit `docs/PIPELINE.md` with the new architecture
-2. If adding new SVG diagrams, render them manually using an external tool (e.g., Mermaid Live Editor)
-3. Commit both the markdown and any new diagram files

client/index.html

@@ -1,366 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Mainline Terminal</title>
-    <style>
-        * {
-            margin: 0;
-            padding: 0;
-            box-sizing: border-box;
-        }
-        body {
-            background: #0a0a0a;
-            color: #ccc;
-            font-family: 'Fira Code', 'Cascadia Code', 'Consolas', monospace;
-            display: flex;
-            flex-direction: column;
-            align-items: center;
-            justify-content: center;
-            min-height: 100vh;
-            padding: 20px;
-        }
-        body.fullscreen {
-            padding: 0;
-        }
-        body.fullscreen #controls {
-            display: none;
-        }
-        #container {
-            position: relative;
-        }
-        canvas {
-            background: #000;
-            border: 1px solid #333;
-            image-rendering: pixelated;
-            image-rendering: crisp-edges;
-        }
-        body.fullscreen canvas {
-            border: none;
-            width: 100vw;
-            height: 100vh;
-            max-width: 100vw;
-            max-height: 100vh;
-        }
-        #controls {
-            display: flex;
-            gap: 10px;
-            margin-top: 10px;
-            align-items: center;
-        }
-        #controls button {
-            background: #333;
-            color: #ccc;
-            border: 1px solid #555;
-            padding: 5px 12px;
-            cursor: pointer;
-            font-family: inherit;
-            font-size: 12px;
-        }
-        #controls button:hover {
-            background: #444;
-        }
-        #controls input {
-            width: 60px;
-            background: #222;
-            color: #ccc;
-            border: 1px solid #444;
-            padding: 4px 8px;
-            font-family: inherit;
-            text-align: center;
-        }
-        #status {
-            margin-top: 10px;
-            font-size: 12px;
-            color: #666;
-        }
-        #status.connected {
-            color: #4f4;
-        }
-        #status.disconnected {
-            color: #f44;
-        }
-    </style>
-</head>
-<body>
-    <div id="container">
-        <canvas id="terminal"></canvas>
-    </div>
-    <div id="controls">
-        <label>Cols: <input type="number" id="cols" value="80" min="20" max="200"></label>
-        <label>Rows: <input type="number" id="rows" value="24" min="10" max="60"></label>
-        <button id="apply">Apply</button>
-        <button id="fullscreen">Fullscreen</button>
-    </div>
-    <div id="status" class="disconnected">Connecting...</div>
-
-    <script>
-        const canvas = document.getElementById('terminal');
-        const ctx = canvas.getContext('2d');
-        const status = document.getElementById('status');
-        const colsInput = document.getElementById('cols');
-        const rowsInput = document.getElementById('rows');
-        const applyBtn = document.getElementById('apply');
-        const fullscreenBtn = document.getElementById('fullscreen');
-
-        const CHAR_WIDTH = 9;
-        const CHAR_HEIGHT = 16;
-
-        const ANSI_COLORS = {
-            0: '#000000', 1: '#cd3131', 2: '#0dbc79', 3: '#e5e510',
-            4: '#2472c8', 5: '#bc3fbc', 6: '#11a8cd', 7: '#e5e5e5',
-            8: '#666666', 9: '#f14c4c', 10: '#23d18b', 11: '#f5f543',
-            12: '#3b8eea', 13: '#d670d6', 14: '#29b8db', 15: '#ffffff',
-        };
-
-        let cols = 80;
-        let rows = 24;
-        let ws = null;
-
-        function resizeCanvas() {
-            canvas.width = cols * CHAR_WIDTH;
-            canvas.height = rows * CHAR_HEIGHT;
-        }
-
-        function parseAnsi(text) {
-            if (!text) return [];
-            
-            const tokens = [];
-            let currentText = '';
-            let fg = '#cccccc';
-            let bg = '#000000';
-            let bold = false;
-            let i = 0;
-            let inEscape = false;
-            let escapeCode = '';
-
-            while (i < text.length) {
-                const char = text[i];
-                
-                if (inEscape) {
-                    if (char >= '0' && char <= '9' || char === ';' || char === '[') {
-                        escapeCode += char;
-                    }
-                    
-                    if (char === 'm') {
-                        const codes = escapeCode.replace('\x1b[', '').split(';');
-                        
-                        for (const code of codes) {
-                            const num = parseInt(code) || 0;
-                            
-                            if (num === 0) {
-                                fg = '#cccccc';
-                                bg = '#000000';
-                                bold = false;
-                            } else if (num === 1) {
-                                bold = true;
-                            } else if (num === 22) {
-                                bold = false;
-                            } else if (num === 39) {
-                                fg = '#cccccc';
-                            } else if (num === 49) {
-                                bg = '#000000';
-                            } else if (num >= 30 && num <= 37) {
-                                fg = ANSI_COLORS[num - 30 + (bold ? 8 : 0)] || '#cccccc';
-                            } else if (num >= 40 && num <= 47) {
-                                bg = ANSI_COLORS[num - 40] || '#000000';
-                            } else if (num >= 90 && num <= 97) {
-                                fg = ANSI_COLORS[num - 90 + 8] || '#cccccc';
-                            } else if (num >= 100 && num <= 107) {
-                                bg = ANSI_COLORS[num - 100 + 8] || '#000000';
-                            } else if (num >= 1 && num <= 256) {
-                                // 256 colors
-                                if (num < 16) {
-                                    fg = ANSI_COLORS[num] || '#cccccc';
-                                } else if (num < 232) {
-                                    const c = num - 16;
-                                    const r = Math.floor(c / 36) * 51;
-                                    const g = Math.floor((c % 36) / 6) * 51;
-                                    const b = (c % 6) * 51;
-                                    fg = `#${r.toString(16).padStart(2,'0')}${g.toString(16).padStart(2,'0')}${b.toString(16).padStart(2,'0')}`;
-                                } else {
-                                    const gray = (num - 232) * 10 + 8;
-                                    fg = `#${gray.toString(16).repeat(2)}`;
-                                }
-                            }
-                        }
-                        
-                        if (currentText) {
-                            tokens.push({ text: currentText, fg, bg, bold });
-                            currentText = '';
-                        }
-                        inEscape = false;
-                        escapeCode = '';
-                    }
-                } else if (char === '\x1b' && text[i + 1] === '[') {
-                    if (currentText) {
-                        tokens.push({ text: currentText, fg, bg, bold });
-                        currentText = '';
-                    }
-                    inEscape = true;
-                    escapeCode = '';
-                    i++;
-                } else {
-                    currentText += char;
-                }
-                i++;
-            }
-
-            if (currentText) {
-                tokens.push({ text: currentText, fg, bg, bold });
-            }
-
-            return tokens;
-        }
-
-        function renderLine(text, x, y, lineHeight) {
-            const tokens = parseAnsi(text);
-            let xOffset = x;
-
-            for (const token of tokens) {
-                if (token.text) {
-                    if (token.bold) {
-                        ctx.font = 'bold 16px monospace';
-                    } else {
-                        ctx.font = '16px monospace';
-                    }
-
-                    const metrics = ctx.measureText(token.text);
-                    
-                    if (token.bg !== '#000000') {
-                        ctx.fillStyle = token.bg;
-                        ctx.fillRect(xOffset, y - 2, metrics.width + 1, lineHeight);
-                    }
-                    
-                    ctx.fillStyle = token.fg;
-                    ctx.fillText(token.text, xOffset, y);
-                    xOffset += metrics.width;
-                }
-            }
-        }
-
-        function connect() {
-            const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-            const wsUrl = `${protocol}//${window.location.hostname}:8765`;
-            
-            ws = new WebSocket(wsUrl);
-
-            ws.onopen = () => {
-                status.textContent = 'Connected';
-                status.className = 'connected';
-                sendSize();
-            };
-
-            ws.onclose = () => {
-                status.textContent = 'Disconnected - Reconnecting...';
-                status.className = 'disconnected';
-                setTimeout(connect, 1000);
-            };
-
-            ws.onerror = () => {
-                status.textContent = 'Connection error';
-                status.className = 'disconnected';
-            };
-
-            ws.onmessage = (event) => {
-                try {
-                    const data = JSON.parse(event.data);
-                    
-                    if (data.type === 'frame') {
-                        cols = data.width || 80;
-                        rows = data.height || 24;
-                        colsInput.value = cols;
-                        rowsInput.value = rows;
-                        resizeCanvas();
-                        render(data.lines || []);
-                    } else if (data.type === 'clear') {
-                        ctx.fillStyle = '#000';
-                        ctx.fillRect(0, 0, canvas.width, canvas.height);
-                    }
-                } catch (e) {
-                    console.error('Failed to parse message:', e);
-                }
-            };
-        }
-
-        function sendSize() {
-            if (ws && ws.readyState === WebSocket.OPEN) {
-                ws.send(JSON.stringify({
-                    type: 'resize',
-                    width: parseInt(colsInput.value),
-                    height: parseInt(rowsInput.value)
-                }));
-            }
-        }
-
-        function render(lines) {
-            ctx.fillStyle = '#000';
-            ctx.fillRect(0, 0, canvas.width, canvas.height);
-
-            ctx.font = '16px monospace';
-            ctx.textBaseline = 'top';
-
-            const lineHeight = CHAR_HEIGHT;
-            const maxLines = Math.min(lines.length, rows);
-
-            for (let i = 0; i < maxLines; i++) {
-                const line = lines[i] || '';
-                renderLine(line, 0, i * lineHeight, lineHeight);
-            }
-        }
-
-        function calculateViewportSize() {
-            const isFullscreen = document.fullscreenElement !== null;
-            const padding = isFullscreen ? 0 : 40;
-            const controlsHeight = isFullscreen ? 0 : 60;
-            const availableWidth = window.innerWidth - padding;
-            const availableHeight = window.innerHeight - controlsHeight;
-            cols = Math.max(20, Math.floor(availableWidth / CHAR_WIDTH));
-            rows = Math.max(10, Math.floor(availableHeight / CHAR_HEIGHT));
-            colsInput.value = cols;
-            rowsInput.value = rows;
-            resizeCanvas();
-            console.log('Fullscreen:', isFullscreen, 'Size:', cols, 'x', rows);
-            sendSize();
-        }
-
-        applyBtn.addEventListener('click', () => {
-            cols = parseInt(colsInput.value);
-            rows = parseInt(rowsInput.value);
-            resizeCanvas();
-            sendSize();
-        });
-
-        fullscreenBtn.addEventListener('click', () => {
-            if (!document.fullscreenElement) {
-                document.body.classList.add('fullscreen');
-                document.documentElement.requestFullscreen().then(() => {
-                    calculateViewportSize();
-                });
-            } else {
-                document.exitFullscreen().then(() => {
-                    calculateViewportSize();
-                });
-            }
-        });
-
-        document.addEventListener('fullscreenchange', () => {
-            if (!document.fullscreenElement) {
-                document.body.classList.remove('fullscreen');
-                calculateViewportSize();
-            }
-        });
-
-        window.addEventListener('resize', () => {
-            if (document.fullscreenElement) {
-                calculateViewportSize();
-            }
-        });
-
-        // Initial setup
-        resizeCanvas();
-        connect();
-    </script>
-</body>
-</html>

cmdline.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 """
 Command-line utility for interacting with mainline via ntfy.
 
@@ -21,11 +20,6 @@ C&C works like a serial port:
     3. Cmdline polls for response
 """
 
-import os
-
-os.environ["FORCE_COLOR"] = "1"
-os.environ["TERM"] = "xterm-256color"
-
 import argparse
 import json
 import sys

docs/PIPELINE.md

@@ -1,118 +0,0 @@
-# Mainline Pipeline
-
-## Content to Display Rendering Pipeline
-
-```mermaid
-flowchart TD
-    subgraph Sources["Data Sources"]
-        RSS[("RSS Feeds")]
-        Poetry[("Poetry Feed")]
-        Ntfy[("Ntfy Messages")]
-        Mic[("Microphone")]
-    end
-
-    subgraph Fetch["Fetch Layer"]
-        FC[fetch_all]
-        FP[fetch_poetry]
-        Cache[(Cache)]
-    end
-
-    subgraph Prepare["Prepare Layer"]
-        MB[make_block]
-        Strip[strip_tags]
-        Trans[translate]
-    end
-
-    subgraph Scroll["Scroll Engine"]
-        CAM[Camera]
-        NH[next_headline]
-        RTZ[render_ticker_zone]
-        Grad[lr_gradient]
-        VT[vis_trunc / vis_offset]
-    end
-
-    subgraph Effects["Effect Pipeline"]
-        subgraph EffectsPlugins["Effect Plugins"]
-            Noise[NoiseEffect]
-            Fade[FadeEffect]
-            Glitch[GlitchEffect]
-            Firehose[FirehoseEffect]
-            Hud[HudEffect]
-        end
-        EC[EffectChain]
-        ER[EffectRegistry]
-    end
-
-    subgraph Render["Render Layer"]
-        RL[render_line]
-        TL[apply_ticker_layout]
-    end
-
-    subgraph Display["Display Backends"]
-        TD[TerminalDisplay]
-        PD[PygameDisplay]
-        SD[SixelDisplay]
-        KD[KittyDisplay]
-        WSD[WebSocketDisplay]
-        ND[NullDisplay]
-    end
-
-    Sources --> Fetch
-    RSS --> FC
-    Poetry --> FP
-    FC --> Cache
-    FP --> Cache
-    Cache --> MB
-    Strip --> MB
-    Trans --> MB
-    MB --> NH
-    NH --> RTZ
-    CAM --> RTZ
-    Grad --> RTZ
-    VT --> RTZ
-    RTZ --> EC
-    EC --> ER
-    ER --> EffectsPlugins
-    EffectsPlugins --> RL
-    RL --> Display
-    Ntfy --> RL
-    Mic --> RL
-
-    style Sources fill:#f9f,stroke:#333
-    style Fetch fill:#bbf,stroke:#333
-    style Scroll fill:#bfb,stroke:#333
-    style Effects fill:#fbf,stroke:#333
-    style Render fill:#ffb,stroke:#333
-    style Display fill:#bff,stroke:#333
-```
-
-## Camera Modes
-
-```mermaid
-stateDiagram-v2
-    [*] --> Vertical
-    Vertical --> Horizontal: mode change
-    Horizontal --> Omni: mode change
-    Omni --> Floating: mode change
-    Floating --> Vertical: mode change
-
-    state Vertical {
-        [*] --> ScrollUp
-        ScrollUp --> ScrollUp: +y each frame
-    }
-
-    state Horizontal {
-        [*] --> ScrollLeft
-        ScrollLeft --> ScrollLeft: +x each frame
-    }
-
-    state Omni {
-        [*] --> Diagonal
-        Diagonal --> Diagonal: +x, +y each frame
-    }
-
-    state Floating {
-        [*] --> Bobbing
-        Bobbing --> Bobbing: sin(time) for x,y
-    }
-```

docs/superpowers/plans/2026-03-16-color-scheme-implementation.md

@@ -0,0 +1,894 @@
+# Color Scheme Switcher Implementation Plan
+
+> **For agentic workers:** REQUIRED: Use superpowers:subagent-driven-development (if subagents available) or superpowers:executing-plans to implement this plan. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Implement interactive color theme picker at startup that lets users choose between green, orange, or purple gradients with complementary message queue colors.
+
+**Architecture:** New `themes.py` data module defines Theme class and THEME_REGISTRY. Config adds `ACTIVE_THEME` global set by picker. Render functions read from active theme instead of hardcoded constants. App adds picker UI that mirrors font picker pattern.
+
+**Tech Stack:** Python 3.10+, ANSI 256-color codes, existing terminal I/O utilities
+
+---
+
+## File Structure
+
+| File | Purpose | Change Type |
+|------|---------|------------|
+| `engine/themes.py` | Theme class, THEME_REGISTRY, color codes | Create |
+| `engine/config.py` | ACTIVE_THEME global, set_active_theme() | Modify |
+| `engine/render.py` | Replace GRAD_COLS/MSG_GRAD_COLS with config lookup | Modify |
+| `engine/scroll.py` | Update message gradient call | Modify |
+| `engine/app.py` | pick_color_theme(), call in main() | Modify |
+| `tests/test_themes.py` | Theme class and registry unit tests | Create |
+
+---
+
+## Chunk 1: Theme Data Module
+
+### Task 1: Create themes.py with Theme class and registry
+
+**Files:**
+- Create: `engine/themes.py`
+- Test: `tests/test_themes.py`
+
+- [ ] **Step 1: Write failing test for Theme class**
+
+Create `tests/test_themes.py`:
+
+```python
+"""Test color themes and registry."""
+from engine.themes import Theme, THEME_REGISTRY, get_theme
+
+
+def test_theme_construction():
+    """Theme stores name and gradient lists."""
+    main = ["\033[1;38;5;231m"] * 12
+    msg = ["\033[1;38;5;225m"] * 12
+    theme = Theme(name="Test Green", main_gradient=main, message_gradient=msg)
+
+    assert theme.name == "Test Green"
+    assert theme.main_gradient == main
+    assert theme.message_gradient == msg
+
+
+def test_gradient_length():
+    """Each gradient must have exactly 12 ANSI codes."""
+    for theme_id, theme in THEME_REGISTRY.items():
+        assert len(theme.main_gradient) == 12, f"{theme_id} main gradient wrong length"
+        assert len(theme.message_gradient) == 12, f"{theme_id} message gradient wrong length"
+
+
+def test_theme_registry_has_three_themes():
+    """Registry contains green, orange, purple."""
+    assert len(THEME_REGISTRY) == 3
+    assert "green" in THEME_REGISTRY
+    assert "orange" in THEME_REGISTRY
+    assert "purple" in THEME_REGISTRY
+
+
+def test_get_theme_valid():
+    """get_theme returns Theme object for valid ID."""
+    theme = get_theme("green")
+    assert isinstance(theme, Theme)
+    assert theme.name == "Verdant Green"
+
+
+def test_get_theme_invalid():
+    """get_theme raises KeyError for invalid ID."""
+    with pytest.raises(KeyError):
+        get_theme("invalid_theme")
+
+
+def test_green_theme_unchanged():
+    """Green theme uses original green → magenta colors."""
+    green_theme = get_theme("green")
+    # First color should be white (bold)
+    assert green_theme.main_gradient[0] == "\033[1;38;5;231m"
+    # Last deep green
+    assert green_theme.main_gradient[9] == "\033[38;5;22m"
+    # Message gradient is magenta
+    assert green_theme.message_gradient[9] == "\033[38;5;89m"
+```
+
+Run: `pytest tests/test_themes.py -v`
+Expected: FAIL (module doesn't exist)
+
+- [ ] **Step 2: Create themes.py with Theme class and finalized gradients**
+
+Create `engine/themes.py`:
+
+```python
+"""Color theme definitions and registry."""
+from typing import Optional
+
+
+class Theme:
+    """Encapsulates a color scheme: name, main gradient, message gradient."""
+
+    def __init__(self, name: str, main_gradient: list[str], message_gradient: list[str]):
+        """Initialize theme with display name and gradient lists.
+
+        Args:
+            name: Display name (e.g., "Verdant Green")
+            main_gradient: List of 12 ANSI 256-color codes (white → primary color)
+            message_gradient: List of 12 ANSI codes (white → complementary color)
+        """
+        self.name = name
+        self.main_gradient = main_gradient
+        self.message_gradient = message_gradient
+
+
+# ─── FINALIZED GRADIENTS ──────────────────────────────────────────────────
+# Each gradient: white → primary/complementary, 12 steps total
+# Format: "\033[<brightness>;<color>m" where color is 38;5;<colorcode>
+
+_GREEN_MAIN = [
+    "\033[1;38;5;231m",  # white (bold)
+    "\033[1;38;5;195m",  # pale white-tint
+    "\033[38;5;123m",    # bright cyan
+    "\033[38;5;118m",    # bright lime
+    "\033[38;5;82m",     # lime
+    "\033[38;5;46m",     # bright green
+    "\033[38;5;40m",     # green
+    "\033[38;5;34m",     # medium green
+    "\033[38;5;28m",     # dark green
+    "\033[38;5;22m",     # deep green
+    "\033[2;38;5;22m",   # dim deep green
+    "\033[2;38;5;235m",  # near black
+]
+
+_GREEN_MESSAGE = [
+    "\033[1;38;5;231m",  # white (bold)
+    "\033[1;38;5;225m",  # pale pink-white
+    "\033[38;5;219m",    # bright pink
+    "\033[38;5;213m",    # hot pink
+    "\033[38;5;207m",    # magenta
+    "\033[38;5;201m",    # bright magenta
+    "\033[38;5;165m",    # orchid-red
+    "\033[38;5;161m",    # ruby-magenta
+    "\033[38;5;125m",    # dark magenta
+    "\033[38;5;89m",     # deep maroon-magenta
+    "\033[2;38;5;89m",   # dim deep maroon-magenta
+    "\033[2;38;5;235m",  # near black
+]
+
+_ORANGE_MAIN = [
+    "\033[1;38;5;231m",  # white (bold)
+    "\033[1;38;5;215m",  # pale orange-white
+    "\033[38;5;209m",    # bright orange
+    "\033[38;5;208m",    # vibrant orange
+    "\033[38;5;202m",    # orange
+    "\033[38;5;166m",    # dark orange
+    "\033[38;5;130m",    # burnt orange
+    "\033[38;5;94m",     # rust
+    "\033[38;5;58m",     # dark rust
+    "\033[38;5;94m",     # rust (hold)
+    "\033[2;38;5;94m",   # dim rust
+    "\033[2;38;5;235m",  # near black
+]
+
+_ORANGE_MESSAGE = [
+    "\033[1;38;5;231m",  # white (bold)
+    "\033[1;38;5;195m",  # pale cyan-white
+    "\033[38;5;33m",     # bright blue
+    "\033[38;5;27m",     # blue
+    "\033[38;5;21m",     # deep blue
+    "\033[38;5;21m",     # deep blue (hold)
+    "\033[38;5;21m",     # deep blue (hold)
+    "\033[38;5;18m",     # navy
+    "\033[38;5;18m",     # navy (hold)
+    "\033[38;5;18m",     # navy (hold)
+    "\033[2;38;5;18m",   # dim navy
+    "\033[2;38;5;235m",  # near black
+]
+
+_PURPLE_MAIN = [
+    "\033[1;38;5;231m",  # white (bold)
+    "\033[1;38;5;225m",  # pale purple-white
+    "\033[38;5;177m",    # bright purple
+    "\033[38;5;171m",    # vibrant purple
+    "\033[38;5;165m",    # purple
+    "\033[38;5;135m",    # medium purple
+    "\033[38;5;129m",    # purple
+    "\033[38;5;93m",     # dark purple
+    "\033[38;5;57m",     # deep purple
+    "\033[38;5;57m",     # deep purple (hold)
+    "\033[2;38;5;57m",   # dim deep purple
+    "\033[2;38;5;235m",  # near black
+]
+
+_PURPLE_MESSAGE = [
+    "\033[1;38;5;231m",  # white (bold)
+    "\033[1;38;5;226m",  # pale yellow-white
+    "\033[38;5;226m",    # bright yellow
+    "\033[38;5;220m",    # yellow
+    "\033[38;5;220m",    # yellow (hold)
+    "\033[38;5;184m",    # dark yellow
+    "\033[38;5;184m",    # dark yellow (hold)
+    "\033[38;5;178m",    # olive-yellow
+    "\033[38;5;178m",    # olive-yellow (hold)
+    "\033[38;5;172m",    # golden
+    "\033[2;38;5;172m",  # dim golden
+    "\033[2;38;5;235m",  # near black
+]
+
+# ─── THEME REGISTRY ───────────────────────────────────────────────────────
+
+THEME_REGISTRY = {
+    "green": Theme(
+        name="Verdant Green",
+        main_gradient=_GREEN_MAIN,
+        message_gradient=_GREEN_MESSAGE,
+    ),
+    "orange": Theme(
+        name="Molten Orange",
+        main_gradient=_ORANGE_MAIN,
+        message_gradient=_ORANGE_MESSAGE,
+    ),
+    "purple": Theme(
+        name="Violet Purple",
+        main_gradient=_PURPLE_MAIN,
+        message_gradient=_PURPLE_MESSAGE,
+    ),
+}
+
+
+def get_theme(theme_id: str) -> Theme:
+    """Retrieve a theme by ID.
+
+    Args:
+        theme_id: One of "green", "orange", "purple"
+
+    Returns:
+        Theme object
+
+    Raises:
+        KeyError: If theme_id not found in registry
+    """
+    if theme_id not in THEME_REGISTRY:
+        raise KeyError(f"Unknown theme: {theme_id}. Available: {list(THEME_REGISTRY.keys())}")
+    return THEME_REGISTRY[theme_id]
+```
+
+- [ ] **Step 3: Run tests to verify they pass**
+
+Run: `pytest tests/test_themes.py -v`
+Expected: PASS (all 6 tests)
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add engine/themes.py tests/test_themes.py
+git commit -m "feat: create Theme class and registry with finalized color gradients
+
+- Define Theme class to encapsulate name and main/message gradients
+- Create THEME_REGISTRY with green, orange, purple themes
+- Each gradient has 12 ANSI 256-color codes finalized
+- Complementary color pairs: green/magenta, orange/blue, purple/yellow
+- Add get_theme() lookup with error handling
+- Add comprehensive unit tests"
+```
+
+---
+
+## Chunk 2: Config Integration
+
+### Task 2: Add ACTIVE_THEME global and set_active_theme() to config.py
+
+**Files:**
+- Modify: `engine/config.py:1-30`
+- Test: `tests/test_config.py` (expand existing)
+
+- [ ] **Step 1: Write failing tests for config changes**
+
+Add to `tests/test_config.py`:
+
+```python
+def test_active_theme_initially_none():
+    """ACTIVE_THEME is None before initialization."""
+    # This test may fail if config is already initialized
+    # We'll set it to None first for testing
+    import engine.config
+    engine.config.ACTIVE_THEME = None
+    assert engine.config.ACTIVE_THEME is None
+
+
+def test_set_active_theme_green():
+    """set_active_theme('green') sets ACTIVE_THEME to green theme."""
+    from engine.config import set_active_theme
+    from engine.themes import get_theme
+
+    set_active_theme("green")
+
+    assert config.ACTIVE_THEME is not None
+    assert config.ACTIVE_THEME.name == "Verdant Green"
+    assert config.ACTIVE_THEME == get_theme("green")
+
+
+def test_set_active_theme_default():
+    """set_active_theme() with no args defaults to green."""
+    from engine.config import set_active_theme
+
+    set_active_theme()
+
+    assert config.ACTIVE_THEME.name == "Verdant Green"
+
+
+def test_set_active_theme_invalid():
+    """set_active_theme() with invalid ID raises KeyError."""
+    from engine.config import set_active_theme
+
+    with pytest.raises(KeyError):
+        set_active_theme("invalid")
+```
+
+Run: `pytest tests/test_config.py -v`
+Expected: FAIL (functions don't exist yet)
+
+- [ ] **Step 2: Add ACTIVE_THEME global and set_active_theme() to config.py**
+
+Edit `engine/config.py`, add after line 30 (after `_resolve_font_path` function):
+
+```python
+# ─── COLOR THEME ──────────────────────────────────────────────────────────
+ACTIVE_THEME = None  # set by set_active_theme() after picker
+
+
+def set_active_theme(theme_id: str = "green"):
+    """Set the active color theme. Defaults to 'green' if not specified.
+
+    Args:
+        theme_id: One of "green", "orange", "purple"
+
+    Raises:
+        KeyError: If theme_id is invalid
+    """
+    global ACTIVE_THEME
+    from engine import themes
+    ACTIVE_THEME = themes.get_theme(theme_id)
+```
+
+- [ ] **Step 3: Remove hardcoded GRAD_COLS and MSG_GRAD_COLS from render.py**
+
+Edit `engine/render.py`, find and delete lines 20-49 (the hardcoded gradient arrays):
+
+```python
+# DELETED:
+# GRAD_COLS = [...]
+# MSG_GRAD_COLS = [...]
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `pytest tests/test_config.py::test_active_theme_initially_none -v`
+Run: `pytest tests/test_config.py::test_set_active_theme_green -v`
+Run: `pytest tests/test_config.py::test_set_active_theme_default -v`
+Run: `pytest tests/test_config.py::test_set_active_theme_invalid -v`
+
+Expected: PASS (all 4 new tests)
+
+- [ ] **Step 5: Verify existing config tests still pass**
+
+Run: `pytest tests/test_config.py -v`
+
+Expected: PASS (all existing + new tests)
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add engine/config.py tests/test_config.py
+git commit -m "feat: add ACTIVE_THEME global and set_active_theme() to config
+
+- Add ACTIVE_THEME global (initialized to None)
+- Add set_active_theme(theme_id) function with green default
+- Remove hardcoded GRAD_COLS and MSG_GRAD_COLS (move to themes.py)
+- Add comprehensive tests for theme setting"
+```
+
+---
+
+## Chunk 3: Render Pipeline Integration
+
+### Task 3: Update render.py to use config.ACTIVE_THEME
+
+**Files:**
+- Modify: `engine/render.py:15-220`
+- Test: `tests/test_render.py` (expand existing)
+
+- [ ] **Step 1: Write failing test for lr_gradient with theme**
+
+Add to `tests/test_render.py`:
+
+```python
+def test_lr_gradient_uses_active_theme(monkeypatch):
+    """lr_gradient uses config.ACTIVE_THEME when cols=None."""
+    from engine import config, render
+    from engine.themes import get_theme
+
+    # Set orange theme
+    config.set_active_theme("orange")
+
+    # Create simple rows
+    rows = ["test row"]
+    result = render.lr_gradient(rows, offset=0, cols=None)
+
+    # Result should start with first color from orange main gradient
+    assert result[0].startswith("\033[1;38;5;231m")  # white (same for all)
+
+
+def test_lr_gradient_fallback_when_no_theme(monkeypatch):
+    """lr_gradient uses fallback when ACTIVE_THEME is None."""
+    from engine import config, render
+
+    # Clear active theme
+    config.ACTIVE_THEME = None
+
+    rows = ["test row"]
+    result = render.lr_gradient(rows, offset=0, cols=None)
+
+    # Should not crash and should return something
+    assert result is not None
+    assert len(result) > 0
+
+
+def test_default_green_gradient_length():
+    """_default_green_gradient returns 12 colors."""
+    from engine import render
+
+    colors = render._default_green_gradient()
+    assert len(colors) == 12
+```
+
+Run: `pytest tests/test_render.py::test_lr_gradient_uses_active_theme -v`
+Expected: FAIL (function signature doesn't match)
+
+- [ ] **Step 2: Update lr_gradient() to use config.ACTIVE_THEME**
+
+Edit `engine/render.py`, find the `lr_gradient()` function (around line 194) and update it:
+
+```python
+def lr_gradient(rows, offset, cols=None):
+    """
+    Render rows through a left-to-right color sweep.
+
+    Args:
+        rows: List of text rows to colorize
+        offset: Gradient position offset (for animation)
+        cols: Optional list of color codes. If None, uses active theme.
+
+    Returns:
+        List of colorized rows
+    """
+    if cols is None:
+        from engine import config
+        cols = (
+            config.ACTIVE_THEME.main_gradient
+            if config.ACTIVE_THEME
+            else _default_green_gradient()
+        )
+
+    # ... rest of function unchanged ...
+```
+
+- [ ] **Step 3: Add _default_green_gradient() fallback function**
+
+Add to `engine/render.py` before `lr_gradient()`:
+
+```python
+def _default_green_gradient():
+    """Fallback green gradient (original colors) for initialization."""
+    return [
+        "\033[1;38;5;231m",  # white (bold)
+        "\033[1;38;5;195m",  # pale white-tint
+        "\033[38;5;123m",    # bright cyan
+        "\033[38;5;118m",    # bright lime
+        "\033[38;5;82m",     # lime
+        "\033[38;5;46m",     # bright green
+        "\033[38;5;40m",     # green
+        "\033[38;5;34m",     # medium green
+        "\033[38;5;28m",     # dark green
+        "\033[38;5;22m",     # deep green
+        "\033[2;38;5;22m",   # dim deep green
+        "\033[2;38;5;235m",  # near black
+    ]
+
+
+def _default_magenta_gradient():
+    """Fallback magenta gradient (original message colors) for initialization."""
+    return [
+        "\033[1;38;5;231m",  # white (bold)
+        "\033[1;38;5;225m",  # pale pink-white
+        "\033[38;5;219m",    # bright pink
+        "\033[38;5;213m",    # hot pink
+        "\033[38;5;207m",    # magenta
+        "\033[38;5;201m",    # bright magenta
+        "\033[38;5;165m",    # orchid-red
+        "\033[38;5;161m",    # ruby-magenta
+        "\033[38;5;125m",    # dark magenta
+        "\033[38;5;89m",     # deep maroon-magenta
+        "\033[2;38;5;89m",   # dim deep maroon-magenta
+        "\033[2;38;5;235m",  # near black
+    ]
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `pytest tests/test_render.py::test_lr_gradient_uses_active_theme -v`
+Run: `pytest tests/test_render.py::test_lr_gradient_fallback_when_no_theme -v`
+Run: `pytest tests/test_render.py::test_default_green_gradient_length -v`
+
+Expected: PASS (all 3 new tests)
+
+- [ ] **Step 5: Run full render test suite**
+
+Run: `pytest tests/test_render.py -v`
+
+Expected: PASS (existing tests may need adjustment for mocking)
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add engine/render.py tests/test_render.py
+git commit -m "feat: update lr_gradient to use config.ACTIVE_THEME
+
+- Update lr_gradient(cols=None) to check config.ACTIVE_THEME
+- Add _default_green_gradient() and _default_magenta_gradient() fallbacks
+- Fallback used when ACTIVE_THEME is None (non-interactive init)
+- Add tests for theme-aware and fallback gradient rendering"
+```
+
+---
+
+## Chunk 4: Message Gradient Integration
+
+### Task 4: Update scroll.py to use message gradient from config
+
+**Files:**
+- Modify: `engine/scroll.py:85-95`
+- Test: existing `tests/test_scroll.py`
+
+- [ ] **Step 1: Locate message gradient calls in scroll.py**
+
+Run: `grep -n "MSG_GRAD_COLS\|lr_gradient_opposite" /Users/genejohnson/Dev/mainline/engine/scroll.py`
+
+Expected: Should find line(s) where `MSG_GRAD_COLS` or similar is used
+
+- [ ] **Step 2: Update scroll.py to use theme message gradient**
+
+Edit `engine/scroll.py`, find the line that uses message gradients (around line 89 based on spec) and update:
+
+Old code:
+```python
+# Some variation of:
+rows = lr_gradient(rows, offset, MSG_GRAD_COLS)
+```
+
+New code:
+```python
+from engine import config
+msg_cols = (
+    config.ACTIVE_THEME.message_gradient
+    if config.ACTIVE_THEME
+    else render._default_magenta_gradient()
+)
+rows = lr_gradient(rows, offset, msg_cols)
+```
+
+Or use the helper approach (create `msg_gradient()` in render.py):
+
+```python
+def msg_gradient(rows, offset):
+    """Apply message (ntfy) gradient using theme complementary colors."""
+    from engine import config
+    cols = (
+        config.ACTIVE_THEME.message_gradient
+        if config.ACTIVE_THEME
+        else _default_magenta_gradient()
+    )
+    return lr_gradient(rows, offset, cols)
+```
+
+Then in scroll.py:
+```python
+rows = render.msg_gradient(rows, offset)
+```
+
+- [ ] **Step 3: Run existing scroll tests**
+
+Run: `pytest tests/test_scroll.py -v`
+
+Expected: PASS (existing functionality unchanged)
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add engine/scroll.py engine/render.py
+git commit -m "feat: update scroll.py to use theme message gradient
+
+- Replace MSG_GRAD_COLS reference with config.ACTIVE_THEME.message_gradient
+- Use fallback magenta gradient when theme not initialized
+- Ensure ntfy messages render in complementary color from selected theme"
+```
+
+---
+
+## Chunk 5: Color Picker UI
+
+### Task 5: Create pick_color_theme() function in app.py
+
+**Files:**
+- Modify: `engine/app.py:1-300`
+- Test: manual/integration (interactive)
+
+- [ ] **Step 1: Write helper functions for color picker UI**
+
+Edit `engine/app.py`, add before `pick_font_face()` function:
+
+```python
+def _draw_color_picker(themes_list, selected):
+    """Draw the color theme picker menu."""
+    import sys
+    from engine.terminal import CLR, W_GHOST, G_HI, G_DIM, tw
+
+    print(CLR, end="")
+    print()
+    print(f"  {G_HI}▼ COLOR THEME{W_GHOST} ─ ↑/↓ or j/k to move, Enter/q to select{G_DIM}")
+    print(f"  {W_GHOST}{'─' * (tw() - 4)}\n")
+
+    for i, (theme_id, theme) in enumerate(themes_list):
+        prefix = "  ▶ " if i == selected else "    "
+        color = G_HI if i == selected else ""
+        reset = "" if i == selected else W_GHOST
+        print(f"{prefix}{color}{theme.name}{reset}")
+
+    print()
+```
+
+- [ ] **Step 2: Create pick_color_theme() function**
+
+Edit `engine/app.py`, add after helper function:
+
+```python
+def pick_color_theme():
+    """Interactive color theme picker. Defaults to 'green' if not TTY."""
+    import sys
+    import termios
+    import tty
+    from engine import config, themes
+
+    # Non-interactive fallback: use green
+    if not sys.stdin.isatty():
+        config.set_active_theme("green")
+        return
+
+    themes_list = list(themes.THEME_REGISTRY.items())
+    selected = 0
+
+    fd = sys.stdin.fileno()
+    old_settings = termios.tcgetattr(fd)
+    try:
+        tty.setcbreak(fd)
+        while True:
+            _draw_color_picker(themes_list, selected)
+            key = _read_picker_key()
+            if key == "up":
+                selected = max(0, selected - 1)
+            elif key == "down":
+                selected = min(len(themes_list) - 1, selected + 1)
+            elif key == "enter":
+                break
+            elif key == "interrupt":
+                raise KeyboardInterrupt
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+
+    selected_theme_id = themes_list[selected][0]
+    config.set_active_theme(selected_theme_id)
+
+    theme_name = themes_list[selected][1].name
+    print(f"  {G_DIM}> using {theme_name}{RST}")
+    time.sleep(0.8)
+    print(CLR, end="")
+    print(CURSOR_OFF, end="")
+    print()
+```
+
+- [ ] **Step 3: Update main() to call pick_color_theme() before pick_font_face()**
+
+Edit `engine/app.py`, find the `main()` function and locate where `pick_font_face()` is called (around line 265). Add before it:
+
+```python
+def main():
+    # ... existing signal handler setup ...
+
+    pick_color_theme()  # NEW LINE - before font picker
+    pick_font_face()
+
+    # ... rest of main unchanged ...
+```
+
+- [ ] **Step 4: Manual test - run in interactive terminal**
+
+Run: `python3 mainline.py`
+
+Expected:
+- See color theme picker menu before font picker
+- Can navigate with ↑/↓ or j/k
+- Can select with Enter or q
+- Selected theme applies to scrolling headlines
+- Can select different themes and see colors change
+
+- [ ] **Step 5: Manual test - run in non-interactive environment**
+
+Run: `echo "" | python3 mainline.py`
+
+Expected:
+- No color picker menu shown
+- Defaults to green theme
+- App runs without error
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add engine/app.py
+git commit -m "feat: add pick_color_theme() UI and integration
+
+- Create _draw_color_picker() to render menu
+- Create pick_color_theme() function mirroring font picker pattern
+- Integrate into main() before font picker
+- Fallback to green theme in non-interactive environments
+- Support arrow keys and j/k navigation"
+```
+
+---
+
+## Chunk 6: Integration & Validation
+
+### Task 6: End-to-end testing and cleanup
+
+**Files:**
+- Test: All modified files
+- Verify: App functionality
+
+- [ ] **Step 1: Run full test suite**
+
+Run: `pytest tests/ -v`
+
+Expected: PASS (all tests, including new ones)
+
+- [ ] **Step 2: Run linter**
+
+Run: `ruff check engine/ mainline.py`
+
+Expected: No errors (fix any style issues)
+
+- [ ] **Step 3: Manual integration test - green theme**
+
+Run: `python3 mainline.py`
+
+Then select "Verdant Green" from picker.
+
+Expected:
+- Headlines render in green → deep green
+- ntfy messages render in magenta gradient
+- Both work correctly during streaming
+
+- [ ] **Step 4: Manual integration test - orange theme**
+
+Run: `python3 mainline.py`
+
+Then select "Molten Orange" from picker.
+
+Expected:
+- Headlines render in orange → deep orange
+- ntfy messages render in blue gradient
+- Colors are visually distinct from green
+
+- [ ] **Step 5: Manual integration test - purple theme**
+
+Run: `python3 mainline.py`
+
+Then select "Violet Purple" from picker.
+
+Expected:
+- Headlines render in purple → deep purple
+- ntfy messages render in yellow gradient
+- Colors are visually distinct from green and orange
+
+- [ ] **Step 6: Test poetry mode with color picker**
+
+Run: `python3 mainline.py --poetry`
+
+Then select "orange" from picker.
+
+Expected:
+- Poetry mode works with color picker
+- Colors apply to poetry rendering
+
+- [ ] **Step 7: Test code mode with color picker**
+
+Run: `python3 mainline.py --code`
+
+Then select "purple" from picker.
+
+Expected:
+- Code mode works with color picker
+- Colors apply to code rendering
+
+- [ ] **Step 8: Verify acceptance criteria**
+
+✓ Color picker displays 3 theme options at startup
+✓ Selection applies to all headline and message gradients
+✓ Boot UI (title, status) uses hardcoded green (not theme)
+✓ Scrolling headlines and ntfy messages use theme gradients
+✓ No persistence between runs (each run picks fresh)
+✓ Non-TTY environments default to green without error
+✓ Architecture supports future random/animation modes
+✓ All gradient color codes finalized with no TBD values
+
+- [ ] **Step 9: Final commit**
+
+```bash
+git add -A
+git commit -m "feat: color scheme switcher implementation complete
+
+Closes color-pick feature with:
+- Three selectable color themes (green, orange, purple)
+- Interactive menu at startup (mirrors font picker UI)
+- Complementary colors for ntfy message queue
+- Fallback to green in non-interactive environments
+- All tests passing, manual validation complete"
+```
+
+- [ ] **Step 10: Create feature branch PR summary**
+
+```
+## Color Scheme Switcher
+
+Implements interactive color theme selection for Mainline news ticker.
+
+### What's New
+- 3 color themes: Verdant Green, Molten Orange, Violet Purple
+- Interactive picker at startup (↑/↓ or j/k, Enter to select)
+- Complementary gradients for ntfy messages (magenta, blue, yellow)
+- Fresh theme selection each run (no persistence)
+
+### Files Changed
+- `engine/themes.py` (new)
+- `engine/config.py` (ACTIVE_THEME, set_active_theme)
+- `engine/render.py` (theme-aware gradients)
+- `engine/scroll.py` (message gradient integration)
+- `engine/app.py` (pick_color_theme UI)
+- `tests/test_themes.py` (new theme tests)
+- `README.md` (documentation)
+
+### Acceptance Criteria
+All met. App fully tested and ready for merge.
+```
+
+---
+
+## Testing Checklist
+
+- [ ] Unit tests: `pytest tests/test_themes.py -v`
+- [ ] Unit tests: `pytest tests/test_config.py -v`
+- [ ] Unit tests: `pytest tests/test_render.py -v`
+- [ ] Full suite: `pytest tests/ -v`
+- [ ] Linting: `ruff check engine/ mainline.py`
+- [ ] Manual: Green theme selection
+- [ ] Manual: Orange theme selection
+- [ ] Manual: Purple theme selection
+- [ ] Manual: Poetry mode with colors
+- [ ] Manual: Code mode with colors
+- [ ] Manual: Non-TTY fallback
+
+---
+
+## Notes
+
+- `themes.py` is data-only; never import config or render to prevent cycles
+- `ACTIVE_THEME` initialized to None; guaranteed non-None before stream() via pick_color_theme()
+- Font picker UI remains hardcoded green; title/subtitle use G_HI/G_DIM constants (not theme)
+- Message gradients use complementary colors; lookup in scroll.py
+- Each gradient has 12 colors; verify length in tests
+- No persistence; fresh picker each run

docs/superpowers/specs/2026-03-16-code-scroll-design.md

@@ -0,0 +1,154 @@
+# Code Scroll Mode — Design Spec
+
+**Date:** 2026-03-16
+**Branch:** feat/code-scroll
+**Status:** Approved
+
+---
+
+## Overview
+
+Add a `--code` CLI flag that puts MAINLINE into "source consciousness" mode. Instead of RSS headlines or poetry stanzas, the program's own source code scrolls upward as large OTF half-block characters with the standard white-hot → deep green gradient. Each scroll item is one non-blank, non-comment line from `engine/*.py`, attributed to its enclosing function/class scope and dotted module path.
+
+---
+
+## Goals
+
+- Mirror the existing `--poetry` mode pattern as closely as possible
+- Zero new runtime dependencies (stdlib `ast` and `pathlib` only)
+- No changes to `scroll.py` or the render pipeline
+- The item tuple shape `(text, src, ts)` is unchanged
+
+---
+
+## New Files
+
+### `engine/fetch_code.py`
+
+Single public function `fetch_code()` that returns `(items, line_count, 0)`.
+
+**Algorithm:**
+
+1. Glob `engine/*.py` in sorted order
+2. For each file:
+   a. Read source text
+   b. `ast.parse(source)` → build a `{line_number: scope_label}` map by walking all `FunctionDef`, `AsyncFunctionDef`, and `ClassDef` nodes. Each node covers its full line range. Inner scopes override outer ones.
+   c. Iterate source lines (1-indexed). Skip if:
+      - The stripped line is empty
+      - The stripped line starts with `#`
+   d. For each kept line emit:
+      - `text` = `line.rstrip()` (preserve indentation for readability in the big render)
+      - `src` = scope label from the AST map, e.g. `stream()` for functions, `MicMonitor` for classes, `<module>` for top-level lines
+      - `ts` = dotted module path derived from filename, e.g. `engine/scroll.py` → `engine.scroll`
+3. Return `(items, len(items), 0)`
+
+**Scope label rules:**
+- `FunctionDef` / `AsyncFunctionDef` → `name()`
+- `ClassDef` → `name` (no parens)
+- No enclosing node → `<module>`
+
+**Dependencies:** `ast`, `pathlib` — stdlib only.
+
+---
+
+## Modified Files
+
+### `engine/config.py`
+
+Extend `MODE` detection to recognise `--code`:
+
+```python
+MODE = (
+    "poetry" if "--poetry" in sys.argv or "-p" in sys.argv
+    else "code" if "--code" in sys.argv
+    else "news"
+)
+```
+
+### `engine/app.py`
+
+**Subtitle line** — extend the subtitle dict:
+
+```python
+_subtitle = {
+    "poetry": "literary consciousness stream",
+    "code":   "source consciousness stream",
+}.get(config.MODE, "digital consciousness stream")
+```
+
+**Boot sequence** — add `elif config.MODE == "code":` branch after the poetry branch:
+
+```python
+elif config.MODE == "code":
+    from engine.fetch_code import fetch_code
+    slow_print("  > INITIALIZING SOURCE ARRAY...\n")
+    time.sleep(0.2)
+    print()
+    items, line_count, _ = fetch_code()
+    print()
+    print(f"  {G_DIM}>{RST} {G_MID}{line_count} LINES ACQUIRED{RST}")
+```
+
+No cache save/load — local source files are read instantly and change only on disk writes.
+
+---
+
+## Data Flow
+
+```
+engine/*.py (sorted)
+    │
+    ▼
+fetch_code()
+    │  ast.parse → scope map
+    │  filter blank + comment lines
+    │  emit (line, scope(), engine.module)
+    ▼
+items: List[Tuple[str, str, str]]
+    │
+    ▼
+stream(items, ntfy, mic)   ← unchanged
+    │
+    ▼
+next_headline() shuffles + recycles automatically
+```
+
+---
+
+## Error Handling
+
+- If a file fails to `ast.parse` (malformed source), fall back to `<module>` scope for all lines in that file — do not crash.
+- If `engine/` contains no `.py` files (shouldn't happen in practice), `fetch_code()` returns an empty list; `app.py`'s existing `if not items:` guard handles this.
+
+---
+
+## Testing
+
+New file: `tests/test_fetch_code.py`
+
+| Test | Assertion |
+|------|-----------|
+| `test_items_are_tuples` | Every item from `fetch_code()` is a 3-tuple of strings |
+| `test_blank_and_comment_lines_excluded` | No item text is empty; no item text (stripped) starts with `#` |
+| `test_module_path_format` | Every `ts` field matches pattern `engine\.\w+` |
+
+No mocking — tests read the real engine source files, keeping them honest against actual content.
+
+---
+
+## CLI
+
+```bash
+python3 mainline.py --code        # source consciousness mode
+uv run mainline.py --code
+```
+
+Compatible with all existing flags (`--no-font-picker`, `--font-file`, `--firehose`, etc.).
+
+---
+
+## Out of Scope
+
+- Syntax highlighting / token-aware coloring (can be added later)
+- `--code-dir` flag for pointing at arbitrary directories (YAGNI)
+- Caching code items to disk

docs/superpowers/specs/2026-03-16-color-scheme-design.md

@@ -0,0 +1,299 @@
+# Color Scheme Switcher Design
+
+**Date:** 2026-03-16
+**Status:** Revised after review
+**Scope:** Interactive color theme selection for Mainline news ticker
+
+---
+
+## Overview
+
+Mainline currently renders news headlines with a fixed white-hot → deep green gradient. This feature adds an interactive theme picker at startup that lets users choose between three precise color schemes (green, orange, purple), each with complementary message queue colors.
+
+The implementation uses a dedicated `Theme` class to encapsulate gradients and metadata, enabling future extensions like random rotation, animation, or additional themes without architectural changes.
+
+---
+
+## Requirements
+
+**Functional:**
+1. User selects a color theme from an interactive menu at startup (green, orange, or purple)
+2. Main headline gradient uses the selected primary color (white → color)
+3. Message queue (ntfy) gradient uses the precise complementary color (white → opposite)
+4. Selection is fresh each run (no persistence)
+5. Design supports future "random rotation" mode without refactoring
+
+**Complementary colors (precise opposites):**
+- Green (38;5;22) → Magenta (38;5;89) *(current, unchanged)*
+- Orange (38;5;208) → Blue (38;5;21)
+- Purple (38;5;129) → Yellow (38;5;226)
+
+**Non-functional:**
+- Reuse the existing font picker pattern for UI consistency
+- Zero runtime overhead during streaming (theme lookup happens once at startup)
+- **Boot UI (title, subtitle, status lines) use hardcoded green color constants (G_HI, G_DIM, G_MID); only scrolling headlines and ntfy messages use theme gradients**
+- Font picker UI remains hardcoded green for visual continuity
+
+---
+
+## Architecture
+
+### New Module: `engine/themes.py`
+
+**Data-only module:** Contains Theme class, THEME_REGISTRY, and get_theme() function. **Imports only typing; does NOT import config or render** to prevent circular dependencies.
+
+```python
+class Theme:
+    """Encapsulates a color scheme: name, main gradient, message gradient."""
+
+    def __init__(self, name: str, main_gradient: list[str], message_gradient: list[str]):
+        self.name = name
+        self.main_gradient = main_gradient      # white → primary color
+        self.message_gradient = message_gradient  # white → complementary
+```
+
+**Theme Registry:**
+Three instances registered by ID: `"green"`, `"orange"`, `"purple"` (IDs match menu labels for clarity).
+
+Each gradient is a list of 12 ANSI 256-color codes matching the current green gradient:
+```
+[
+    "\033[1;38;5;231m",  # white (bold)
+    "\033[1;38;5;195m",  # pale white-tint
+    "\033[38;5;123m",    # bright cyan
+    "\033[38;5;118m",    # bright lime
+    "\033[38;5;82m",     # lime
+    "\033[38;5;46m",     # bright color
+    "\033[38;5;40m",     # color
+    "\033[38;5;34m",     # medium color
+    "\033[38;5;28m",     # dark color
+    "\033[38;5;22m",     # deep color
+    "\033[2;38;5;22m",   # dim deep color
+    "\033[2;38;5;235m",  # near black
+]
+```
+
+**Finalized color codes:**
+
+**Green (primary: 22, complementary: 89)** — unchanged from current
+- Main: `[231, 195, 123, 118, 82, 46, 40, 34, 28, 22, 22(dim), 235]`
+- Messages: `[231, 225, 219, 213, 207, 201, 165, 161, 125, 89, 89(dim), 235]`
+
+**Orange (primary: 208, complementary: 21)**
+- Main: `[231, 215, 209, 208, 202, 166, 130, 94, 58, 94, 94(dim), 235]`
+- Messages: `[231, 195, 33, 27, 21, 21, 21, 18, 18, 18, 18(dim), 235]`
+
+**Purple (primary: 129, complementary: 226)**
+- Main: `[231, 225, 177, 171, 165, 135, 129, 93, 57, 57, 57(dim), 235]`
+- Messages: `[231, 226, 226, 220, 220, 184, 184, 178, 178, 172, 172(dim), 235]`
+
+**Public API:**
+- `get_theme(theme_id: str) -> Theme` — lookup by ID, raises KeyError if not found
+- `THEME_REGISTRY` — dict of all available themes (for picker)
+
+---
+
+### Modified: `engine/config.py`
+
+**New globals:**
+```python
+ACTIVE_THEME = None  # set by set_active_theme() after picker; guaranteed non-None during stream()
+```
+
+**New function:**
+```python
+def set_active_theme(theme_id: str = "green"):
+    """Set the active theme. Defaults to 'green' if not specified."""
+    global ACTIVE_THEME
+    from engine import themes
+    ACTIVE_THEME = themes.get_theme(theme_id)
+```
+
+**Behavior:**
+- Called by `app.pick_color_theme()` with user selection
+- Has default fallback to "green" for non-interactive environments (CI, testing, piped stdin)
+- Guarantees `ACTIVE_THEME` is set before any render functions are called
+
+**Removal:**
+- Delete hardcoded `GRAD_COLS` and `MSG_GRAD_COLS` constants
+
+---
+
+### Modified: `engine/render.py`
+
+**Updated gradient access in existing functions:**
+
+Current pattern (will be removed):
+```python
+GRAD_COLS = [...]  # hardcoded green
+MSG_GRAD_COLS = [...] # hardcoded magenta
+```
+
+New pattern — update `lr_gradient()` function:
+```python
+def lr_gradient(rows, offset, cols=None):
+    if cols is None:
+        from engine import config
+        cols = (config.ACTIVE_THEME.main_gradient
+                if config.ACTIVE_THEME
+                else _default_green_gradient())
+    # ... rest of function unchanged
+```
+
+**Define fallback:**
+```python
+def _default_green_gradient():
+    """Fallback green gradient (current colors)."""
+    return [
+        "\033[1;38;5;231m", "\033[1;38;5;195m", "\033[38;5;123m",
+        "\033[38;5;118m", "\033[38;5;82m", "\033[38;5;46m",
+        "\033[38;5;40m", "\033[38;5;34m", "\033[38;5;28m",
+        "\033[38;5;22m", "\033[2;38;5;22m", "\033[2;38;5;235m",
+    ]
+```
+
+**Message gradient handling:**
+
+The existing code (scroll.py line 89) calls `lr_gradient()` with `MSG_GRAD_COLS`. Change this call to:
+```python
+# Instead of: lr_gradient(rows, offset, MSG_GRAD_COLS)
+# Use:
+from engine import config
+cols = (config.ACTIVE_THEME.message_gradient
+        if config.ACTIVE_THEME
+        else _default_magenta_gradient())
+lr_gradient(rows, offset, cols)
+```
+
+or define a helper:
+```python
+def msg_gradient(rows, offset):
+    """Apply message (ntfy) gradient using theme complementary colors."""
+    from engine import config
+    cols = (config.ACTIVE_THEME.message_gradient
+            if config.ACTIVE_THEME
+            else _default_magenta_gradient())
+    return lr_gradient(rows, offset, cols)
+```
+
+---
+
+### Modified: `engine/app.py`
+
+**New function: `pick_color_theme()`**
+
+Mirrors `pick_font_face()` pattern:
+
+```python
+def pick_color_theme():
+    """Interactive color theme picker. Defaults to 'green' if not TTY."""
+    import sys
+    from engine import config, themes
+
+    # Non-interactive fallback: use default
+    if not sys.stdin.isatty():
+        config.set_active_theme("green")
+        return
+
+    # Interactive picker (similar to font picker)
+    themes_list = list(themes.THEME_REGISTRY.items())
+    selected = 0
+
+    # ... render menu, handle arrow keys j/k, ↑/↓ ...
+    # ... on Enter, call config.set_active_theme(themes_list[selected][0]) ...
+```
+
+**Placement in `main()`:**
+```python
+def main():
+    # ... signal handler setup ...
+    pick_color_theme()  # NEW — before title/subtitle
+    pick_font_face()
+    # ... rest of boot sequence, title/subtitle use hardcoded G_HI/G_DIM ...
+```
+
+**Important:** The title and subtitle render with hardcoded `G_HI`/`G_DIM` constants, not theme gradients. This is intentional for visual consistency with the font picker menu.
+
+---
+
+## Data Flow
+
+```
+User starts: mainline.py
+    ↓
+main() called
+    ↓
+pick_color_theme()
+    → If TTY: display menu, read input, call config.set_active_theme(user_choice)
+    → If not TTY: silently call config.set_active_theme("green")
+    ↓
+pick_font_face() — renders in hardcoded green UI colors
+    ↓
+Boot messages (title, status) — all use hardcoded G_HI/G_DIM (not theme gradients)
+    ↓
+stream() — headlines + ntfy messages use config.ACTIVE_THEME gradients
+    ↓
+On exit: no persistence
+```
+
+---
+
+## Implementation Notes
+
+### Initialization Guarantee
+`config.ACTIVE_THEME` is guaranteed to be non-None before `stream()` is called because:
+1. `pick_color_theme()` always sets it (either interactively or via fallback)
+2. It's called before any rendering happens
+3. Default fallback ensures non-TTY environments don't crash
+
+### Module Independence
+`themes.py` is a pure data module with no imports of `config` or `render`. This prevents circular dependencies and allows it to be imported by multiple consumers without side effects.
+
+### Color Code Finalization
+All three gradient sequences (green, orange, purple main + complementary) are now finalized with specific ANSI codes. No TBD placeholders remain.
+
+### Theme ID Naming
+IDs are `"green"`, `"orange"`, `"purple"` — matching the menu labels exactly for clarity.
+
+### Terminal Resize Handling
+The `pick_color_theme()` function mirrors `pick_font_face()`, which does not handle terminal resizing during the picker display. If the terminal is resized while the picker menu is shown, the menu redraw may be incomplete; pressing any key (arrow, j/k, q) continues normally. This is acceptable because:
+1. The picker completes quickly (< 5 seconds typical interaction)
+2. Once a theme is selected, the menu closes and rendering begins
+3. The streaming phase (`stream()`) is resilient to terminal resizing and auto-reflows to new dimensions
+
+No special resize handling is needed for the color picker beyond what exists for the font picker.
+
+### Testing Strategy
+1. **Unit tests** (`tests/test_themes.py`):
+   - Verify Theme class construction
+   - Test THEME_REGISTRY lookup (valid and invalid IDs)
+   - Confirm gradient lists have correct length (12)
+
+2. **Integration tests** (`tests/test_render.py`):
+   - Mock `config.ACTIVE_THEME` to each theme
+   - Verify `lr_gradient()` uses correct colors
+   - Verify fallback works when `ACTIVE_THEME` is None
+
+3. **Existing tests:**
+   - Render tests that check gradient output will need to mock `config.ACTIVE_THEME`
+   - Use pytest fixtures to set theme per test case
+
+---
+
+## Files Changed
+- `engine/themes.py` (new)
+- `engine/config.py` (add `ACTIVE_THEME`, `set_active_theme()`)
+- `engine/render.py` (replace GRAD_COLS/MSG_GRAD_COLS references with config lookups)
+- `engine/app.py` (add `pick_color_theme()`, call in main)
+- `tests/test_themes.py` (new unit tests)
+- `tests/test_render.py` (update mocking strategy)
+
+## Acceptance Criteria
+1. ✓ Color picker displays 3 theme options at startup
+2. ✓ Selection applies to all headline and message gradients
+3. ✓ Boot UI (title, status) uses hardcoded green (not theme)
+4. ✓ Scrolling headlines and ntfy messages use theme gradients
+5. ✓ No persistence between runs
+6. ✓ Non-TTY environments default to green without error
+7. ✓ Architecture supports future random/animation modes
+8. ✓ All gradient color codes finalized with no TBD values

effects_plugins/__init__.py

@@ -28,8 +28,6 @@ def discover_plugins():
                     and attr_name.endswith("Effect")
                 ):
                     plugin = attr()
-                    if not isinstance(plugin, EffectPlugin):
-                        continue
                     registry.register(plugin)
                     imported[plugin.name] = plugin
         except Exception:

effects_plugins/fade.py

@@ -54,5 +54,5 @@ class FadeEffect(EffectPlugin):
                 i += 1
         return "".join(result)
 
-    def configure(self, config: EffectConfig) -> None:
-        self.config = config
+    def configure(self, cfg: EffectConfig) -> None:
+        self.config = cfg

effects_plugins/firehose.py

@@ -68,5 +68,5 @@ class FirehoseEffect(EffectPlugin):
             color = random.choice([G_LO, C_DIM, W_GHOST])
             return f"{color}{text}{RST}"
 
-    def configure(self, config: EffectConfig) -> None:
-        self.config = config
+    def configure(self, cfg: EffectConfig) -> None:
+        self.config = cfg

effects_plugins/glitch.py

@@ -33,5 +33,5 @@ class GlitchEffect(EffectPlugin):
         o = random.randint(0, w - n)
         return " " * o + f"{G_LO}{DIM}" + c * n + RST
 
-    def configure(self, config: EffectConfig) -> None:
-        self.config = config
+    def configure(self, cfg: EffectConfig) -> None:
+        self.config = cfg

effects_plugins/hud.py

@@ -1,63 +0,0 @@
-from engine.effects.performance import get_monitor
-from engine.effects.types import EffectConfig, EffectContext, EffectPlugin
-
-
-class HudEffect(EffectPlugin):
-    name = "hud"
-    config = EffectConfig(enabled=True, intensity=1.0)
-
-    def process(self, buf: list[str], ctx: EffectContext) -> list[str]:
-        result = list(buf)
-        monitor = get_monitor()
-
-        fps = 0.0
-        frame_time = 0.0
-        if monitor:
-            stats = monitor.get_stats()
-            if stats and "pipeline" in stats:
-                frame_time = stats["pipeline"].get("avg_ms", 0.0)
-                frame_count = stats.get("frame_count", 0)
-                if frame_count > 0 and frame_time > 0:
-                    fps = 1000.0 / frame_time
-
-        w = ctx.terminal_width
-        h = ctx.terminal_height
-
-        effect_name = self.config.params.get("display_effect", "none")
-        effect_intensity = self.config.params.get("display_intensity", 0.0)
-
-        hud_lines = []
-        hud_lines.append(
-            f"\033[1;1H\033[38;5;46mMAINLINE DEMO\033[0m \033[38;5;245m|\033[0m \033[38;5;39mFPS: {fps:.1f}\033[0m \033[38;5;245m|\033[0m \033[38;5;208m{frame_time:.1f}ms\033[0m"
-        )
-
-        bar_width = 20
-        filled = int(bar_width * effect_intensity)
-        bar = (
-            "\033[38;5;82m"
-            + "█" * filled
-            + "\033[38;5;240m"
-            + "░" * (bar_width - filled)
-            + "\033[0m"
-        )
-        hud_lines.append(
-            f"\033[2;1H\033[38;5;45mEFFECT:\033[0m \033[1;38;5;227m{effect_name:12s}\033[0m \033[38;5;245m|\033[0m {bar} \033[38;5;245m|\033[0m \033[38;5;219m{effect_intensity * 100:.0f}%\033[0m"
-        )
-
-        from engine.effects import get_effect_chain
-
-        chain = get_effect_chain()
-        order = chain.get_order()
-        pipeline_str = ",".join(order) if order else "(none)"
-        hud_lines.append(f"\033[3;1H\033[38;5;44mPIPELINE:\033[0m {pipeline_str}")
-
-        for i, line in enumerate(hud_lines):
-            if i < len(result):
-                result[i] = line + result[i][len(line) :]
-            else:
-                result.append(line)
-
-        return result
-
-    def configure(self, config: EffectConfig) -> None:
-        self.config = config

effects_plugins/noise.py

@@ -32,5 +32,5 @@ class NoiseEffect(EffectPlugin):
             for _ in range(w)
         )
 
-    def configure(self, config: EffectConfig) -> None:
-        self.config = config
+    def configure(self, cfg: EffectConfig) -> None:
+        self.config = cfg

engine/app.py

@@ -10,9 +10,11 @@ import termios
 import time
 import tty
 
-from engine import config, render
-from engine.controller import StreamController
+from engine import config, render, themes
 from engine.fetch import fetch_all, fetch_poetry, load_cache, save_cache
+from engine.mic import MicMonitor
+from engine.ntfy import NtfyPoller
+from engine.scroll import stream
 from engine.terminal import (
     CLR,
     CURSOR_OFF,
@@ -63,6 +65,30 @@ def _read_picker_key():
     return None
 
 
+def _draw_color_picker(themes_list, selected):
+    """Draw the color theme picker menu.
+
+    Args:
+        themes_list: List of (theme_id, Theme) tuples from THEME_REGISTRY.items()
+        selected: Index of currently selected theme (0-2)
+    """
+    print(CLR, end="")
+    print()
+
+    print(
+        f"  {G_HI}▼ COLOR THEME{RST} {W_GHOST}─ ↑/↓ or j/k to move, Enter/q to select{RST}"
+    )
+    print(f"  {W_GHOST}{'─' * (tw() - 4)}{RST}\n")
+
+    for i, (theme_id, theme) in enumerate(themes_list):
+        prefix = "  ▶ " if i == selected else "    "
+        color = G_HI if i == selected else ""
+        reset = "" if i == selected else W_GHOST
+        print(f"{prefix}{color}{theme.name}{reset}")
+
+    print()
+
+
 def _normalize_preview_rows(rows):
     """Trim shared left padding and trailing spaces for stable on-screen previews."""
     non_empty = [r for r in rows if r.strip()]
@@ -129,6 +155,50 @@ def _draw_font_picker(faces, selected):
         print(f"    {shown}")
 
 
+def pick_color_theme():
+    """Interactive color theme picker. Defaults to 'green' if not TTY.
+
+    Displays a menu of available themes and lets user select with arrow keys.
+    Non-interactive environments (piped stdin, CI) silently default to green.
+    """
+    # Non-interactive fallback
+    if not sys.stdin.isatty():
+        config.set_active_theme("green")
+        return
+
+    # Interactive picker
+    themes_list = list(themes.THEME_REGISTRY.items())
+    selected = 0
+
+    fd = sys.stdin.fileno()
+    old_settings = termios.tcgetattr(fd)
+    try:
+        tty.setcbreak(fd)
+        while True:
+            _draw_color_picker(themes_list, selected)
+            key = _read_picker_key()
+            if key == "up":
+                selected = max(0, selected - 1)
+            elif key == "down":
+                selected = min(len(themes_list) - 1, selected + 1)
+            elif key == "enter":
+                break
+            elif key == "interrupt":
+                raise KeyboardInterrupt
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+
+    selected_theme_id = themes_list[selected][0]
+    config.set_active_theme(selected_theme_id)
+
+    theme_name = themes_list[selected][1].name
+    print(f"  {G_DIM}> using {theme_name}{RST}")
+    time.sleep(0.8)
+    print(CLR, end="")
+    print(CURSOR_OFF, end="")
+    print()
+
+
 def pick_font_face():
     """Interactive startup picker for selecting a face from repo OTF files."""
     if not config.FONT_PICKER:
@@ -247,474 +317,7 @@ def pick_font_face():
     print()
 
 
-def pick_effects_config():
-    """Interactive picker for configuring effects pipeline."""
-    import effects_plugins
-    from engine.effects import get_effect_chain, get_registry
-
-    effects_plugins.discover_plugins()
-
-    registry = get_registry()
-    chain = get_effect_chain()
-    chain.set_order(["noise", "fade", "glitch", "firehose"])
-
-    effects = list(registry.list_all().values())
-    if not effects:
-        return
-
-    selected = 0
-    editing_intensity = False
-    intensity_value = 1.0
-
-    def _draw_effects_picker():
-        w = tw()
-        print(CLR, end="")
-        print("\033[1;1H", end="")
-        print("  \033[1;38;5;231mEFFECTS CONFIG\033[0m")
-        print(f"  \033[2;38;5;37m{'─' * (w - 4)}\033[0m")
-        print()
-
-        for i, effect in enumerate(effects):
-            prefix = " > " if i == selected else "   "
-            marker = "[*]" if effect.config.enabled else "[ ]"
-            if editing_intensity and i == selected:
-                print(
-                    f"{prefix}{marker} \033[1;38;5;82m{effect.name}\033[0m: intensity={intensity_value:.2f} (use +/- to adjust, Enter to confirm)"
-                )
-            else:
-                print(
-                    f"{prefix}{marker} {effect.name}: intensity={effect.config.intensity:.2f}"
-                )
-
-        print()
-        print(f"  \033[2;38;5;37m{'─' * (w - 4)}\033[0m")
-        print(
-            "  \033[38;5;245mControls: space=toggle on/off | +/-=adjust intensity | arrows=move | Enter=next effect | q=done\033[0m"
-        )
-
-    def _read_effects_key():
-        ch = sys.stdin.read(1)
-        if ch == "\x03":
-            return "interrupt"
-        if ch in ("\r", "\n"):
-            return "enter"
-        if ch == " ":
-            return "toggle"
-        if ch == "q":
-            return "quit"
-        if ch == "+" or ch == "=":
-            return "up"
-        if ch == "-" or ch == "_":
-            return "down"
-        if ch == "\x1b":
-            c1 = sys.stdin.read(1)
-            if c1 != "[":
-                return None
-            c2 = sys.stdin.read(1)
-            if c2 == "A":
-                return "up"
-            if c2 == "B":
-                return "down"
-            return None
-        return None
-
-    if not sys.stdin.isatty():
-        return
-
-    fd = sys.stdin.fileno()
-    old_settings = termios.tcgetattr(fd)
-    try:
-        tty.setcbreak(fd)
-        while True:
-            _draw_effects_picker()
-            key = _read_effects_key()
-
-            if key == "quit" or key == "enter":
-                break
-            elif key == "up" and editing_intensity:
-                intensity_value = min(1.0, intensity_value + 0.1)
-                effects[selected].config.intensity = intensity_value
-            elif key == "down" and editing_intensity:
-                intensity_value = max(0.0, intensity_value - 0.1)
-                effects[selected].config.intensity = intensity_value
-            elif key == "up":
-                selected = max(0, selected - 1)
-                intensity_value = effects[selected].config.intensity
-            elif key == "down":
-                selected = min(len(effects) - 1, selected + 1)
-                intensity_value = effects[selected].config.intensity
-            elif key == "toggle":
-                effects[selected].config.enabled = not effects[selected].config.enabled
-            elif key == "interrupt":
-                raise KeyboardInterrupt
-    finally:
-        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
-
-
-def run_demo_mode():
-    """Run demo mode - showcases effects and camera modes with real content."""
-    import random
-
-    from engine import config
-    from engine.camera import Camera, CameraMode
-    from engine.display import DisplayRegistry
-    from engine.effects import (
-        EffectContext,
-        PerformanceMonitor,
-        get_effect_chain,
-        get_registry,
-        set_monitor,
-    )
-    from engine.fetch import fetch_all, fetch_poetry, load_cache
-    from engine.scroll import calculate_scroll_step
-
-    print("  \033[1;38;5;46mMAINLINE DEMO MODE\033[0m")
-    print("  \033[38;5;245mInitializing...\033[0m")
-
-    import effects_plugins
-
-    effects_plugins.discover_plugins()
-
-    registry = get_registry()
-    chain = get_effect_chain()
-    chain.set_order(["noise", "fade", "glitch", "firehose", "hud"])
-
-    monitor = PerformanceMonitor()
-    set_monitor(monitor)
-    chain._monitor = monitor
-
-    display = DisplayRegistry.create("pygame")
-    if not display:
-        print("  \033[38;5;196mFailed to create pygame display\033[0m")
-        sys.exit(1)
-
-    w, h = 80, 24
-    display.init(w, h)
-    display.clear()
-
-    print("  \033[38;5;245mFetching content...\033[0m")
-
-    cached = load_cache()
-    if cached:
-        items = cached
-    elif config.MODE == "poetry":
-        items, _, _ = fetch_poetry()
-    else:
-        items, _, _ = fetch_all()
-
-    if not items:
-        print("  \033[38;5;196mNo content available\033[0m")
-        sys.exit(1)
-
-    random.shuffle(items)
-    pool = list(items)
-    seen = set()
-    active = []
-    ticker_next_y = 0
-    noise_cache = {}
-    scroll_motion_accum = 0.0
-    frame_number = 0
-
-    GAP = 3
-    scroll_step_interval = calculate_scroll_step(config.SCROLL_DUR, h)
-
-    camera = Camera.vertical(speed=1.0)
-
-    effects_to_demo = ["noise", "fade", "glitch", "firehose"]
-    effect_idx = 0
-    effect_name = effects_to_demo[effect_idx]
-    effect_start_time = time.time()
-    current_intensity = 0.0
-    ramping_up = True
-
-    camera_modes = [
-        (CameraMode.VERTICAL, "vertical"),
-        (CameraMode.HORIZONTAL, "horizontal"),
-        (CameraMode.OMNI, "omni"),
-        (CameraMode.FLOATING, "floating"),
-    ]
-    camera_mode_idx = 0
-    camera_start_time = time.time()
-
-    print("  \033[38;5;82mStarting effect & camera demo...\033[0m")
-    print("  \033[38;5;245mPress Ctrl+C to exit\033[0m\n")
-
-    try:
-        while True:
-            elapsed = time.time() - effect_start_time
-            camera_elapsed = time.time() - camera_start_time
-            duration = config.DEMO_EFFECT_DURATION
-
-            if elapsed >= duration:
-                effect_idx = (effect_idx + 1) % len(effects_to_demo)
-                effect_name = effects_to_demo[effect_idx]
-                effect_start_time = time.time()
-                elapsed = 0
-                current_intensity = 0.0
-                ramping_up = True
-
-            if camera_elapsed >= duration * 2:
-                camera_mode_idx = (camera_mode_idx + 1) % len(camera_modes)
-                mode, mode_name = camera_modes[camera_mode_idx]
-                camera = Camera(mode=mode, speed=1.0)
-                camera_start_time = time.time()
-                camera_elapsed = 0
-
-            progress = elapsed / duration
-            if ramping_up:
-                current_intensity = progress
-                if progress >= 1.0:
-                    ramping_up = False
-            else:
-                current_intensity = 1.0 - progress
-
-            for effect in registry.list_all().values():
-                if effect.name == effect_name:
-                    effect.config.enabled = True
-                    effect.config.intensity = current_intensity
-                elif effect.name not in ("hud",):
-                    effect.config.enabled = False
-
-            hud_effect = registry.get("hud")
-            if hud_effect:
-                mode_name = camera_modes[camera_mode_idx][1]
-                hud_effect.config.params["display_effect"] = (
-                    f"{effect_name} / {mode_name}"
-                )
-                hud_effect.config.params["display_intensity"] = current_intensity
-
-            scroll_motion_accum += config.FRAME_DT
-            while scroll_motion_accum >= scroll_step_interval:
-                scroll_motion_accum -= scroll_step_interval
-                camera.update(config.FRAME_DT)
-
-                while ticker_next_y < camera.y + h + 10 and len(active) < 50:
-                    from engine.effects import next_headline
-                    from engine.render import make_block
-
-                    t, src, ts = next_headline(pool, items, seen)
-                    ticker_content, hc, midx = make_block(t, src, ts, w)
-                    active.append((ticker_content, hc, ticker_next_y, midx))
-                    ticker_next_y += len(ticker_content) + GAP
-
-                active = [
-                    (c, hc, by, mi)
-                    for c, hc, by, mi in active
-                    if by + len(c) > camera.y
-                ]
-                for k in list(noise_cache):
-                    if k < camera.y:
-                        del noise_cache[k]
-
-            grad_offset = (time.time() * config.GRAD_SPEED) % 1.0
-
-            from engine.layers import render_ticker_zone
-
-            buf, noise_cache = render_ticker_zone(
-                active,
-                scroll_cam=camera.y,
-                camera_x=camera.x,
-                ticker_h=h,
-                w=w,
-                noise_cache=noise_cache,
-                grad_offset=grad_offset,
-            )
-
-            from engine.layers import render_firehose
-
-            firehose_buf = render_firehose(items, w, 0, h)
-            buf.extend(firehose_buf)
-
-            ctx = EffectContext(
-                terminal_width=w,
-                terminal_height=h,
-                scroll_cam=camera.y,
-                ticker_height=h,
-                camera_x=camera.x,
-                mic_excess=0.0,
-                grad_offset=grad_offset,
-                frame_number=frame_number,
-                has_message=False,
-                items=items,
-            )
-
-            result = chain.process(buf, ctx)
-            display.show(result)
-
-            new_w, new_h = display.get_dimensions()
-            if new_w != w or new_h != h:
-                w, h = new_w, new_h
-                scroll_step_interval = calculate_scroll_step(config.SCROLL_DUR, h)
-                active = []
-                noise_cache = {}
-
-            frame_number += 1
-            time.sleep(1 / 60)
-
-    except KeyboardInterrupt:
-        pass
-    finally:
-        display.cleanup()
-        print("\n  \033[38;5;245mDemo ended\033[0m")
-
-
-def run_pipeline_demo():
-    """Run pipeline visualization demo mode - shows ASCII pipeline animation."""
-    import time
-
-    from engine import config
-    from engine.camera import Camera, CameraMode
-    from engine.display import DisplayRegistry
-    from engine.effects import (
-        EffectContext,
-        PerformanceMonitor,
-        get_effect_chain,
-        get_registry,
-        set_monitor,
-    )
-    from engine.pipeline_viz import generate_animated_pipeline
-
-    print("  \033[1;38;5;46mMAINLINE PIPELINE DEMO\033[0m")
-    print("  \033[38;5;245mInitializing...\033[0m")
-
-    import effects_plugins
-
-    effects_plugins.discover_plugins()
-
-    registry = get_registry()
-    chain = get_effect_chain()
-    chain.set_order(["noise", "fade", "glitch", "firehose", "hud"])
-
-    monitor = PerformanceMonitor()
-    set_monitor(monitor)
-    chain._monitor = monitor
-
-    display = DisplayRegistry.create("pygame")
-    if not display:
-        print("  \033[38;5;196mFailed to create pygame display\033[0m")
-        sys.exit(1)
-
-    w, h = 80, 24
-    display.init(w, h)
-    display.clear()
-
-    camera = Camera.vertical(speed=1.0)
-
-    effects_to_demo = ["noise", "fade", "glitch", "firehose"]
-    effect_idx = 0
-    effect_name = effects_to_demo[effect_idx]
-    effect_start_time = time.time()
-    current_intensity = 0.0
-    ramping_up = True
-
-    camera_modes = [
-        (CameraMode.VERTICAL, "vertical"),
-        (CameraMode.HORIZONTAL, "horizontal"),
-        (CameraMode.OMNI, "omni"),
-        (CameraMode.FLOATING, "floating"),
-    ]
-    camera_mode_idx = 0
-    camera_start_time = time.time()
-
-    frame_number = 0
-
-    print("  \033[38;5;82mStarting pipeline visualization...\033[0m")
-    print("  \033[38;5;245mPress Ctrl+C to exit\033[0m\n")
-
-    try:
-        while True:
-            elapsed = time.time() - effect_start_time
-            camera_elapsed = time.time() - camera_start_time
-            duration = config.DEMO_EFFECT_DURATION
-
-            if elapsed >= duration:
-                effect_idx = (effect_idx + 1) % len(effects_to_demo)
-                effect_name = effects_to_demo[effect_idx]
-                effect_start_time = time.time()
-                elapsed = 0
-                current_intensity = 0.0
-                ramping_up = True
-
-            if camera_elapsed >= duration * 2:
-                camera_mode_idx = (camera_mode_idx + 1) % len(camera_modes)
-                mode, mode_name = camera_modes[camera_mode_idx]
-                camera = Camera(mode=mode, speed=1.0)
-                camera_start_time = time.time()
-                camera_elapsed = 0
-
-            progress = elapsed / duration
-            if ramping_up:
-                current_intensity = progress
-                if progress >= 1.0:
-                    ramping_up = False
-            else:
-                current_intensity = 1.0 - progress
-
-            for effect in registry.list_all().values():
-                if effect.name == effect_name:
-                    effect.config.enabled = True
-                    effect.config.intensity = current_intensity
-                elif effect.name not in ("hud",):
-                    effect.config.enabled = False
-
-            hud_effect = registry.get("hud")
-            if hud_effect:
-                mode_name = camera_modes[camera_mode_idx][1]
-                hud_effect.config.params["display_effect"] = (
-                    f"{effect_name} / {mode_name}"
-                )
-                hud_effect.config.params["display_intensity"] = current_intensity
-
-            camera.update(config.FRAME_DT)
-
-            buf = generate_animated_pipeline(w, frame_number)
-
-            ctx = EffectContext(
-                terminal_width=w,
-                terminal_height=h,
-                scroll_cam=camera.y,
-                ticker_height=h,
-                camera_x=camera.x,
-                mic_excess=0.0,
-                grad_offset=0.0,
-                frame_number=frame_number,
-                has_message=False,
-                items=[],
-            )
-
-            result = chain.process(buf, ctx)
-            display.show(result)
-
-            new_w, new_h = display.get_dimensions()
-            if new_w != w or new_h != h:
-                w, h = new_w, new_h
-
-            frame_number += 1
-            time.sleep(1 / 60)
-
-    except KeyboardInterrupt:
-        pass
-    finally:
-        display.cleanup()
-        print("\n  \033[38;5;245mPipeline demo ended\033[0m")
-
-
 def main():
-    from engine import config
-    from engine.pipeline import generate_pipeline_diagram
-
-    if config.PIPELINE_DIAGRAM:
-        print(generate_pipeline_diagram())
-        return
-
-    if config.PIPELINE_DEMO:
-        run_pipeline_demo()
-        return
-
-    if config.DEMO:
-        run_demo_mode()
-        return
-
     atexit.register(lambda: print(CURSOR_ON, end="", flush=True))
 
     def handle_sigint(*_):
@@ -724,13 +327,11 @@ def main():
 
     signal.signal(signal.SIGINT, handle_sigint)
 
-    StreamController.warmup_topics()
-
     w = tw()
     print(CLR, end="")
     print(CURSOR_OFF, end="")
+    pick_color_theme()
     pick_font_face()
-    pick_effects_config()
     w = tw()
     print()
     time.sleep(0.4)
@@ -740,11 +341,10 @@ def main():
         time.sleep(0.07)
 
     print()
-    _subtitle = (
-        "literary consciousness stream"
-        if config.MODE == "poetry"
-        else "digital consciousness stream"
-    )
+    _subtitle = {
+        "poetry": "literary consciousness stream",
+        "code": "source consciousness stream",
+    }.get(config.MODE, "digital consciousness stream")
     print(f"  {W_DIM}v0.1 · {_subtitle}{RST}")
     print(f"  {W_GHOST}{'─' * (w - 4)}{RST}")
     print()
@@ -765,6 +365,15 @@ def main():
         )
         print(f"  {G_DIM}>{RST} {G_MID}{len(items)} STANZAS ACQUIRED{RST}")
         save_cache(items)
+    elif config.MODE == "code":
+        from engine.fetch_code import fetch_code
+
+        slow_print("  > INITIALIZING SOURCE ARRAY...\n")
+        time.sleep(0.2)
+        print()
+        items, line_count, _ = fetch_code()
+        print()
+        print(f"  {G_DIM}>{RST} {G_MID}{line_count} LINES ACQUIRED{RST}")
     else:
         slow_print("  > INITIALIZING FEED ARRAY...\n")
         time.sleep(0.2)
@@ -782,10 +391,9 @@ def main():
         sys.exit(1)
 
     print()
-    controller = StreamController()
-    mic_ok, ntfy_ok = controller.initialize_sources()
-
-    if controller.mic and controller.mic.available:
+    mic = MicMonitor(threshold_db=config.MIC_THRESHOLD_DB)
+    mic_ok = mic.start()
+    if mic.available:
         boot_ln(
             "Microphone",
             "ACTIVE"
@@ -794,6 +402,12 @@ def main():
             bool(mic_ok),
         )
 
+    ntfy = NtfyPoller(
+        config.NTFY_TOPIC,
+        reconnect_delay=config.NTFY_RECONNECT_DELAY,
+        display_secs=config.MESSAGE_DISPLAY_SECS,
+    )
+    ntfy_ok = ntfy.start()
     boot_ln("ntfy", "LISTENING" if ntfy_ok else "OFFLINE", ntfy_ok)
 
     if config.FIREHOSE:
@@ -806,7 +420,7 @@ def main():
     print()
     time.sleep(0.4)
 
-    controller.run(items)
+    stream(items, ntfy, mic)
 
     print()
     print(f"  {W_GHOST}{'─' * (tw() - 4)}{RST}")

engine/benchmark.py

@@ -1,730 +0,0 @@
-#!/usr/bin/env python3
-"""
-Benchmark runner for mainline - tests performance across effects and displays.
-
-Usage:
-    python -m engine.benchmark
-    python -m engine.benchmark --output report.md
-    python -m engine.benchmark --displays terminal,websocket --effects glitch,fade
-    python -m engine.benchmark --format json --output benchmark.json
-
-Headless mode (default): suppress all terminal output during benchmarks.
-"""
-
-import argparse
-import json
-import sys
-import time
-from dataclasses import dataclass, field
-from datetime import datetime
-from io import StringIO
-from pathlib import Path
-from typing import Any
-
-import numpy as np
-
-
-@dataclass
-class BenchmarkResult:
-    """Result of a single benchmark run."""
-
-    name: str
-    display: str
-    effect: str | None
-    iterations: int
-    total_time_ms: float
-    avg_time_ms: float
-    std_dev_ms: float
-    min_ms: float
-    max_ms: float
-    fps: float
-    chars_processed: int
-    chars_per_sec: float
-
-
-@dataclass
-class BenchmarkReport:
-    """Complete benchmark report."""
-
-    timestamp: str
-    python_version: str
-    results: list[BenchmarkResult] = field(default_factory=list)
-    summary: dict[str, Any] = field(default_factory=dict)
-
-
-def get_sample_buffer(width: int = 80, height: int = 24) -> list[str]:
-    """Generate a sample buffer for benchmarking."""
-    lines = []
-    for i in range(height):
-        line = f"\x1b[32mLine {i}\x1b[0m " + "A" * (width - 10)
-        lines.append(line)
-    return lines
-
-
-def benchmark_display(
-    display_class,
-    buffer: list[str],
-    iterations: int = 100,
-    display=None,
-    reuse: bool = False,
-) -> BenchmarkResult | None:
-    """Benchmark a single display.
-
-    Args:
-        display_class: Display class to instantiate
-        buffer: Buffer to display
-        iterations: Number of iterations
-        display: Optional existing display instance to reuse
-        reuse: If True and display provided, use reuse mode
-    """
-    old_stdout = sys.stdout
-    old_stderr = sys.stderr
-
-    try:
-        sys.stdout = StringIO()
-        sys.stderr = StringIO()
-
-        if display is None:
-            display = display_class()
-            display.init(80, 24, reuse=False)
-            should_cleanup = True
-        else:
-            should_cleanup = False
-
-        times = []
-        chars = sum(len(line) for line in buffer)
-
-        for _ in range(iterations):
-            t0 = time.perf_counter()
-            display.show(buffer)
-            elapsed = (time.perf_counter() - t0) * 1000
-            times.append(elapsed)
-
-        if should_cleanup and hasattr(display, "cleanup"):
-            display.cleanup(quit_pygame=False)
-
-    except Exception:
-        return None
-    finally:
-        sys.stdout = old_stdout
-        sys.stderr = old_stderr
-
-    times_arr = np.array(times)
-
-    return BenchmarkResult(
-        name=f"display_{display_class.__name__}",
-        display=display_class.__name__,
-        effect=None,
-        iterations=iterations,
-        total_time_ms=sum(times),
-        avg_time_ms=float(np.mean(times_arr)),
-        std_dev_ms=float(np.std(times_arr)),
-        min_ms=float(np.min(times_arr)),
-        max_ms=float(np.max(times_arr)),
-        fps=float(1000.0 / np.mean(times_arr)) if np.mean(times_arr) > 0 else 0.0,
-        chars_processed=chars * iterations,
-        chars_per_sec=float((chars * iterations) / (sum(times) / 1000))
-        if sum(times) > 0
-        else 0.0,
-    )
-
-
-def benchmark_effect_with_display(
-    effect_class, display, buffer: list[str], iterations: int = 100, reuse: bool = False
-) -> BenchmarkResult | None:
-    """Benchmark an effect with a display.
-
-    Args:
-        effect_class: Effect class to instantiate
-        display: Display instance to use
-        buffer: Buffer to process and display
-        iterations: Number of iterations
-        reuse: If True, use reuse mode for display
-    """
-    old_stdout = sys.stdout
-    old_stderr = sys.stderr
-
-    try:
-        from engine.effects.types import EffectConfig, EffectContext
-
-        sys.stdout = StringIO()
-        sys.stderr = StringIO()
-
-        effect = effect_class()
-        effect.configure(EffectConfig(enabled=True, intensity=1.0))
-
-        ctx = EffectContext(
-            terminal_width=80,
-            terminal_height=24,
-            scroll_cam=0,
-            ticker_height=0,
-            mic_excess=0.0,
-            grad_offset=0.0,
-            frame_number=0,
-            has_message=False,
-        )
-
-        times = []
-        chars = sum(len(line) for line in buffer)
-
-        for _ in range(iterations):
-            processed = effect.process(buffer, ctx)
-            t0 = time.perf_counter()
-            display.show(processed)
-            elapsed = (time.perf_counter() - t0) * 1000
-            times.append(elapsed)
-
-        if not reuse and hasattr(display, "cleanup"):
-            display.cleanup(quit_pygame=False)
-
-    except Exception:
-        return None
-    finally:
-        sys.stdout = old_stdout
-        sys.stderr = old_stderr
-
-    times_arr = np.array(times)
-
-    return BenchmarkResult(
-        name=f"effect_{effect_class.__name__}_with_{display.__class__.__name__}",
-        display=display.__class__.__name__,
-        effect=effect_class.__name__,
-        iterations=iterations,
-        total_time_ms=sum(times),
-        avg_time_ms=float(np.mean(times_arr)),
-        std_dev_ms=float(np.std(times_arr)),
-        min_ms=float(np.min(times_arr)),
-        max_ms=float(np.max(times_arr)),
-        fps=float(1000.0 / np.mean(times_arr)) if np.mean(times_arr) > 0 else 0.0,
-        chars_processed=chars * iterations,
-        chars_per_sec=float((chars * iterations) / (sum(times) / 1000))
-        if sum(times) > 0
-        else 0.0,
-    )
-
-
-def get_available_displays():
-    """Get available display classes."""
-    from engine.display import (
-        DisplayRegistry,
-        NullDisplay,
-        TerminalDisplay,
-    )
-
-    DisplayRegistry.initialize()
-
-    displays = [
-        ("null", NullDisplay),
-        ("terminal", TerminalDisplay),
-    ]
-
-    try:
-        from engine.display.backends.websocket import WebSocketDisplay
-
-        displays.append(("websocket", WebSocketDisplay))
-    except Exception:
-        pass
-
-    try:
-        from engine.display.backends.sixel import SixelDisplay
-
-        displays.append(("sixel", SixelDisplay))
-    except Exception:
-        pass
-
-    try:
-        from engine.display.backends.pygame import PygameDisplay
-
-        displays.append(("pygame", PygameDisplay))
-    except Exception:
-        pass
-
-    return displays
-
-
-def get_available_effects():
-    """Get available effect classes."""
-    try:
-        from engine.effects import get_registry
-
-        try:
-            from effects_plugins import discover_plugins
-
-            discover_plugins()
-        except Exception:
-            pass
-    except Exception:
-        return []
-
-    effects = []
-    registry = get_registry()
-
-    for name, effect in registry.list_all().items():
-        if effect:
-            effect_cls = type(effect)
-            effects.append((name, effect_cls))
-
-    return effects
-
-
-def run_benchmarks(
-    displays: list[tuple[str, Any]] | None = None,
-    effects: list[tuple[str, Any]] | None = None,
-    iterations: int = 100,
-    verbose: bool = False,
-) -> BenchmarkReport:
-    """Run all benchmarks and return report."""
-    from datetime import datetime
-
-    if displays is None:
-        displays = get_available_displays()
-
-    if effects is None:
-        effects = get_available_effects()
-
-    buffer = get_sample_buffer(80, 24)
-    results = []
-
-    if verbose:
-        print(f"Running benchmarks ({iterations} iterations each)...")
-
-    pygame_display = None
-    for name, display_class in displays:
-        if verbose:
-            print(f"Benchmarking display: {name}")
-
-        result = benchmark_display(display_class, buffer, iterations)
-        if result:
-            results.append(result)
-            if verbose:
-                print(f"  {result.fps:.1f} FPS, {result.avg_time_ms:.2f}ms avg")
-
-        if name == "pygame":
-            pygame_display = result
-
-    if verbose:
-        print()
-
-    pygame_instance = None
-    if pygame_display:
-        try:
-            from engine.display.backends.pygame import PygameDisplay
-
-            PygameDisplay.reset_state()
-            pygame_instance = PygameDisplay()
-            pygame_instance.init(80, 24, reuse=False)
-        except Exception:
-            pygame_instance = None
-
-    for effect_name, effect_class in effects:
-        for display_name, display_class in displays:
-            if display_name == "websocket":
-                continue
-
-            if display_name == "pygame":
-                if verbose:
-                    print(f"Benchmarking effect: {effect_name} with {display_name}")
-
-                if pygame_instance:
-                    result = benchmark_effect_with_display(
-                        effect_class, pygame_instance, buffer, iterations, reuse=True
-                    )
-                    if result:
-                        results.append(result)
-                        if verbose:
-                            print(
-                                f"  {result.fps:.1f} FPS, {result.avg_time_ms:.2f}ms avg"
-                            )
-                continue
-
-            if verbose:
-                print(f"Benchmarking effect: {effect_name} with {display_name}")
-
-            display = display_class()
-            display.init(80, 24)
-            result = benchmark_effect_with_display(
-                effect_class, display, buffer, iterations
-            )
-            if result:
-                results.append(result)
-                if verbose:
-                    print(f"  {result.fps:.1f} FPS, {result.avg_time_ms:.2f}ms avg")
-
-    if pygame_instance:
-        try:
-            pygame_instance.cleanup(quit_pygame=True)
-        except Exception:
-            pass
-
-    summary = generate_summary(results)
-
-    return BenchmarkReport(
-        timestamp=datetime.now().isoformat(),
-        python_version=sys.version,
-        results=results,
-        summary=summary,
-    )
-
-
-def generate_summary(results: list[BenchmarkResult]) -> dict[str, Any]:
-    """Generate summary statistics from results."""
-    by_display: dict[str, list[BenchmarkResult]] = {}
-    by_effect: dict[str, list[BenchmarkResult]] = {}
-
-    for r in results:
-        if r.display not in by_display:
-            by_display[r.display] = []
-        by_display[r.display].append(r)
-
-        if r.effect:
-            if r.effect not in by_effect:
-                by_effect[r.effect] = []
-            by_effect[r.effect].append(r)
-
-    summary = {
-        "by_display": {},
-        "by_effect": {},
-        "overall": {
-            "total_tests": len(results),
-            "displays_tested": len(by_display),
-            "effects_tested": len(by_effect),
-        },
-    }
-
-    for display, res in by_display.items():
-        fps_values = [r.fps for r in res]
-        summary["by_display"][display] = {
-            "avg_fps": float(np.mean(fps_values)),
-            "min_fps": float(np.min(fps_values)),
-            "max_fps": float(np.max(fps_values)),
-            "tests": len(res),
-        }
-
-    for effect, res in by_effect.items():
-        fps_values = [r.fps for r in res]
-        summary["by_effect"][effect] = {
-            "avg_fps": float(np.mean(fps_values)),
-            "min_fps": float(np.min(fps_values)),
-            "max_fps": float(np.max(fps_values)),
-            "tests": len(res),
-        }
-
-    return summary
-
-
-DEFAULT_CACHE_PATH = Path.home() / ".mainline_benchmark_cache.json"
-
-
-def load_baseline(cache_path: Path | None = None) -> dict[str, Any] | None:
-    """Load baseline benchmark results from cache."""
-    path = cache_path or DEFAULT_CACHE_PATH
-    if not path.exists():
-        return None
-    try:
-        with open(path) as f:
-            return json.load(f)
-    except Exception:
-        return None
-
-
-def save_baseline(
-    results: list[BenchmarkResult],
-    cache_path: Path | None = None,
-) -> None:
-    """Save benchmark results as baseline to cache."""
-    path = cache_path or DEFAULT_CACHE_PATH
-    baseline = {
-        "timestamp": datetime.now().isoformat(),
-        "results": {
-            r.name: {
-                "fps": r.fps,
-                "avg_time_ms": r.avg_time_ms,
-                "chars_per_sec": r.chars_per_sec,
-            }
-            for r in results
-        },
-    }
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with open(path, "w") as f:
-        json.dump(baseline, f, indent=2)
-
-
-def compare_with_baseline(
-    results: list[BenchmarkResult],
-    baseline: dict[str, Any],
-    threshold: float = 0.2,
-    verbose: bool = True,
-) -> tuple[bool, list[str]]:
-    """Compare current results with baseline. Returns (pass, messages)."""
-    baseline_results = baseline.get("results", {})
-    failures = []
-    warnings = []
-
-    for r in results:
-        if r.name not in baseline_results:
-            warnings.append(f"New test: {r.name} (no baseline)")
-            continue
-
-        b = baseline_results[r.name]
-        if b["fps"] == 0:
-            continue
-
-        degradation = (b["fps"] - r.fps) / b["fps"]
-        if degradation > threshold:
-            failures.append(
-                f"{r.name}: FPS degraded {degradation * 100:.1f}% "
-                f"(baseline: {b['fps']:.1f}, current: {r.fps:.1f})"
-            )
-        elif verbose:
-            print(f"  {r.name}: {r.fps:.1f} FPS (baseline: {b['fps']:.1f})")
-
-    passed = len(failures) == 0
-    messages = []
-    if failures:
-        messages.extend(failures)
-    if warnings:
-        messages.extend(warnings)
-
-    return passed, messages
-
-
-def run_hook_mode(
-    displays: list[tuple[str, Any]] | None = None,
-    effects: list[tuple[str, Any]] | None = None,
-    iterations: int = 20,
-    threshold: float = 0.2,
-    cache_path: Path | None = None,
-    verbose: bool = False,
-) -> int:
-    """Run in hook mode: compare against baseline, exit 0 on pass, 1 on fail."""
-    baseline = load_baseline(cache_path)
-
-    if baseline is None:
-        print("No baseline found. Run with --baseline to create one.")
-        return 1
-
-    report = run_benchmarks(displays, effects, iterations, verbose)
-
-    passed, messages = compare_with_baseline(
-        report.results, baseline, threshold, verbose
-    )
-
-    print("\n=== Benchmark Hook Results ===")
-    if passed:
-        print("PASSED - No significant performance degradation")
-        return 0
-    else:
-        print("FAILED - Performance degradation detected:")
-        for msg in messages:
-            print(f"  - {msg}")
-        return 1
-
-
-def format_report_text(report: BenchmarkReport) -> str:
-    """Format report as human-readable text."""
-    lines = [
-        "# Mainline Performance Benchmark Report",
-        "",
-        f"Generated: {report.timestamp}",
-        f"Python: {report.python_version}",
-        "",
-        "## Summary",
-        "",
-        f"Total tests: {report.summary['overall']['total_tests']}",
-        f"Displays tested: {report.summary['overall']['displays_tested']}",
-        f"Effects tested: {report.summary['overall']['effects_tested']}",
-        "",
-        "## By Display",
-        "",
-    ]
-
-    for display, stats in report.summary["by_display"].items():
-        lines.append(f"### {display}")
-        lines.append(f"- Avg FPS: {stats['avg_fps']:.1f}")
-        lines.append(f"- Min FPS: {stats['min_fps']:.1f}")
-        lines.append(f"- Max FPS: {stats['max_fps']:.1f}")
-        lines.append(f"- Tests: {stats['tests']}")
-        lines.append("")
-
-    if report.summary["by_effect"]:
-        lines.append("## By Effect")
-        lines.append("")
-
-        for effect, stats in report.summary["by_effect"].items():
-            lines.append(f"### {effect}")
-            lines.append(f"- Avg FPS: {stats['avg_fps']:.1f}")
-            lines.append(f"- Min FPS: {stats['min_fps']:.1f}")
-            lines.append(f"- Max FPS: {stats['max_fps']:.1f}")
-            lines.append(f"- Tests: {stats['tests']}")
-            lines.append("")
-
-    lines.append("## Detailed Results")
-    lines.append("")
-    lines.append("| Display | Effect | FPS | Avg ms | StdDev ms | Min ms | Max ms |")
-    lines.append("|---------|--------|-----|--------|-----------|--------|--------|")
-
-    for r in report.results:
-        effect_col = r.effect if r.effect else "-"
-        lines.append(
-            f"| {r.display} | {effect_col} | {r.fps:.1f} | {r.avg_time_ms:.2f} | "
-            f"{r.std_dev_ms:.2f} | {r.min_ms:.2f} | {r.max_ms:.2f} |"
-        )
-
-    return "\n".join(lines)
-
-
-def format_report_json(report: BenchmarkReport) -> str:
-    """Format report as JSON."""
-    data = {
-        "timestamp": report.timestamp,
-        "python_version": report.python_version,
-        "summary": report.summary,
-        "results": [
-            {
-                "name": r.name,
-                "display": r.display,
-                "effect": r.effect,
-                "iterations": r.iterations,
-                "total_time_ms": r.total_time_ms,
-                "avg_time_ms": r.avg_time_ms,
-                "std_dev_ms": r.std_dev_ms,
-                "min_ms": r.min_ms,
-                "max_ms": r.max_ms,
-                "fps": r.fps,
-                "chars_processed": r.chars_processed,
-                "chars_per_sec": r.chars_per_sec,
-            }
-            for r in report.results
-        ],
-    }
-    return json.dumps(data, indent=2)
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Run mainline benchmarks")
-    parser.add_argument(
-        "--displays",
-        help="Comma-separated list of displays to test (default: all)",
-    )
-    parser.add_argument(
-        "--effects",
-        help="Comma-separated list of effects to test (default: all)",
-    )
-    parser.add_argument(
-        "--iterations",
-        type=int,
-        default=100,
-        help="Number of iterations per test (default: 100)",
-    )
-    parser.add_argument(
-        "--output",
-        help="Output file path (default: stdout)",
-    )
-    parser.add_argument(
-        "--format",
-        choices=["text", "json"],
-        default="text",
-        help="Output format (default: text)",
-    )
-    parser.add_argument(
-        "--verbose",
-        "-v",
-        action="store_true",
-        help="Show progress during benchmarking",
-    )
-    parser.add_argument(
-        "--hook",
-        action="store_true",
-        help="Run in hook mode: compare against baseline, exit 0 pass, 1 fail",
-    )
-    parser.add_argument(
-        "--baseline",
-        action="store_true",
-        help="Save current results as baseline for future hook comparisons",
-    )
-    parser.add_argument(
-        "--threshold",
-        type=float,
-        default=0.2,
-        help="Performance degradation threshold for hook mode (default: 0.2 = 20%%)",
-    )
-    parser.add_argument(
-        "--cache",
-        type=str,
-        default=None,
-        help="Path to baseline cache file (default: ~/.mainline_benchmark_cache.json)",
-    )
-
-    args = parser.parse_args()
-
-    cache_path = Path(args.cache) if args.cache else DEFAULT_CACHE_PATH
-
-    if args.hook:
-        displays = None
-        if args.displays:
-            display_map = dict(get_available_displays())
-            displays = [
-                (name, display_map[name])
-                for name in args.displays.split(",")
-                if name in display_map
-            ]
-
-        effects = None
-        if args.effects:
-            effect_map = dict(get_available_effects())
-            effects = [
-                (name, effect_map[name])
-                for name in args.effects.split(",")
-                if name in effect_map
-            ]
-
-        return run_hook_mode(
-            displays,
-            effects,
-            iterations=args.iterations,
-            threshold=args.threshold,
-            cache_path=cache_path,
-            verbose=args.verbose,
-        )
-
-    displays = None
-    if args.displays:
-        display_map = dict(get_available_displays())
-        displays = [
-            (name, display_map[name])
-            for name in args.displays.split(",")
-            if name in display_map
-        ]
-
-    effects = None
-    if args.effects:
-        effect_map = dict(get_available_effects())
-        effects = [
-            (name, effect_map[name])
-            for name in args.effects.split(",")
-            if name in effect_map
-        ]
-
-    report = run_benchmarks(displays, effects, args.iterations, args.verbose)
-
-    if args.baseline:
-        save_baseline(report.results, cache_path)
-        print(f"Baseline saved to {cache_path}")
-        return 0
-
-    if args.format == "json":
-        output = format_report_json(report)
-    else:
-        output = format_report_text(report)
-
-    if args.output:
-        with open(args.output, "w") as f:
-            f.write(output)
-    else:
-        print(output)
-
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

engine/camera.py

@@ -1,109 +0,0 @@
-"""
-Camera system for viewport scrolling.
-
-Provides abstraction for camera motion in different modes:
-- Vertical: traditional upward scroll
-- Horizontal: left/right movement
-- Omni: combination of both
-- Floating: sinusoidal/bobbing motion
-"""
-
-import math
-from collections.abc import Callable
-from dataclasses import dataclass, field
-from enum import Enum, auto
-
-
-class CameraMode(Enum):
-    VERTICAL = auto()
-    HORIZONTAL = auto()
-    OMNI = auto()
-    FLOATING = auto()
-
-
-@dataclass
-class Camera:
-    """Camera for viewport scrolling.
-
-    Attributes:
-        x: Current horizontal offset (positive = scroll left)
-        y: Current vertical offset (positive = scroll up)
-        mode: Current camera mode
-        speed: Base scroll speed
-        custom_update: Optional custom update function
-    """
-
-    x: int = 0
-    y: int = 0
-    mode: CameraMode = CameraMode.VERTICAL
-    speed: float = 1.0
-    custom_update: Callable[["Camera", float], None] | None = None
-    _time: float = field(default=0.0, repr=False)
-
-    def update(self, dt: float) -> None:
-        """Update camera position based on mode.
-
-        Args:
-            dt: Delta time in seconds
-        """
-        self._time += dt
-
-        if self.custom_update:
-            self.custom_update(self, dt)
-            return
-
-        if self.mode == CameraMode.VERTICAL:
-            self._update_vertical(dt)
-        elif self.mode == CameraMode.HORIZONTAL:
-            self._update_horizontal(dt)
-        elif self.mode == CameraMode.OMNI:
-            self._update_omni(dt)
-        elif self.mode == CameraMode.FLOATING:
-            self._update_floating(dt)
-
-    def _update_vertical(self, dt: float) -> None:
-        self.y += int(self.speed * dt * 60)
-
-    def _update_horizontal(self, dt: float) -> None:
-        self.x += int(self.speed * dt * 60)
-
-    def _update_omni(self, dt: float) -> None:
-        speed = self.speed * dt * 60
-        self.y += int(speed)
-        self.x += int(speed * 0.5)
-
-    def _update_floating(self, dt: float) -> None:
-        base = self.speed * 30
-        self.y = int(math.sin(self._time * 2) * base)
-        self.x = int(math.cos(self._time * 1.5) * base * 0.5)
-
-    def reset(self) -> None:
-        """Reset camera position."""
-        self.x = 0
-        self.y = 0
-        self._time = 0.0
-
-    @classmethod
-    def vertical(cls, speed: float = 1.0) -> "Camera":
-        """Create a vertical scrolling camera."""
-        return cls(mode=CameraMode.VERTICAL, speed=speed)
-
-    @classmethod
-    def horizontal(cls, speed: float = 1.0) -> "Camera":
-        """Create a horizontal scrolling camera."""
-        return cls(mode=CameraMode.HORIZONTAL, speed=speed)
-
-    @classmethod
-    def omni(cls, speed: float = 1.0) -> "Camera":
-        """Create an omnidirectional scrolling camera."""
-        return cls(mode=CameraMode.OMNI, speed=speed)
-
-    @classmethod
-    def floating(cls, speed: float = 1.0) -> "Camera":
-        """Create a floating/bobbing camera."""
-        return cls(mode=CameraMode.FLOATING, speed=speed)
-
-    @classmethod
-    def custom(cls, update_fn: Callable[["Camera", float], None]) -> "Camera":
-        """Create a camera with custom update function."""
-        return cls(custom_update=update_fn)

engine/config.py

@@ -105,8 +105,6 @@ class Config:
     firehose: bool = False
 
     ntfy_topic: str = "https://ntfy.sh/klubhaus_terminal_mainline/json"
-    ntfy_cc_cmd_topic: str = "https://ntfy.sh/klubhaus_terminal_mainline_cc_cmd/json"
-    ntfy_cc_resp_topic: str = "https://ntfy.sh/klubhaus_terminal_mainline_cc_resp/json"
     ntfy_reconnect_delay: int = 5
     message_display_secs: int = 30
 
@@ -129,10 +127,6 @@ class Config:
 
     script_fonts: dict[str, str] = field(default_factory=_get_platform_font_paths)
 
-    display: str = "terminal"
-    websocket: bool = False
-    websocket_port: int = 8765
-
     @classmethod
     def from_args(cls, argv: list[str] | None = None) -> "Config":
         """Create Config from CLI arguments (or custom argv for testing)."""
@@ -154,8 +148,6 @@ class Config:
             mode="poetry" if "--poetry" in argv or "-p" in argv else "news",
             firehose="--firehose" in argv,
             ntfy_topic="https://ntfy.sh/klubhaus_terminal_mainline/json",
-            ntfy_cc_cmd_topic="https://ntfy.sh/klubhaus_terminal_mainline_cc_cmd/json",
-            ntfy_cc_resp_topic="https://ntfy.sh/klubhaus_terminal_mainline_cc_resp/json",
             ntfy_reconnect_delay=5,
             message_display_secs=30,
             font_dir=font_dir,
@@ -172,9 +164,6 @@ class Config:
             glitch_glyphs="░▒▓█▌▐╌╍╎╏┃┆┇┊┋",
             kata_glyphs="ﾊﾐﾋｰｳｼﾅﾓﾆｻﾜﾂｵﾘｱﾎﾃﾏｹﾒｴｶｷﾑﾕﾗｾﾈｽﾀﾇﾍ",
             script_fonts=_get_platform_font_paths(),
-            display=_arg_value("--display", argv) or "terminal",
-            websocket="--websocket" in argv,
-            websocket_port=_arg_int("--websocket-port", 8765, argv),
         )
 
 
@@ -199,13 +188,17 @@ def set_config(config: Config) -> None:
 HEADLINE_LIMIT = 1000
 FEED_TIMEOUT = 10
 MIC_THRESHOLD_DB = 50  # dB above which glitches intensify
-MODE = "poetry" if "--poetry" in sys.argv or "-p" in sys.argv else "news"
+MODE = (
+    "poetry"
+    if "--poetry" in sys.argv or "-p" in sys.argv
+    else "code"
+    if "--code" in sys.argv
+    else "news"
+)
 FIREHOSE = "--firehose" in sys.argv
 
 # ─── NTFY MESSAGE QUEUE ──────────────────────────────────
 NTFY_TOPIC = "https://ntfy.sh/klubhaus_terminal_mainline/json"
-NTFY_CC_CMD_TOPIC = "https://ntfy.sh/klubhaus_terminal_mainline_cc_cmd/json"
-NTFY_CC_RESP_TOPIC = "https://ntfy.sh/klubhaus_terminal_mainline_cc_resp/json"
 NTFY_RECONNECT_DELAY = 5  # seconds before reconnecting after a dropped stream
 MESSAGE_DISPLAY_SECS = 30  # how long a message holds the screen
 
@@ -236,19 +229,6 @@ GRAD_SPEED = 0.08  # gradient traversal speed (cycles/sec, ~12s full sweep)
 GLITCH = "░▒▓█▌▐╌╍╎╏┃┆┇┊┋"
 KATA = "ﾊﾐﾋｰｳｼﾅﾓﾆｻﾜﾂｵﾘｱﾎﾃﾏｹﾒｴｶｷﾑﾕﾗｾﾈｽﾀﾇﾍ"
 
-# ─── WEBSOCKET ─────────────────────────────────────────────
-DISPLAY = _arg_value("--display", sys.argv) or "terminal"
-WEBSOCKET = "--websocket" in sys.argv
-WEBSOCKET_PORT = _arg_int("--websocket-port", 8765)
-
-# ─── DEMO MODE ────────────────────────────────────────────
-DEMO = "--demo" in sys.argv
-DEMO_EFFECT_DURATION = 5.0  # seconds per effect
-PIPELINE_DEMO = "--pipeline-demo" in sys.argv
-
-# ─── PIPELINE DIAGRAM ────────────────────────────────────
-PIPELINE_DIAGRAM = "--pipeline-diagram" in sys.argv
-
 
 def set_font_selection(font_path=None, font_index=None):
     """Set runtime primary font selection."""
@@ -257,3 +237,26 @@ def set_font_selection(font_path=None, font_index=None):
         FONT_PATH = _resolve_font_path(font_path)
     if font_index is not None:
         FONT_INDEX = max(0, int(font_index))
+
+
+# ─── THEME MANAGEMENT ─────────────────────────────────────────
+ACTIVE_THEME = None
+
+
+def set_active_theme(theme_id: str = "green"):
+    """Set the active theme by ID.
+
+    Args:
+        theme_id: Theme identifier ("green", "orange", or "purple")
+                  Defaults to "green"
+
+    Raises:
+        KeyError: If theme_id is not in the theme registry
+
+    Side Effects:
+        Sets the ACTIVE_THEME global variable
+    """
+    global ACTIVE_THEME
+    from engine import themes
+
+    ACTIVE_THEME = themes.get_theme(theme_id)

engine/controller.py

@@ -3,17 +3,6 @@ Stream controller - manages input sources and orchestrates the render stream.
 """
 
 from engine.config import Config, get_config
-from engine.display import (
-    DisplayRegistry,
-    KittyDisplay,
-    MultiDisplay,
-    NullDisplay,
-    PygameDisplay,
-    SixelDisplay,
-    TerminalDisplay,
-    WebSocketDisplay,
-)
-from engine.effects.controller import handle_effects_command
 from engine.eventbus import EventBus
 from engine.events import EventType, StreamEvent
 from engine.mic import MicMonitor
@@ -21,82 +10,14 @@ from engine.ntfy import NtfyPoller
 from engine.scroll import stream
 
 
-def _get_display(config: Config):
-    """Get the appropriate display based on config."""
-    DisplayRegistry.initialize()
-    display_mode = config.display.lower()
-
-    displays = []
-
-    if display_mode in ("terminal", "both"):
-        displays.append(TerminalDisplay())
-
-    if display_mode in ("websocket", "both"):
-        ws = WebSocketDisplay(host="0.0.0.0", port=config.websocket_port)
-        ws.start_server()
-        ws.start_http_server()
-        displays.append(ws)
-
-    if display_mode == "sixel":
-        displays.append(SixelDisplay())
-
-    if display_mode == "kitty":
-        displays.append(KittyDisplay())
-
-    if display_mode == "pygame":
-        displays.append(PygameDisplay())
-
-    if not displays:
-        return NullDisplay()
-
-    if len(displays) == 1:
-        return displays[0]
-
-    return MultiDisplay(displays)
-
-
 class StreamController:
     """Controls the stream lifecycle - initializes sources and runs the stream."""
 
-    _topics_warmed = False
-
     def __init__(self, config: Config | None = None, event_bus: EventBus | None = None):
         self.config = config or get_config()
         self.event_bus = event_bus
         self.mic: MicMonitor | None = None
         self.ntfy: NtfyPoller | None = None
-        self.ntfy_cc: NtfyPoller | None = None
-
-    @classmethod
-    def warmup_topics(cls) -> None:
-        """Warm up ntfy topics lazily (creates them if they don't exist)."""
-        if cls._topics_warmed:
-            return
-
-        import urllib.request
-
-        topics = [
-            "https://ntfy.sh/klubhaus_terminal_mainline_cc_cmd",
-            "https://ntfy.sh/klubhaus_terminal_mainline_cc_resp",
-            "https://ntfy.sh/klubhaus_terminal_mainline",
-        ]
-
-        for topic in topics:
-            try:
-                req = urllib.request.Request(
-                    topic,
-                    data=b"init",
-                    headers={
-                        "User-Agent": "mainline/0.1",
-                        "Content-Type": "text/plain",
-                    },
-                    method="POST",
-                )
-                urllib.request.urlopen(req, timeout=5)
-            except Exception:
-                pass
-
-        cls._topics_warmed = True
 
     def initialize_sources(self) -> tuple[bool, bool]:
         """Initialize microphone and ntfy sources.
@@ -114,38 +35,7 @@ class StreamController:
         )
         ntfy_ok = self.ntfy.start()
 
-        self.ntfy_cc = NtfyPoller(
-            self.config.ntfy_cc_cmd_topic,
-            reconnect_delay=self.config.ntfy_reconnect_delay,
-            display_secs=5,
-        )
-        self.ntfy_cc.subscribe(self._handle_cc_message)
-        ntfy_cc_ok = self.ntfy_cc.start()
-
-        return bool(mic_ok), ntfy_ok and ntfy_cc_ok
-
-    def _handle_cc_message(self, event) -> None:
-        """Handle incoming C&C message - like a serial port control interface."""
-        import urllib.request
-
-        cmd = event.body.strip() if hasattr(event, "body") else str(event).strip()
-        if not cmd.startswith("/"):
-            return
-
-        response = handle_effects_command(cmd)
-
-        topic_url = self.config.ntfy_cc_resp_topic.replace("/json", "")
-        data = response.encode("utf-8")
-        req = urllib.request.Request(
-            topic_url,
-            data=data,
-            headers={"User-Agent": "mainline/0.1", "Content-Type": "text/plain"},
-            method="POST",
-        )
-        try:
-            urllib.request.urlopen(req, timeout=5)
-        except Exception:
-            pass
+        return bool(mic_ok), ntfy_ok
 
     def run(self, items: list) -> None:
         """Run the stream with initialized sources."""
@@ -161,10 +51,7 @@ class StreamController:
                 ),
             )
 
-        display = _get_display(self.config)
-        stream(items, self.ntfy, self.mic, display)
-        if display:
-            display.cleanup()
+        stream(items, self.ntfy, self.mic)
 
         if self.event_bus:
             self.event_bus.publish(

engine/display.py

@@ -0,0 +1,102 @@
+"""
+Display output abstraction - allows swapping output backends.
+
+Protocol:
+    - init(width, height): Initialize display with terminal dimensions
+    - show(buffer): Render buffer (list of strings) to display
+    - clear(): Clear the display
+    - cleanup(): Shutdown display
+"""
+
+import time
+from typing import Protocol
+
+
+class Display(Protocol):
+    """Protocol for display backends."""
+
+    def init(self, width: int, height: int) -> None:
+        """Initialize display with dimensions."""
+        ...
+
+    def show(self, buffer: list[str]) -> None:
+        """Show buffer on display."""
+        ...
+
+    def clear(self) -> None:
+        """Clear display."""
+        ...
+
+    def cleanup(self) -> None:
+        """Shutdown display."""
+        ...
+
+
+def get_monitor():
+    """Get the performance monitor."""
+    try:
+        from engine.effects.performance import get_monitor as _get_monitor
+
+        return _get_monitor()
+    except Exception:
+        return None
+
+
+class TerminalDisplay:
+    """ANSI terminal display backend."""
+
+    def __init__(self):
+        self.width = 80
+        self.height = 24
+
+    def init(self, width: int, height: int) -> None:
+        from engine.terminal import CURSOR_OFF
+
+        self.width = width
+        self.height = height
+        print(CURSOR_OFF, end="", flush=True)
+
+    def show(self, buffer: list[str]) -> None:
+        import sys
+
+        t0 = time.perf_counter()
+        sys.stdout.buffer.write("".join(buffer).encode())
+        sys.stdout.flush()
+        elapsed_ms = (time.perf_counter() - t0) * 1000
+
+        monitor = get_monitor()
+        if monitor:
+            chars_in = sum(len(line) for line in buffer)
+            monitor.record_effect("terminal_display", elapsed_ms, chars_in, chars_in)
+
+    def clear(self) -> None:
+        from engine.terminal import CLR
+
+        print(CLR, end="", flush=True)
+
+    def cleanup(self) -> None:
+        from engine.terminal import CURSOR_ON
+
+        print(CURSOR_ON, end="", flush=True)
+
+
+class NullDisplay:
+    """Headless/null display - discards all output."""
+
+    def init(self, width: int, height: int) -> None:
+        self.width = width
+        self.height = height
+
+    def show(self, buffer: list[str]) -> None:
+        monitor = get_monitor()
+        if monitor:
+            t0 = time.perf_counter()
+            chars_in = sum(len(line) for line in buffer)
+            elapsed_ms = (time.perf_counter() - t0) * 1000
+            monitor.record_effect("null_display", elapsed_ms, chars_in, chars_in)
+
+    def clear(self) -> None:
+        pass
+
+    def cleanup(self) -> None:
+        pass

engine/display/__init__.py

@@ -1,124 +0,0 @@
-"""
-Display backend system with registry pattern.
-
-Allows swapping output backends via the Display protocol.
-Supports auto-discovery of display backends.
-"""
-
-from typing import Protocol
-
-from engine.display.backends.kitty import KittyDisplay
-from engine.display.backends.multi import MultiDisplay
-from engine.display.backends.null import NullDisplay
-from engine.display.backends.pygame import PygameDisplay
-from engine.display.backends.sixel import SixelDisplay
-from engine.display.backends.terminal import TerminalDisplay
-from engine.display.backends.websocket import WebSocketDisplay
-
-
-class Display(Protocol):
-    """Protocol for display backends.
-
-    All display backends must implement:
-    - width, height: Terminal dimensions
-    - init(width, height, reuse=False): Initialize the display
-    - show(buffer): Render buffer to display
-    - clear(): Clear the display
-    - cleanup(): Shutdown the display
-
-    The reuse flag allows attaching to an existing display instance
-    rather than creating a new window/connection.
-    """
-
-    width: int
-    height: int
-
-    def init(self, width: int, height: int, reuse: bool = False) -> None:
-        """Initialize display with dimensions.
-
-        Args:
-            width: Terminal width in characters
-            height: Terminal height in rows
-            reuse: If True, attach to existing display instead of creating new
-        """
-        ...
-
-    def show(self, buffer: list[str]) -> None:
-        """Show buffer on display."""
-        ...
-
-    def clear(self) -> None:
-        """Clear display."""
-        ...
-
-    def cleanup(self) -> None:
-        """Shutdown display."""
-        ...
-
-
-class DisplayRegistry:
-    """Registry for display backends with auto-discovery."""
-
-    _backends: dict[str, type[Display]] = {}
-    _initialized = False
-
-    @classmethod
-    def register(cls, name: str, backend_class: type[Display]) -> None:
-        """Register a display backend."""
-        cls._backends[name.lower()] = backend_class
-
-    @classmethod
-    def get(cls, name: str) -> type[Display] | None:
-        """Get a display backend class by name."""
-        return cls._backends.get(name.lower())
-
-    @classmethod
-    def list_backends(cls) -> list[str]:
-        """List all available display backend names."""
-        return list(cls._backends.keys())
-
-    @classmethod
-    def create(cls, name: str, **kwargs) -> Display | None:
-        """Create a display instance by name."""
-        cls.initialize()
-        backend_class = cls.get(name)
-        if backend_class:
-            return backend_class(**kwargs)
-        return None
-
-    @classmethod
-    def initialize(cls) -> None:
-        """Initialize and register all built-in backends."""
-        if cls._initialized:
-            return
-
-        cls.register("terminal", TerminalDisplay)
-        cls.register("null", NullDisplay)
-        cls.register("websocket", WebSocketDisplay)
-        cls.register("sixel", SixelDisplay)
-        cls.register("kitty", KittyDisplay)
-        cls.register("pygame", PygameDisplay)
-
-        cls._initialized = True
-
-
-def get_monitor():
-    """Get the performance monitor."""
-    try:
-        from engine.effects.performance import get_monitor as _get_monitor
-
-        return _get_monitor()
-    except Exception:
-        return None
-
-
-__all__ = [
-    "Display",
-    "DisplayRegistry",
-    "get_monitor",
-    "TerminalDisplay",
-    "NullDisplay",
-    "WebSocketDisplay",
-    "SixelDisplay",
-    "MultiDisplay",
-]

engine/display/backends/kitty.py

@@ -1,152 +0,0 @@
-"""
-Kitty graphics display backend - renders using kitty's native graphics protocol.
-"""
-
-import time
-
-from engine.display.renderer import get_default_font_path, parse_ansi
-
-
-def _encode_kitty_graphic(image_data: bytes, width: int, height: int) -> bytes:
-    """Encode image data using kitty's graphics protocol."""
-    import base64
-
-    encoded = base64.b64encode(image_data).decode("ascii")
-
-    chunks = []
-    for i in range(0, len(encoded), 4096):
-        chunk = encoded[i : i + 4096]
-        if i == 0:
-            chunks.append(f"\x1b_Gf=100,t=d,s={width},v={height},c=1,r=1;{chunk}\x1b\\")
-        else:
-            chunks.append(f"\x1b_Gm={height};{chunk}\x1b\\")
-
-    return "".join(chunks).encode("utf-8")
-
-
-class KittyDisplay:
-    """Kitty graphics display backend using kitty's native protocol."""
-
-    width: int = 80
-    height: int = 24
-
-    def __init__(self, cell_width: int = 9, cell_height: int = 16):
-        self.width = 80
-        self.height = 24
-        self.cell_width = cell_width
-        self.cell_height = cell_height
-        self._initialized = False
-        self._font_path = None
-
-    def init(self, width: int, height: int, reuse: bool = False) -> None:
-        """Initialize display with dimensions.
-
-        Args:
-            width: Terminal width in characters
-            height: Terminal height in rows
-            reuse: Ignored for KittyDisplay (protocol doesn't support reuse)
-        """
-        self.width = width
-        self.height = height
-        self._initialized = True
-
-    def _get_font_path(self) -> str | None:
-        """Get font path from env or detect common locations."""
-        import os
-
-        if self._font_path:
-            return self._font_path
-
-        env_font = os.environ.get("MAINLINE_KITTY_FONT")
-        if env_font and os.path.exists(env_font):
-            self._font_path = env_font
-            return env_font
-
-        font_path = get_default_font_path()
-        if font_path:
-            self._font_path = font_path
-
-        return self._font_path
-
-    def show(self, buffer: list[str]) -> None:
-        import sys
-
-        t0 = time.perf_counter()
-
-        img_width = self.width * self.cell_width
-        img_height = self.height * self.cell_height
-
-        try:
-            from PIL import Image, ImageDraw, ImageFont
-        except ImportError:
-            return
-
-        img = Image.new("RGBA", (img_width, img_height), (0, 0, 0, 255))
-        draw = ImageDraw.Draw(img)
-
-        font_path = self._get_font_path()
-        font = None
-        if font_path:
-            try:
-                font = ImageFont.truetype(font_path, self.cell_height - 2)
-            except Exception:
-                font = None
-
-        if font is None:
-            try:
-                font = ImageFont.load_default()
-            except Exception:
-                font = None
-
-        for row_idx, line in enumerate(buffer[: self.height]):
-            if row_idx >= self.height:
-                break
-
-            tokens = parse_ansi(line)
-            x_pos = 0
-            y_pos = row_idx * self.cell_height
-
-            for text, fg, bg, bold in tokens:
-                if not text:
-                    continue
-
-                if bg != (0, 0, 0):
-                    bbox = draw.textbbox((x_pos, y_pos), text, font=font)
-                    draw.rectangle(bbox, fill=(*bg, 255))
-
-                if bold and font:
-                    draw.text((x_pos - 1, y_pos - 1), text, fill=(*fg, 255), font=font)
-
-                draw.text((x_pos, y_pos), text, fill=(*fg, 255), font=font)
-
-                if font:
-                    x_pos += draw.textlength(text, font=font)
-
-        from io import BytesIO
-
-        output = BytesIO()
-        img.save(output, format="PNG")
-        png_data = output.getvalue()
-
-        graphic = _encode_kitty_graphic(png_data, img_width, img_height)
-
-        sys.stdout.buffer.write(graphic)
-        sys.stdout.flush()
-
-        elapsed_ms = (time.perf_counter() - t0) * 1000
-
-        from engine.display import get_monitor
-
-        monitor = get_monitor()
-        if monitor:
-            chars_in = sum(len(line) for line in buffer)
-            monitor.record_effect("kitty_display", elapsed_ms, chars_in, chars_in)
-
-    def clear(self) -> None:
-        import sys
-
-        sys.stdout.buffer.write(b"\x1b_Ga=d\x1b\\")
-        sys.stdout.flush()
-
-    def cleanup(self) -> None:
-        self.clear()

engine/display/backends/multi.py

@@ -1,43 +0,0 @@
-"""
-Multi display backend - forwards to multiple displays.
-"""
-
-
-class MultiDisplay:
-    """Display that forwards to multiple displays.
-
-    Supports reuse - passes reuse flag to all child displays.
-    """
-
-    width: int = 80
-    height: int = 24
-
-    def __init__(self, displays: list):
-        self.displays = displays
-        self.width = 80
-        self.height = 24
-
-    def init(self, width: int, height: int, reuse: bool = False) -> None:
-        """Initialize all child displays with dimensions.
-
-        Args:
-            width: Terminal width in characters
-            height: Terminal height in rows
-            reuse: If True, use reuse mode for child displays
-        """
-        self.width = width
-        self.height = height
-        for d in self.displays:
-            d.init(width, height, reuse=reuse)
-
-    def show(self, buffer: list[str]) -> None:
-        for d in self.displays:
-            d.show(buffer)
-
-    def clear(self) -> None:
-        for d in self.displays:
-            d.clear()
-
-    def cleanup(self) -> None:
-        for d in self.displays:
-            d.cleanup()

engine/display/backends/null.py

@@ -1,43 +0,0 @@
-"""
-Null/headless display backend.
-"""
-
-import time
-
-
-class NullDisplay:
-    """Headless/null display - discards all output.
-
-    This display does nothing - useful for headless benchmarking
-    or when no display output is needed.
-    """
-
-    width: int = 80
-    height: int = 24
-
-    def init(self, width: int, height: int, reuse: bool = False) -> None:
-        """Initialize display with dimensions.
-
-        Args:
-            width: Terminal width in characters
-            height: Terminal height in rows
-            reuse: Ignored for NullDisplay (no resources to reuse)
-        """
-        self.width = width
-        self.height = height
-
-    def show(self, buffer: list[str]) -> None:
-        from engine.display import get_monitor
-
-        monitor = get_monitor()
-        if monitor:
-            t0 = time.perf_counter()
-            chars_in = sum(len(line) for line in buffer)
-            elapsed_ms = (time.perf_counter() - t0) * 1000
-            monitor.record_effect("null_display", elapsed_ms, chars_in, chars_in)
-
-    def clear(self) -> None:
-        pass
-
-    def cleanup(self) -> None:
-        pass

engine/display/backends/pygame.py

@@ -1,212 +0,0 @@
-"""
-Pygame display backend - renders to a native application window.
-"""
-
-import time
-
-from engine.display.renderer import parse_ansi
-
-
-class PygameDisplay:
-    """Pygame display backend - renders to native window.
-
-    Supports reuse mode - when reuse=True, skips SDL initialization
-    and reuses the existing pygame window from a previous instance.
-    """
-
-    width: int = 80
-    window_width: int = 800
-    window_height: int = 600
-    _pygame_initialized: bool = False
-
-    def __init__(
-        self,
-        cell_width: int = 10,
-        cell_height: int = 18,
-        window_width: int = 800,
-        window_height: int = 600,
-    ):
-        self.width = 80
-        self.height = 24
-        self.cell_width = cell_width
-        self.cell_height = cell_height
-        self.window_width = window_width
-        self.window_height = window_height
-        self._initialized = False
-        self._pygame = None
-        self._screen = None
-        self._font = None
-        self._resized = False
-
-    def _get_font_path(self) -> str | None:
-        """Get font path for rendering."""
-        import os
-        import sys
-        from pathlib import Path
-
-        env_font = os.environ.get("MAINLINE_PYGAME_FONT")
-        if env_font and os.path.exists(env_font):
-            return env_font
-
-        def search_dir(base_path: str) -> str | None:
-            if not os.path.exists(base_path):
-                return None
-            if os.path.isfile(base_path):
-                return base_path
-            for font_file in Path(base_path).rglob("*"):
-                if font_file.suffix.lower() in (".ttf", ".otf", ".ttc"):
-                    name = font_file.stem.lower()
-                    if "geist" in name and ("nerd" in name or "mono" in name):
-                        return str(font_file)
-            return None
-
-        search_dirs = []
-        if sys.platform == "darwin":
-            search_dirs.append(os.path.expanduser("~/Library/Fonts/"))
-        elif sys.platform == "win32":
-            search_dirs.append(
-                os.path.expanduser("~\\AppData\\Local\\Microsoft\\Windows\\Fonts\\")
-            )
-        else:
-            search_dirs.extend(
-                [
-                    os.path.expanduser("~/.local/share/fonts/"),
-                    os.path.expanduser("~/.fonts/"),
-                    "/usr/share/fonts/",
-                ]
-            )
-
-        for search_dir_path in search_dirs:
-            found = search_dir(search_dir_path)
-            if found:
-                return found
-
-        return None
-
-    def init(self, width: int, height: int, reuse: bool = False) -> None:
-        """Initialize display with dimensions.
-
-        Args:
-            width: Terminal width in characters
-            height: Terminal height in rows
-            reuse: If True, attach to existing pygame window instead of creating new
-        """
-        self.width = width
-        self.height = height
-
-        import os
-
-        os.environ["SDL_VIDEODRIVER"] = "x11"
-
-        try:
-            import pygame
-        except ImportError:
-            return
-
-        if reuse and PygameDisplay._pygame_initialized:
-            self._pygame = pygame
-            self._initialized = True
-            return
-
-        pygame.init()
-        pygame.display.set_caption("Mainline")
-
-        self._screen = pygame.display.set_mode(
-            (self.window_width, self.window_height),
-            pygame.RESIZABLE,
-        )
-        self._pygame = pygame
-        PygameDisplay._pygame_initialized = True
-
-        font_path = self._get_font_path()
-        if font_path:
-            try:
-                self._font = pygame.font.Font(font_path, self.cell_height - 2)
-            except Exception:
-                self._font = pygame.font.SysFont("monospace", self.cell_height - 2)
-        else:
-            self._font = pygame.font.SysFont("monospace", self.cell_height - 2)
-
-        self._initialized = True
-
-    def show(self, buffer: list[str]) -> None:
-        import sys
-
-        if not self._initialized or not self._pygame:
-            return
-
-        t0 = time.perf_counter()
-
-        for event in self._pygame.event.get():
-            if event.type == self._pygame.QUIT:
-                sys.exit(0)
-            elif event.type == self._pygame.VIDEORESIZE:
-                self.window_width = event.w
-                self.window_height = event.h
-                self.width = max(1, self.window_width // self.cell_width)
-                self.height = max(1, self.window_height // self.cell_height)
-                self._resized = True
-
-        self._screen.fill((0, 0, 0))
-
-        for row_idx, line in enumerate(buffer[: self.height]):
-            if row_idx >= self.height:
-                break
-
-            tokens = parse_ansi(line)
-            x_pos = 0
-
-            for text, fg, bg, _bold in tokens:
-                if not text:
-                    continue
-
-                if bg != (0, 0, 0):
-                    bg_surface = self._font.render(text, True, fg, bg)
-                    self._screen.blit(bg_surface, (x_pos, row_idx * self.cell_height))
-                else:
-                    text_surface = self._font.render(text, True, fg)
-                    self._screen.blit(text_surface, (x_pos, row_idx * self.cell_height))
-
-                x_pos += self._font.size(text)[0]
-
-        self._pygame.display.flip()
-
-        elapsed_ms = (time.perf_counter() - t0) * 1000
-
-        from engine.display import get_monitor
-
-        monitor = get_monitor()
-        if monitor:
-            chars_in = sum(len(line) for line in buffer)
-            monitor.record_effect("pygame_display", elapsed_ms, chars_in, chars_in)
-
-    def clear(self) -> None:
-        if self._screen and self._pygame:
-            self._screen.fill((0, 0, 0))
-            self._pygame.display.flip()
-
-    def get_dimensions(self) -> tuple[int, int]:
-        """Get current terminal dimensions based on window size.
-
-        Returns:
-            (width, height) in character cells
-        """
-        if self._resized:
-            self._resized = False
-        return self.width, self.height
-
-    def cleanup(self, quit_pygame: bool = True) -> None:
-        """Cleanup display resources.
-
-        Args:
-            quit_pygame: If True, quit pygame entirely. Set to False when
-                        reusing the display to avoid closing shared window.
-        """
-        if quit_pygame and self._pygame:
-            self._pygame.quit()
-            PygameDisplay._pygame_initialized = False
-
-    @classmethod
-    def reset_state(cls) -> None:
-        """Reset pygame state - useful for testing."""
-        cls._pygame_initialized = False

engine/display/backends/sixel.py

@@ -1,200 +0,0 @@
-"""
-Sixel graphics display backend - renders to sixel graphics in terminal.
-"""
-
-import time
-
-from engine.display.renderer import get_default_font_path, parse_ansi
-
-
-def _encode_sixel(image) -> str:
-    """Encode a PIL Image to sixel format (pure Python)."""
-    img = image.convert("RGBA")
-    width, height = img.size
-    pixels = img.load()
-
-    palette = []
-    pixel_palette_idx = {}
-
-    def get_color_idx(r, g, b, a):
-        if a < 128:
-            return -1
-        key = (r // 32, g // 32, b // 32)
-        if key not in pixel_palette_idx:
-            idx = len(palette)
-            if idx < 256:
-                palette.append((r, g, b))
-                pixel_palette_idx[key] = idx
-        return pixel_palette_idx.get(key, 0)
-
-    for y in range(height):
-        for x in range(width):
-            r, g, b, a = pixels[x, y]
-            get_color_idx(r, g, b, a)
-
-    if not palette:
-        return ""
-
-    if len(palette) == 1:
-        palette = [palette[0], (0, 0, 0)]
-
-    sixel_data = []
-    sixel_data.append(
-        f'"{"".join(f"#{i};2;{r};{g};{b}" for i, (r, g, b) in enumerate(palette))}'
-    )
-
-    for x in range(width):
-        col_data = []
-        for y in range(0, height, 6):
-            bits = 0
-            color_idx = -1
-            for dy in range(6):
-                if y + dy < height:
-                    r, g, b, a = pixels[x, y + dy]
-                    if a >= 128:
-                        bits |= 1 << dy
-                        idx = get_color_idx(r, g, b, a)
-                        if color_idx == -1:
-                            color_idx = idx
-                        elif color_idx != idx:
-                            color_idx = -2
-
-            if color_idx >= 0:
-                col_data.append(
-                    chr(63 + color_idx) + chr(63 + bits)
-                    if bits
-                    else chr(63 + color_idx) + "?"
-                )
-            elif color_idx == -2:
-                pass
-
-        if col_data:
-            sixel_data.append("".join(col_data) + "$")
-        else:
-            sixel_data.append("-" if x < width - 1 else "$")
-
-    sixel_data.append("\x1b\\")
-
-    return "\x1bPq" + "".join(sixel_data)
-
-
-class SixelDisplay:
-    """Sixel graphics display backend - renders to sixel graphics in terminal."""
-
-    width: int = 80
-    height: int = 24
-
-    def __init__(self, cell_width: int = 9, cell_height: int = 16):
-        self.width = 80
-        self.height = 24
-        self.cell_width = cell_width
-        self.cell_height = cell_height
-        self._initialized = False
-        self._font_path = None
-
-    def _get_font_path(self) -> str | None:
-        """Get font path from env or detect common locations."""
-        import os
-
-        if self._font_path:
-            return self._font_path
-
-        env_font = os.environ.get("MAINLINE_SIXEL_FONT")
-        if env_font and os.path.exists(env_font):
-            self._font_path = env_font
-            return env_font
-
-        font_path = get_default_font_path()
-        if font_path:
-            self._font_path = font_path
-
-        return self._font_path
-
-    def init(self, width: int, height: int, reuse: bool = False) -> None:
-        """Initialize display with dimensions.
-
-        Args:
-            width: Terminal width in characters
-            height: Terminal height in rows
-            reuse: Ignored for SixelDisplay
-        """
-        self.width = width
-        self.height = height
-        self._initialized = True
-
-    def show(self, buffer: list[str]) -> None:
-        import sys
-
-        t0 = time.perf_counter()
-
-        img_width = self.width * self.cell_width
-        img_height = self.height * self.cell_height
-
-        try:
-            from PIL import Image, ImageDraw, ImageFont
-        except ImportError:
-            return
-
-        img = Image.new("RGBA", (img_width, img_height), (0, 0, 0, 255))
-        draw = ImageDraw.Draw(img)
-
-        font_path = self._get_font_path()
-        font = None
-        if font_path:
-            try:
-                font = ImageFont.truetype(font_path, self.cell_height - 2)
-            except Exception:
-                font = None
-
-        if font is None:
-            try:
-                font = ImageFont.load_default()
-            except Exception:
-                font = None
-
-        for row_idx, line in enumerate(buffer[: self.height]):
-            if row_idx >= self.height:
-                break
-
-            tokens = parse_ansi(line)
-            x_pos = 0
-            y_pos = row_idx * self.cell_height
-
-            for text, fg, bg, bold in tokens:
-                if not text:
-                    continue
-
-                if bg != (0, 0, 0):
-                    bbox = draw.textbbox((x_pos, y_pos), text, font=font)
-                    draw.rectangle(bbox, fill=(*bg, 255))
-
-                if bold and font:
-                    draw.text((x_pos - 1, y_pos - 1), text, fill=(*fg, 255), font=font)
-
-                draw.text((x_pos, y_pos), text, fill=(*fg, 255), font=font)
-
-                if font:
-                    x_pos += draw.textlength(text, font=font)
-
-        sixel = _encode_sixel(img)
-
-        sys.stdout.buffer.write(sixel.encode("utf-8"))
-        sys.stdout.flush()
-
-        elapsed_ms = (time.perf_counter() - t0) * 1000
-
-        from engine.display import get_monitor
-
-        monitor = get_monitor()
-        if monitor:
-            chars_in = sum(len(line) for line in buffer)
-            monitor.record_effect("sixel_display", elapsed_ms, chars_in, chars_in)
-
-    def clear(self) -> None:
-        import sys
-
-        sys.stdout.buffer.write(b"\x1b[2J\x1b[H")
-        sys.stdout.flush()
-
-    def cleanup(self) -> None:
-        pass

engine/display/backends/terminal.py

@@ -1,59 +0,0 @@
-"""
-ANSI terminal display backend.
-"""
-
-import time
-
-
-class TerminalDisplay:
-    """ANSI terminal display backend.
-
-    Renders buffer to stdout using ANSI escape codes.
-    Supports reuse - when reuse=True, skips re-initializing terminal state.
-    """
-
-    width: int = 80
-    height: int = 24
-    _initialized: bool = False
-
-    def init(self, width: int, height: int, reuse: bool = False) -> None:
-        """Initialize display with dimensions.
-
-        Args:
-            width: Terminal width in characters
-            height: Terminal height in rows
-            reuse: If True, skip terminal re-initialization
-        """
-        from engine.terminal import CURSOR_OFF
-
-        self.width = width
-        self.height = height
-
-        if not reuse or not self._initialized:
-            print(CURSOR_OFF, end="", flush=True)
-            self._initialized = True
-
-    def show(self, buffer: list[str]) -> None:
-        import sys
-
-        t0 = time.perf_counter()
-        sys.stdout.buffer.write("".join(buffer).encode())
-        sys.stdout.flush()
-        elapsed_ms = (time.perf_counter() - t0) * 1000
-
-        from engine.display import get_monitor
-
-        monitor = get_monitor()
-        if monitor:
-            chars_in = sum(len(line) for line in buffer)
-            monitor.record_effect("terminal_display", elapsed_ms, chars_in, chars_in)
-
-    def clear(self) -> None:
-        from engine.terminal import CLR
-
-        print(CLR, end="", flush=True)
-
-    def cleanup(self) -> None:
-        from engine.terminal import CURSOR_ON
-
-        print(CURSOR_ON, end="", flush=True)

engine/display/backends/websocket.py

@@ -1,274 +0,0 @@
-"""
-WebSocket display backend - broadcasts frame buffer to connected web clients.
-"""
-
-import asyncio
-import json
-import threading
-import time
-from typing import Protocol
-
-try:
-    import websockets
-except ImportError:
-    websockets = None
-
-
-class Display(Protocol):
-    """Protocol for display backends."""
-
-    width: int
-    height: int
-
-    def init(self, width: int, height: int) -> None:
-        """Initialize display with dimensions."""
-        ...
-
-    def show(self, buffer: list[str]) -> None:
-        """Show buffer on display."""
-        ...
-
-    def clear(self) -> None:
-        """Clear display."""
-        ...
-
-    def cleanup(self) -> None:
-        """Shutdown display."""
-        ...
-
-
-def get_monitor():
-    """Get the performance monitor."""
-    try:
-        from engine.effects.performance import get_monitor as _get_monitor
-
-        return _get_monitor()
-    except Exception:
-        return None
-
-
-class WebSocketDisplay:
-    """WebSocket display backend - broadcasts to HTML Canvas clients."""
-
-    width: int = 80
-    height: int = 24
-
-    def __init__(
-        self,
-        host: str = "0.0.0.0",
-        port: int = 8765,
-        http_port: int = 8766,
-    ):
-        self.host = host
-        self.port = port
-        self.http_port = http_port
-        self.width = 80
-        self.height = 24
-        self._clients: set = set()
-        self._server_running = False
-        self._http_running = False
-        self._server_thread: threading.Thread | None = None
-        self._http_thread: threading.Thread | None = None
-        self._available = True
-        self._max_clients = 10
-        self._client_connected_callback = None
-        self._client_disconnected_callback = None
-        self._frame_delay = 0.0
-
-        try:
-            import websockets as _ws
-
-            self._available = _ws is not None
-        except ImportError:
-            self._available = False
-
-    def is_available(self) -> bool:
-        """Check if WebSocket support is available."""
-        return self._available
-
-    def init(self, width: int, height: int, reuse: bool = False) -> None:
-        """Initialize display with dimensions and start server.
-
-        Args:
-            width: Terminal width in characters
-            height: Terminal height in rows
-            reuse: If True, skip starting servers (assume already running)
-        """
-        self.width = width
-        self.height = height
-
-        if not reuse or not self._server_running:
-            self.start_server()
-            self.start_http_server()
-
-    def show(self, buffer: list[str]) -> None:
-        """Broadcast buffer to all connected clients."""
-        t0 = time.perf_counter()
-
-        if self._clients:
-            frame_data = {
-                "type": "frame",
-                "width": self.width,
-                "height": self.height,
-                "lines": buffer,
-            }
-            message = json.dumps(frame_data)
-
-            disconnected = set()
-            for client in list(self._clients):
-                try:
-                    asyncio.run(client.send(message))
-                except Exception:
-                    disconnected.add(client)
-
-            for client in disconnected:
-                self._clients.discard(client)
-                if self._client_disconnected_callback:
-                    self._client_disconnected_callback(client)
-
-        elapsed_ms = (time.perf_counter() - t0) * 1000
-        monitor = get_monitor()
-        if monitor:
-            chars_in = sum(len(line) for line in buffer)
-            monitor.record_effect("websocket_display", elapsed_ms, chars_in, chars_in)
-
-    def clear(self) -> None:
-        """Broadcast clear command to all clients."""
-        if self._clients:
-            clear_data = {"type": "clear"}
-            message = json.dumps(clear_data)
-            for client in list(self._clients):
-                try:
-                    asyncio.run(client.send(message))
-                except Exception:
-                    pass
-
-    def cleanup(self) -> None:
-        """Stop the servers."""
-        self.stop_server()
-        self.stop_http_server()
-
-    async def _websocket_handler(self, websocket):
-        """Handle WebSocket connections."""
-        if len(self._clients) >= self._max_clients:
-            await websocket.close()
-            return
-
-        self._clients.add(websocket)
-        if self._client_connected_callback:
-            self._client_connected_callback(websocket)
-
-        try:
-            async for message in websocket:
-                try:
-                    data = json.loads(message)
-                    if data.get("type") == "resize":
-                        self.width = data.get("width", 80)
-                        self.height = data.get("height", 24)
-                except json.JSONDecodeError:
-                    pass
-        except Exception:
-            pass
-        finally:
-            self._clients.discard(websocket)
-            if self._client_disconnected_callback:
-                self._client_disconnected_callback(websocket)
-
-    async def _run_websocket_server(self):
-        """Run the WebSocket server."""
-        async with websockets.serve(self._websocket_handler, self.host, self.port):
-            while self._server_running:
-                await asyncio.sleep(0.1)
-
-    async def _run_http_server(self):
-        """Run simple HTTP server for the client."""
-        import os
-        from http.server import HTTPServer, SimpleHTTPRequestHandler
-
-        client_dir = os.path.join(
-            os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "client"
-        )
-
-        class Handler(SimpleHTTPRequestHandler):
-            def __init__(self, *args, **kwargs):
-                super().__init__(*args, directory=client_dir, **kwargs)
-
-            def log_message(self, format, *args):
-                pass
-
-        httpd = HTTPServer((self.host, self.http_port), Handler)
-        while self._http_running:
-            httpd.handle_request()
-
-    def _run_async(self, coro):
-        """Run coroutine in background."""
-        try:
-            asyncio.run(coro)
-        except Exception as e:
-            print(f"WebSocket async error: {e}")
-
-    def start_server(self):
-        """Start the WebSocket server in a background thread."""
-        if not self._available:
-            return
-        if self._server_thread is not None:
-            return
-
-        self._server_running = True
-        self._server_thread = threading.Thread(
-            target=self._run_async, args=(self._run_websocket_server(),), daemon=True
-        )
-        self._server_thread.start()
-
-    def stop_server(self):
-        """Stop the WebSocket server."""
-        self._server_running = False
-        self._server_thread = None
-
-    def start_http_server(self):
-        """Start the HTTP server in a background thread."""
-        if not self._available:
-            return
-        if self._http_thread is not None:
-            return
-
-        self._http_running = True
-
-        self._http_running = True
-        self._http_thread = threading.Thread(
-            target=self._run_async, args=(self._run_http_server(),), daemon=True
-        )
-        self._http_thread.start()
-
-    def stop_http_server(self):
-        """Stop the HTTP server."""
-        self._http_running = False
-        self._http_thread = None
-
-    def client_count(self) -> int:
-        """Return number of connected clients."""
-        return len(self._clients)
-
-    def get_ws_port(self) -> int:
-        """Return WebSocket port."""
-        return self.port
-
-    def get_http_port(self) -> int:
-        """Return HTTP port."""
-        return self.http_port
-
-    def set_frame_delay(self, delay: float) -> None:
-        """Set delay between frames in seconds."""
-        self._frame_delay = delay
-
-    def get_frame_delay(self) -> float:
-        """Get delay between frames."""
-        return self._frame_delay
-
-    def set_client_connected_callback(self, callback) -> None:
-        """Set callback for client connections."""
-        self._client_connected_callback = callback
-
-    def set_client_disconnected_callback(self, callback) -> None:
-        """Set callback for client disconnections."""
-        self._client_disconnected_callback = callback

engine/display/renderer.py

@@ -1,280 +0,0 @@
-"""
-Shared display rendering utilities.
-
-Provides common functionality for displays that render text to images
-(Pygame, Sixel, Kitty displays).
-"""
-
-from typing import Any
-
-ANSI_COLORS = {
-    0: (0, 0, 0),
-    1: (205, 49, 49),
-    2: (13, 188, 121),
-    3: (229, 229, 16),
-    4: (36, 114, 200),
-    5: (188, 63, 188),
-    6: (17, 168, 205),
-    7: (229, 229, 229),
-    8: (102, 102, 102),
-    9: (241, 76, 76),
-    10: (35, 209, 139),
-    11: (245, 245, 67),
-    12: (59, 142, 234),
-    13: (214, 112, 214),
-    14: (41, 184, 219),
-    15: (255, 255, 255),
-}
-
-
-def parse_ansi(
-    text: str,
-) -> list[tuple[str, tuple[int, int, int], tuple[int, int, int], bool]]:
-    """Parse ANSI escape sequences into text tokens with colors.
-
-    Args:
-        text: Text containing ANSI escape sequences
-
-    Returns:
-        List of (text, fg_rgb, bg_rgb, bold) tuples
-    """
-    tokens = []
-    current_text = ""
-    fg = (204, 204, 204)
-    bg = (0, 0, 0)
-    bold = False
-    i = 0
-
-    ANSI_COLORS_4BIT = {
-        0: (0, 0, 0),
-        1: (205, 49, 49),
-        2: (13, 188, 121),
-        3: (229, 229, 16),
-        4: (36, 114, 200),
-        5: (188, 63, 188),
-        6: (17, 168, 205),
-        7: (229, 229, 229),
-        8: (102, 102, 102),
-        9: (241, 76, 76),
-        10: (35, 209, 139),
-        11: (245, 245, 67),
-        12: (59, 142, 234),
-        13: (214, 112, 214),
-        14: (41, 184, 219),
-        15: (255, 255, 255),
-    }
-
-    while i < len(text):
-        char = text[i]
-
-        if char == "\x1b" and i + 1 < len(text) and text[i + 1] == "[":
-            if current_text:
-                tokens.append((current_text, fg, bg, bold))
-                current_text = ""
-
-            i += 2
-            code = ""
-            while i < len(text):
-                c = text[i]
-                if c.isalpha():
-                    break
-                code += c
-                i += 1
-
-            if code:
-                codes = code.split(";")
-                for c in codes:
-                    if c == "0":
-                        fg = (204, 204, 204)
-                        bg = (0, 0, 0)
-                        bold = False
-                    elif c == "1":
-                        bold = True
-                    elif c == "22":
-                        bold = False
-                    elif c == "39":
-                        fg = (204, 204, 204)
-                    elif c == "49":
-                        bg = (0, 0, 0)
-                    elif c.isdigit():
-                        color_idx = int(c)
-                        if color_idx in ANSI_COLORS_4BIT:
-                            fg = ANSI_COLORS_4BIT[color_idx]
-                        elif 30 <= color_idx <= 37:
-                            fg = ANSI_COLORS_4BIT.get(color_idx - 30, fg)
-                        elif 40 <= color_idx <= 47:
-                            bg = ANSI_COLORS_4BIT.get(color_idx - 40, bg)
-                        elif 90 <= color_idx <= 97:
-                            fg = ANSI_COLORS_4BIT.get(color_idx - 90 + 8, fg)
-                        elif 100 <= color_idx <= 107:
-                            bg = ANSI_COLORS_4BIT.get(color_idx - 100 + 8, bg)
-                    elif c.startswith("38;5;"):
-                        idx = int(c.split(";")[-1])
-                        if idx < 256:
-                            if idx < 16:
-                                fg = ANSI_COLORS_4BIT.get(idx, fg)
-                            elif idx < 232:
-                                c_idx = idx - 16
-                                fg = (
-                                    (c_idx >> 4) * 51,
-                                    ((c_idx >> 2) & 7) * 51,
-                                    (c_idx & 3) * 85,
-                                )
-                            else:
-                                gray = (idx - 232) * 10 + 8
-                                fg = (gray, gray, gray)
-                    elif c.startswith("48;5;"):
-                        idx = int(c.split(";")[-1])
-                        if idx < 256:
-                            if idx < 16:
-                                bg = ANSI_COLORS_4BIT.get(idx, bg)
-                            elif idx < 232:
-                                c_idx = idx - 16
-                                bg = (
-                                    (c_idx >> 4) * 51,
-                                    ((c_idx >> 2) & 7) * 51,
-                                    (c_idx & 3) * 85,
-                                )
-                            else:
-                                gray = (idx - 232) * 10 + 8
-                                bg = (gray, gray, gray)
-            i += 1
-        else:
-            current_text += char
-            i += 1
-
-    if current_text:
-        tokens.append((current_text, fg, bg, bold))
-
-    return tokens if tokens else [("", fg, bg, bold)]
-
-
-def get_default_font_path() -> str | None:
-    """Get the path to a default monospace font."""
-    import os
-    import sys
-    from pathlib import Path
-
-    def search_dir(base_path: str) -> str | None:
-        if not os.path.exists(base_path):
-            return None
-        if os.path.isfile(base_path):
-            return base_path
-        for font_file in Path(base_path).rglob("*"):
-            if font_file.suffix.lower() in (".ttf", ".otf", ".ttc"):
-                name = font_file.stem.lower()
-                if "geist" in name and ("nerd" in name or "mono" in name):
-                    return str(font_file)
-                if "mono" in name or "courier" in name or "terminal" in name:
-                    return str(font_file)
-        return None
-
-    search_dirs = []
-    if sys.platform == "darwin":
-        search_dirs.extend(
-            [
-                os.path.expanduser("~/Library/Fonts/"),
-                "/System/Library/Fonts/",
-            ]
-        )
-    elif sys.platform == "win32":
-        search_dirs.extend(
-            [
-                os.path.expanduser("~\\AppData\\Local\\Microsoft\\Windows\\Fonts\\"),
-                "C:\\Windows\\Fonts\\",
-            ]
-        )
-    else:
-        search_dirs.extend(
-            [
-                os.path.expanduser("~/.local/share/fonts/"),
-                os.path.expanduser("~/.fonts/"),
-                "/usr/share/fonts/",
-            ]
-        )
-
-    for search_dir_path in search_dirs:
-        found = search_dir(search_dir_path)
-        if found:
-            return found
-
-    if sys.platform != "win32":
-        try:
-            import subprocess
-
-            for pattern in ["monospace", "DejaVuSansMono", "LiberationMono"]:
-                result = subprocess.run(
-                    ["fc-match", "-f", "%{file}", pattern],
-                    capture_output=True,
-                    text=True,
-                    timeout=5,
-                )
-                if result.returncode == 0 and result.stdout.strip():
-                    font_file = result.stdout.strip()
-                    if os.path.exists(font_file):
-                        return font_file
-        except Exception:
-            pass
-
-    return None
-
-
-def render_to_pil(
-    buffer: list[str],
-    width: int,
-    height: int,
-    cell_width: int = 10,
-    cell_height: int = 18,
-    font_path: str | None = None,
-) -> Any:
-    """Render buffer to a PIL Image.
-
-    Args:
-        buffer: List of text lines to render
-        width: Terminal width in characters
-        height: Terminal height in rows
-        cell_width: Width of each character cell in pixels
-        cell_height: Height of each character cell in pixels
-        font_path: Path to TTF/OTF font file (optional)
-
-    Returns:
-        PIL Image object
-    """
-    from PIL import Image, ImageDraw, ImageFont
-
-    img_width = width * cell_width
-    img_height = height * cell_height
-
-    img = Image.new("RGBA", (img_width, img_height), (0, 0, 0, 255))
-    draw = ImageDraw.Draw(img)
-
-    if font_path:
-        try:
-            font = ImageFont.truetype(font_path, cell_height - 2)
-        except Exception:
-            font = ImageFont.load_default()
-    else:
-        font = ImageFont.load_default()
-
-    for row_idx, line in enumerate(buffer[:height]):
-        if row_idx >= height:
-            break
-
-        tokens = parse_ansi(line)
-        x_pos = 0
-        y_pos = row_idx * cell_height
-
-        for text, fg, bg, _bold in tokens:
-            if not text:
-                continue
-
-            if bg != (0, 0, 0):
-                bbox = draw.textbbox((x_pos, y_pos), text, font=font)
-                draw.rectangle(bbox, fill=(*bg, 255))
-
-            draw.text((x_pos, y_pos), text, fill=(*fg, 255), font=font)
-
-            if font:
-                x_pos += draw.textlength(text, font=font)
-
-    return img

engine/effects/__init__.py

@@ -6,17 +6,11 @@ from engine.effects.legacy import (
     glitch_bar,
     next_headline,
     noise,
-    vis_offset,
     vis_trunc,
 )
 from engine.effects.performance import PerformanceMonitor, get_monitor, set_monitor
 from engine.effects.registry import EffectRegistry, get_registry, set_registry
-from engine.effects.types import (
-    EffectConfig,
-    EffectContext,
-    PipelineConfig,
-    create_effect_context,
-)
+from engine.effects.types import EffectConfig, EffectContext, PipelineConfig
 
 
 def get_effect_chain():
@@ -31,7 +25,6 @@ __all__ = [
     "EffectConfig",
     "EffectContext",
     "PipelineConfig",
-    "create_effect_context",
     "get_registry",
     "set_registry",
     "get_effect_chain",
@@ -46,5 +39,4 @@ __all__ = [
     "noise",
     "next_headline",
     "vis_trunc",
-    "vis_offset",
 ]

engine/effects/legacy.py

@@ -1,14 +1,6 @@
 """
 Visual effects: noise, glitch, fade, ANSI-aware truncation, firehose, headline pool.
 Depends on: config, terminal, sources.
-
-These are low-level functional implementations of visual effects. They are used
-internally by the EffectPlugin system (effects_plugins/*.py) and also directly
-by layers.py and scroll.py for rendering.
-
-The plugin system provides a higher-level OOP interface with configuration
-support, while these legacy functions provide direct functional access.
-Both systems coexist - there are no current plans to deprecate the legacy functions.
 """
 
 import random
@@ -82,37 +74,6 @@ def vis_trunc(s, w):
     return "".join(result)
 
 
-def vis_offset(s, offset):
-    """Offset string by skipping first offset visual characters, skipping ANSI escape codes."""
-    if offset <= 0:
-        return s
-    result = []
-    vw = 0
-    i = 0
-    skipping = True
-    while i < len(s):
-        if s[i] == "\033" and i + 1 < len(s) and s[i + 1] == "[":
-            j = i + 2
-            while j < len(s) and not s[j].isalpha():
-                j += 1
-            if skipping:
-                i = j + 1
-                continue
-            result.append(s[i : j + 1])
-            i = j + 1
-        else:
-            if skipping:
-                if vw >= offset:
-                    skipping = False
-                    result.append(s[i])
-                vw += 1
-                i += 1
-            else:
-                result.append(s[i])
-                i += 1
-    return "".join(result)
-
-
 def next_headline(pool, items, seen):
     """Pull the next unique headline from pool, refilling as needed."""
     while True:

engine/effects/types.py

@@ -1,23 +1,3 @@
-"""
-Visual effects type definitions and base classes.
-
-EffectPlugin Architecture:
-- Uses ABC (Abstract Base Class) for interface enforcement
-- Runtime discovery via directory scanning (effects_plugins/)
-- Configuration via EffectConfig dataclass
-- Context passed through EffectContext dataclass
-
-Plugin System Research (see AGENTS.md for references):
-- VST: Standardized audio interfaces, chaining, presets (FXP/FXB)
-- Python Entry Points: Namespace packages, importlib.metadata discovery
-- Shadertoy: Shader-based with uniforms as context
-
-Current gaps vs industry patterns:
-- No preset save/load system
-- No external plugin distribution via entry points
-- No plugin metadata (version, author, description)
-"""
-
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from typing import Any
@@ -45,50 +25,14 @@ class EffectConfig:
 
 
 class EffectPlugin(ABC):
-    """Abstract base class for effect plugins.
-
-    Subclasses must define:
-    - name: str - unique identifier for the effect
-    - config: EffectConfig - current configuration
-
-    And implement:
-    - process(buf, ctx) -> list[str]
-    - configure(config) -> None
-
-    Effect Behavior with ticker_height=0:
-    - NoiseEffect: Returns buffer unchanged (no ticker to apply noise to)
-    - FadeEffect: Returns buffer unchanged (no ticker to fade)
-    - GlitchEffect: Processes normally (doesn't depend on ticker_height)
-    - FirehoseEffect: Returns buffer unchanged if no items in context
-
-    Effects should handle missing or zero context values gracefully by
-    returning the input buffer unchanged rather than raising errors.
-    """
-
     name: str
     config: EffectConfig
 
     @abstractmethod
-    def process(self, buf: list[str], ctx: EffectContext) -> list[str]:
-        """Process the buffer with this effect applied.
-
-        Args:
-            buf: List of lines to process
-            ctx: Effect context with terminal state
-
-        Returns:
-            Processed buffer (may be same object or new list)
-        """
-        ...
+    def process(self, buf: list[str], ctx: EffectContext) -> list[str]: ...
 
     @abstractmethod
-    def configure(self, config: EffectConfig) -> None:
-        """Configure the effect with new settings.
-
-        Args:
-            config: New configuration to apply
-        """
-        ...
+    def configure(self, config: EffectConfig) -> None: ...
 
 
 def create_effect_context(
@@ -96,6 +40,7 @@ def create_effect_context(
     terminal_height: int = 24,
     scroll_cam: int = 0,
     ticker_height: int = 0,
+    camera_x: int = 0,
     mic_excess: float = 0.0,
     grad_offset: float = 0.0,
     frame_number: int = 0,
@@ -108,6 +53,7 @@ def create_effect_context(
         terminal_height=terminal_height,
         scroll_cam=scroll_cam,
         ticker_height=ticker_height,
+        camera_x=camera_x,
         mic_excess=mic_excess,
         grad_offset=grad_offset,
         frame_number=frame_number,

engine/fetch_code.py

@@ -0,0 +1,67 @@
+"""
+Source code feed — reads engine/*.py and emits non-blank, non-comment lines
+as scroll items. Used by --code mode.
+Depends on: nothing (stdlib only).
+"""
+
+import ast
+from pathlib import Path
+
+_ENGINE_DIR = Path(__file__).resolve().parent
+
+
+def _scope_map(source: str) -> dict[int, str]:
+    """Return {line_number: scope_label} for every line in source.
+
+    Nodes are sorted by range size descending so inner scopes overwrite
+    outer ones, guaranteeing the narrowest enclosing scope wins.
+    """
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return {}
+
+    nodes = []
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            end = getattr(node, "end_lineno", node.lineno)
+            span = end - node.lineno
+            nodes.append((span, node))
+
+    # Largest range first → inner scopes overwrite on second pass
+    nodes.sort(key=lambda x: x[0], reverse=True)
+
+    scope = {}
+    for _, node in nodes:
+        end = getattr(node, "end_lineno", node.lineno)
+        if isinstance(node, ast.ClassDef):
+            label = node.name
+        else:
+            label = f"{node.name}()"
+        for ln in range(node.lineno, end + 1):
+            scope[ln] = label
+
+    return scope
+
+
+def fetch_code():
+    """Read engine/*.py and return (items, line_count, 0).
+
+    Each item is (text, src, ts) where:
+      text  = the code line (rstripped, indentation preserved)
+      src   = enclosing function/class name, e.g. 'stream()' or '<module>'
+      ts    = dotted module path, e.g. 'engine.scroll'
+    """
+    items = []
+    for path in sorted(_ENGINE_DIR.glob("*.py")):
+        module = f"engine.{path.stem}"
+        source = path.read_text(encoding="utf-8")
+        scope = _scope_map(source)
+        for lineno, raw in enumerate(source.splitlines(), start=1):
+            stripped = raw.strip()
+            if not stripped or stripped.startswith("#"):
+                continue
+            label = scope.get(lineno, "<module>")
+            items.append((raw.rstrip(), label, module))
+
+    return items, len(items), 0

engine/layers.py

@@ -16,10 +16,9 @@ from engine.effects import (
     firehose_line,
     glitch_bar,
     noise,
-    vis_offset,
     vis_trunc,
 )
-from engine.render import big_wrap, lr_gradient, lr_gradient_opposite
+from engine.render import big_wrap, lr_gradient, msg_gradient
 from engine.terminal import RST, W_COOL
 
 MSG_META = "\033[38;5;245m"
@@ -58,7 +57,7 @@ def render_message_overlay(
     else:
         msg_rows = msg_cache[1]
 
-    msg_rows = lr_gradient_opposite(
+    msg_rows = msg_gradient(
         msg_rows, (time.monotonic() * config.GRAD_SPEED) % 1.0
     )
 
@@ -95,18 +94,16 @@ def render_message_overlay(
 def render_ticker_zone(
     active: list,
     scroll_cam: int,
-    camera_x: int = 0,
-    ticker_h: int = 0,
-    w: int = 80,
-    noise_cache: dict | None = None,
-    grad_offset: float = 0.0,
+    ticker_h: int,
+    w: int,
+    noise_cache: dict,
+    grad_offset: float,
 ) -> tuple[list[str], dict]:
     """Render the ticker scroll zone.
 
     Args:
         active: list of (content_rows, color, canvas_y, meta_idx)
         scroll_cam: camera position (viewport top)
-        camera_x: horizontal camera offset
         ticker_h: height of ticker zone
         w: terminal width
         noise_cache: dict of cy -> noise string
@@ -115,8 +112,6 @@ def render_ticker_zone(
     Returns:
         (list of ANSI strings, updated noise_cache)
     """
-    if noise_cache is None:
-        noise_cache = {}
     buf = []
     top_zone = max(1, int(ticker_h * 0.25))
     bot_zone = max(1, int(ticker_h * 0.10))
@@ -142,7 +137,7 @@ def render_ticker_zone(
                     colored = lr_gradient([raw], grad_offset)[0]
                 else:
                     colored = raw
-                ln = vis_trunc(vis_offset(colored, camera_x), w)
+                ln = vis_trunc(colored, w)
                 if row_fade < 1.0:
                     ln = fade_line(ln, row_fade)
 
@@ -233,12 +228,11 @@ def process_effects(
     h: int,
     scroll_cam: int,
     ticker_h: int,
-    camera_x: int = 0,
-    mic_excess: float = 0.0,
-    grad_offset: float = 0.0,
-    frame_number: int = 0,
-    has_message: bool = False,
-    items: list | None = None,
+    mic_excess: float,
+    grad_offset: float,
+    frame_number: int,
+    has_message: bool,
+    items: list,
 ) -> list[str]:
     """Process buffer through effect chain."""
     if _effect_chain is None:
@@ -248,13 +242,12 @@ def process_effects(
         terminal_width=w,
         terminal_height=h,
         scroll_cam=scroll_cam,
-        camera_x=camera_x,
         ticker_height=ticker_h,
         mic_excess=mic_excess,
         grad_offset=grad_offset,
         frame_number=frame_number,
         has_message=has_message,
-        items=items or [],
+        items=items,
     )
     return _effect_chain.process(buf, ctx)
 

engine/pipeline.py

@@ -1,265 +0,0 @@
-"""
-Pipeline introspection - generates self-documenting diagrams of the render pipeline.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-
-@dataclass
-class PipelineNode:
-    """Represents a node in the pipeline."""
-
-    name: str
-    module: str
-    class_name: str | None = None
-    func_name: str | None = None
-    description: str = ""
-    inputs: list[str] | None = None
-    outputs: list[str] | None = None
-
-
-class PipelineIntrospector:
-    """Introspects the render pipeline and generates documentation."""
-
-    def __init__(self):
-        self.nodes: list[PipelineNode] = []
-
-    def add_node(self, node: PipelineNode) -> None:
-        self.nodes.append(node)
-
-    def generate_mermaid_flowchart(self) -> str:
-        """Generate a Mermaid flowchart of the pipeline."""
-        lines = ["```mermaid", "flowchart TD"]
-
-        for node in self.nodes:
-            node_id = node.name.replace("-", "_").replace(" ", "_")
-            label = node.name
-            if node.class_name:
-                label = f"{node.name}\\n({node.class_name})"
-            elif node.func_name:
-                label = f"{node.name}\\n({node.func_name})"
-
-            if node.description:
-                label += f"\\n{node.description}"
-
-            lines.append(f'    {node_id}["{label}"]')
-
-        lines.append("")
-
-        for node in self.nodes:
-            node_id = node.name.replace("-", "_").replace(" ", "_")
-            if node.inputs:
-                for inp in node.inputs:
-                    inp_id = inp.replace("-", "_").replace(" ", "_")
-                    lines.append(f"    {inp_id} --> {node_id}")
-
-        lines.append("```")
-        return "\n".join(lines)
-
-    def generate_mermaid_sequence(self) -> str:
-        """Generate a Mermaid sequence diagram of message flow."""
-        lines = ["```mermaid", "sequenceDiagram"]
-
-        lines.append("    participant Sources")
-        lines.append("    participant Fetch")
-        lines.append("    participant Scroll")
-        lines.append("    participant Effects")
-        lines.append("    participant Display")
-
-        lines.append("    Sources->>Fetch: headlines")
-        lines.append("    Fetch->>Scroll: content blocks")
-        lines.append("    Scroll->>Effects: buffer")
-        lines.append("    Effects->>Effects: process chain")
-        lines.append("    Effects->>Display: rendered buffer")
-
-        lines.append("```")
-        return "\n".join(lines)
-
-    def generate_mermaid_state(self) -> str:
-        """Generate a Mermaid state diagram of camera modes."""
-        lines = ["```mermaid", "stateDiagram-v2"]
-
-        lines.append("    [*] --> Vertical")
-        lines.append("    Vertical --> Horizontal: set_mode()")
-        lines.append("    Horizontal --> Omni: set_mode()")
-        lines.append("    Omni --> Floating: set_mode()")
-        lines.append("    Floating --> Vertical: set_mode()")
-
-        lines.append("    state Vertical {")
-        lines.append("        [*] --> ScrollUp")
-        lines.append("        ScrollUp --> ScrollUp: +y each frame")
-        lines.append("    }")
-
-        lines.append("    state Horizontal {")
-        lines.append("        [*] --> ScrollLeft")
-        lines.append("        ScrollLeft --> ScrollLeft: +x each frame")
-        lines.append("    }")
-
-        lines.append("    state Omni {")
-        lines.append("        [*] --> Diagonal")
-        lines.append("        Diagonal --> Diagonal: +x, +y")
-        lines.append("    }")
-
-        lines.append("    state Floating {")
-        lines.append("        [*] --> Bobbing")
-        lines.append("        Bobbing --> Bobbing: sin(time)")
-        lines.append("    }")
-
-        lines.append("```")
-        return "\n".join(lines)
-
-    def generate_full_diagram(self) -> str:
-        """Generate full pipeline documentation."""
-        lines = [
-            "# Render Pipeline",
-            "",
-            "## Data Flow",
-            "",
-            self.generate_mermaid_flowchart(),
-            "",
-            "## Message Sequence",
-            "",
-            self.generate_mermaid_sequence(),
-            "",
-            "## Camera States",
-            "",
-            self.generate_mermaid_state(),
-        ]
-        return "\n".join(lines)
-
-    def introspect_sources(self) -> None:
-        """Introspect data sources."""
-        from engine import sources
-
-        for name in dir(sources):
-            obj = getattr(sources, name)
-            if isinstance(obj, dict):
-                self.add_node(
-                    PipelineNode(
-                        name=f"Data Source: {name}",
-                        module="engine.sources",
-                        description=f"{len(obj)} feeds configured",
-                    )
-                )
-
-    def introspect_fetch(self) -> None:
-        """Introspect fetch layer."""
-        self.add_node(
-            PipelineNode(
-                name="fetch_all",
-                module="engine.fetch",
-                func_name="fetch_all",
-                description="Fetch RSS feeds",
-                outputs=["items"],
-            )
-        )
-
-        self.add_node(
-            PipelineNode(
-                name="fetch_poetry",
-                module="engine.fetch",
-                func_name="fetch_poetry",
-                description="Fetch Poetry DB",
-                outputs=["items"],
-            )
-        )
-
-    def introspect_scroll(self) -> None:
-        """Introspect scroll engine."""
-        self.add_node(
-            PipelineNode(
-                name="StreamController",
-                module="engine.controller",
-                class_name="StreamController",
-                description="Main render loop orchestrator",
-                inputs=["items", "ntfy_poller", "mic_monitor", "display"],
-                outputs=["buffer"],
-            )
-        )
-
-        self.add_node(
-            PipelineNode(
-                name="render_ticker_zone",
-                module="engine.layers",
-                func_name="render_ticker_zone",
-                description="Render scrolling ticker content",
-                inputs=["active", "camera"],
-                outputs=["buffer"],
-            )
-        )
-
-    def introspect_camera(self) -> None:
-        """Introspect camera system."""
-        self.add_node(
-            PipelineNode(
-                name="Camera",
-                module="engine.camera",
-                class_name="Camera",
-                description="Viewport position controller",
-                inputs=["dt"],
-                outputs=["x", "y"],
-            )
-        )
-
-    def introspect_effects(self) -> None:
-        """Introspect effect system."""
-        self.add_node(
-            PipelineNode(
-                name="EffectChain",
-                module="engine.effects",
-                class_name="EffectChain",
-                description="Process effects in sequence",
-                inputs=["buffer", "context"],
-                outputs=["buffer"],
-            )
-        )
-
-        self.add_node(
-            PipelineNode(
-                name="EffectRegistry",
-                module="engine.effects",
-                class_name="EffectRegistry",
-                description="Manage effect plugins",
-            )
-        )
-
-    def introspect_display(self) -> None:
-        """Introspect display backends."""
-        from engine.display import DisplayRegistry
-
-        DisplayRegistry.initialize()
-        backends = DisplayRegistry.list_backends()
-
-        for backend in backends:
-            self.add_node(
-                PipelineNode(
-                    name=f"Display: {backend}",
-                    module="engine.display.backends",
-                    class_name=f"{backend.title()}Display",
-                    description=f"Render to {backend}",
-                    inputs=["buffer"],
-                )
-            )
-
-    def run(self) -> str:
-        """Run full introspection."""
-        self.introspect_sources()
-        self.introspect_fetch()
-        self.introspect_scroll()
-        self.introspect_camera()
-        self.introspect_effects()
-        self.introspect_display()
-
-        return self.generate_full_diagram()
-
-
-def generate_pipeline_diagram() -> str:
-    """Generate a self-documenting pipeline diagram."""
-    introspector = PipelineIntrospector()
-    return introspector.run()
-
-
-if __name__ == "__main__":
-    print(generate_pipeline_diagram())

engine/pipeline_viz.py

@@ -1,123 +0,0 @@
-"""
-Pipeline visualization - ASCII text graphics showing the render pipeline.
-"""
-
-
-def generate_pipeline_visualization(width: int = 80, height: int = 24) -> list[str]:
-    """Generate ASCII visualization of the pipeline.
-
-    Args:
-        width: Width of the visualization in characters
-        height: Height in lines
-
-    Returns:
-        List of formatted strings representing the pipeline
-    """
-    lines = []
-
-    for y in range(height):
-        line = ""
-
-        if y == 1:
-            line = "╔" + "═" * (width - 2) + "╗"
-        elif y == 2:
-            line = "║" + " RENDER PIPELINE ".center(width - 2) + "║"
-        elif y == 3:
-            line = "╠" + "═" * (width - 2) + "╣"
-
-        elif y == 5:
-            line = "║ SOURCES ══════════════> FETCH ═════════> SCROLL ═══> EFFECTS ═> DISPLAY"
-        elif y == 6:
-            line = "║   │                    │                    │            │"
-        elif y == 7:
-            line = "║   RSS                  Poetry               Camera      Terminal"
-        elif y == 8:
-            line = "║   Ntfy                 Cache               Noise       WebSocket"
-        elif y == 9:
-            line = "║   Mic                                      Fade        Pygame"
-        elif y == 10:
-            line = "║                                             Glitch      Sixel"
-        elif y == 11:
-            line = "║                                             Firehose   Kitty"
-        elif y == 12:
-            line = "║                                             Hud"
-
-        elif y == 14:
-            line = "╠" + "═" * (width - 2) + "╣"
-        elif y == 15:
-            line = "║ CAMERA MODES "
-            remaining = width - len(line) - 1
-            line += (
-                "─" * (remaining // 2 - 7)
-                + " VERTICAL "
-                + "─" * (remaining // 2 - 6)
-                + "║"
-            )
-        elif y == 16:
-            line = (
-                "║ "
-                + "●".center(8)
-                + " "
-                + "○".center(8)
-                + " "
-                + "○".center(8)
-                + " "
-                + "○".center(8)
-                + " " * 20
-                + "║"
-            )
-        elif y == 17:
-            line = (
-                "║  scroll up      scroll left    diagonal     bobbing    "
-                + " " * 16
-                + "║"
-            )
-
-        elif y == 19:
-            line = "╠" + "═" * (width - 2) + "╣"
-        elif y == 20:
-            fps = "60"
-            line = (
-                f"║ FPS: {fps} │ Frame: 16.7ms │ Effects: 5 active │ Camera: VERTICAL "
-                + " " * (width - len(line) - 2)
-                + "║"
-            )
-
-        elif y == 21:
-            line = "╚" + "═" * (width - 2) + "╝"
-
-        else:
-            line = " " * width
-
-        lines.append(line)
-
-    return lines
-
-
-def generate_animated_pipeline(width: int = 80, frame: int = 0) -> list[str]:
-    """Generate animated ASCII visualization.
-
-    Args:
-        width: Width of the visualization
-        frame: Animation frame number
-
-    Returns:
-        List of formatted strings
-    """
-    lines = generate_pipeline_visualization(width, 20)
-
-    anim_chars = ["▓", "▒", "░", " ", "▓", "▒", "░"]
-    char = anim_chars[frame % len(anim_chars)]
-
-    for i, line in enumerate(lines):
-        if "Effects" in line:
-            lines[i] = line.replace("═" * 5, char * 5)
-
-        if "FPS:" in line:
-            lines[i] = (
-                f"║ FPS: {60 - frame % 10} │ Frame: {16 + frame % 5:.1f}ms │ Effects: {5 - (frame % 3)} active │ Camera: {['VERTICAL', 'HORIZONTAL', 'OMNI', 'FLOATING'][frame % 4]} "
-                + " " * (80 - len(lines[i]) - 2)
-                + "║"
-            )
-
-    return lines

engine/render.py

@@ -15,38 +15,72 @@ from engine.sources import NO_UPPER, SCRIPT_FONTS, SOURCE_LANGS
 from engine.terminal import RST
 from engine.translate import detect_location_language, translate_headline
 
-# ─── GRADIENT ─────────────────────────────────────────────
-# Left → right: white-hot leading edge fades to near-black
-GRAD_COLS = [
-    "\033[1;38;5;231m",  # white
-    "\033[1;38;5;195m",  # pale cyan-white
-    "\033[38;5;123m",  # bright cyan
-    "\033[38;5;118m",  # bright lime
-    "\033[38;5;82m",  # lime
-    "\033[38;5;46m",  # bright green
-    "\033[38;5;40m",  # green
-    "\033[38;5;34m",  # medium green
-    "\033[38;5;28m",  # dark green
-    "\033[38;5;22m",  # deep green
-    "\033[2;38;5;22m",  # dim deep green
-    "\033[2;38;5;235m",  # near black
-]
 
-# Complementary sweep for queue messages (opposite hue family from ticker greens)
-MSG_GRAD_COLS = [
-    "\033[1;38;5;231m",  # white
-    "\033[1;38;5;225m",  # pale pink-white
-    "\033[38;5;219m",  # bright pink
-    "\033[38;5;213m",  # hot pink
-    "\033[38;5;207m",  # magenta
-    "\033[38;5;201m",  # bright magenta
-    "\033[38;5;165m",  # orchid-red
-    "\033[38;5;161m",  # ruby-magenta
-    "\033[38;5;125m",  # dark magenta
-    "\033[38;5;89m",  # deep maroon-magenta
-    "\033[2;38;5;89m",  # dim deep maroon-magenta
-    "\033[2;38;5;235m",  # near black
-]
+# ─── GRADIENT ─────────────────────────────────────────────
+def _color_codes_to_ansi(color_codes):
+    """Convert a list of 256-color codes to ANSI escape code strings.
+
+    Pattern: first 2 are bold, middle 8 are normal, last 2 are dim.
+
+    Args:
+        color_codes: List of 12 integers (256-color palette codes)
+
+    Returns:
+        List of ANSI escape code strings
+    """
+    if not color_codes or len(color_codes) != 12:
+        # Fallback to default green if invalid
+        return _default_green_gradient()
+
+    result = []
+    for i, code in enumerate(color_codes):
+        if i < 2:
+            # Bold for first 2 (bright leading edge)
+            result.append(f"\033[1;38;5;{code}m")
+        elif i < 10:
+            # Normal for middle 8
+            result.append(f"\033[38;5;{code}m")
+        else:
+            # Dim for last 2 (dark trailing edge)
+            result.append(f"\033[2;38;5;{code}m")
+    return result
+
+
+def _default_green_gradient():
+    """Return the default 12-color green gradient for fallback when no theme is active."""
+    return [
+        "\033[1;38;5;231m",  # white
+        "\033[1;38;5;195m",  # pale cyan-white
+        "\033[38;5;123m",  # bright cyan
+        "\033[38;5;118m",  # bright lime
+        "\033[38;5;82m",  # lime
+        "\033[38;5;46m",  # bright green
+        "\033[38;5;40m",  # green
+        "\033[38;5;34m",  # medium green
+        "\033[38;5;28m",  # dark green
+        "\033[38;5;22m",  # deep green
+        "\033[2;38;5;22m",  # dim deep green
+        "\033[2;38;5;235m",  # near black
+    ]
+
+
+def _default_magenta_gradient():
+    """Return the default 12-color magenta gradient for fallback when no theme is active."""
+    return [
+        "\033[1;38;5;231m",  # white
+        "\033[1;38;5;225m",  # pale pink-white
+        "\033[38;5;219m",  # bright pink
+        "\033[38;5;213m",  # hot pink
+        "\033[38;5;207m",  # magenta
+        "\033[38;5;201m",  # bright magenta
+        "\033[38;5;165m",  # orchid-red
+        "\033[38;5;161m",  # ruby-magenta
+        "\033[38;5;125m",  # dark magenta
+        "\033[38;5;89m",  # deep maroon-magenta
+        "\033[2;38;5;89m",  # dim deep maroon-magenta
+        "\033[2;38;5;235m",  # near black
+    ]
+
 
 # ─── FONT LOADING ─────────────────────────────────────────
 _FONT_OBJ = None
@@ -189,9 +223,15 @@ def big_wrap(text, max_w, fnt=None):
     return out
 
 
-def lr_gradient(rows, offset=0.0, grad_cols=None):
+def lr_gradient(rows, offset=0.0, cols=None):
     """Color each non-space block character with a shifting left-to-right gradient."""
-    cols = grad_cols or GRAD_COLS
+    if cols is None:
+        from engine import config
+
+        if config.ACTIVE_THEME:
+            cols = _color_codes_to_ansi(config.ACTIVE_THEME.main_gradient)
+        else:
+            cols = _default_green_gradient()
     n = len(cols)
     max_x = max((len(r.rstrip()) for r in rows if r.strip()), default=1)
     out = []
@@ -213,7 +253,30 @@ def lr_gradient(rows, offset=0.0, grad_cols=None):
 
 def lr_gradient_opposite(rows, offset=0.0):
     """Complementary (opposite wheel) gradient used for queue message panels."""
-    return lr_gradient(rows, offset, MSG_GRAD_COLS)
+    return lr_gradient(rows, offset, _default_magenta_gradient())
+
+
+def msg_gradient(rows, offset):
+    """Apply message (ntfy) gradient using theme complementary colors.
+
+    Returns colored rows using ACTIVE_THEME.message_gradient if available,
+    falling back to default magenta if no theme is set.
+
+    Args:
+        rows: List of text strings to colorize
+        offset: Gradient offset (0.0-1.0) for animation
+
+    Returns:
+        List of rows with ANSI color codes applied
+    """
+    from engine import config
+
+    cols = (
+        _color_codes_to_ansi(config.ACTIVE_THEME.message_gradient)
+        if config.ACTIVE_THEME
+        else _default_magenta_gradient()
+    )
+    return lr_gradient(rows, offset, cols)
 
 
 # ─── HEADLINE BLOCK ASSEMBLY ─────────────────────────────

engine/scroll.py

@@ -7,7 +7,6 @@ import random
 import time
 
 from engine import config
-from engine.camera import Camera
 from engine.display import (
     Display,
     TerminalDisplay,
@@ -28,19 +27,10 @@ from engine.viewport import th, tw
 USE_EFFECT_CHAIN = True
 
 
-def stream(
-    items,
-    ntfy_poller,
-    mic_monitor,
-    display: Display | None = None,
-    camera: Camera | None = None,
-):
+def stream(items, ntfy_poller, mic_monitor, display: Display | None = None):
     """Main render loop with four layers: message, ticker, scroll motion, firehose."""
     if display is None:
         display = TerminalDisplay()
-    if camera is None:
-        camera = Camera.vertical()
-
     random.shuffle(items)
     pool = list(items)
     seen = set()
@@ -56,6 +46,7 @@ def stream(
     scroll_step_interval = calculate_scroll_step(config.SCROLL_DUR, ticker_view_h)
 
     active = []
+    scroll_cam = 0
     ticker_next_y = ticker_view_h
     noise_cache = {}
     scroll_motion_accum = 0.0
@@ -81,10 +72,10 @@ def stream(
         scroll_motion_accum += config.FRAME_DT
         while scroll_motion_accum >= scroll_step_interval:
             scroll_motion_accum -= scroll_step_interval
-            camera.update(config.FRAME_DT)
+            scroll_cam += 1
 
             while (
-                ticker_next_y < camera.y + ticker_view_h + 10
+                ticker_next_y < scroll_cam + ticker_view_h + 10
                 and queued < config.HEADLINE_LIMIT
             ):
                 from engine.effects import next_headline
@@ -97,17 +88,17 @@ def stream(
                 queued += 1
 
             active = [
-                (c, hc, by, mi) for c, hc, by, mi in active if by + len(c) > camera.y
+                (c, hc, by, mi) for c, hc, by, mi in active if by + len(c) > scroll_cam
             ]
             for k in list(noise_cache):
-                if k < camera.y:
+                if k < scroll_cam:
                     del noise_cache[k]
 
         grad_offset = (time.monotonic() * config.GRAD_SPEED) % 1.0
         ticker_buf_start = len(buf)
 
         ticker_buf, noise_cache = render_ticker_zone(
-            active, camera.y, camera.x, ticker_h, w, noise_cache, grad_offset
+            active, scroll_cam, ticker_h, w, noise_cache, grad_offset
         )
         buf.extend(ticker_buf)
 
@@ -119,9 +110,8 @@ def stream(
                 buf,
                 w,
                 h,
-                camera.y,
+                scroll_cam,
                 ticker_h,
-                camera.x,
                 mic_excess,
                 grad_offset,
                 frame_number,

engine/themes.py

@@ -0,0 +1,60 @@
+"""
+Theme definitions with color gradients for terminal rendering.
+
+This module is data-only and does not import config or render
+to prevent circular dependencies.
+"""
+
+
+class Theme:
+    """Represents a color theme with two gradients."""
+
+    def __init__(self, name, main_gradient, message_gradient):
+        """Initialize a theme with name and color gradients.
+
+        Args:
+            name: Theme identifier string
+            main_gradient: List of 12 ANSI 256-color codes for main gradient
+            message_gradient: List of 12 ANSI 256-color codes for message gradient
+        """
+        self.name = name
+        self.main_gradient = main_gradient
+        self.message_gradient = message_gradient
+
+
+# ─── GRADIENT DEFINITIONS ─────────────────────────────────────────────────
+# Each gradient is 12 ANSI 256-color codes in sequence
+# Format: [light...] → [medium...] → [dark...] → [black]
+
+_GREEN_MAIN = [231, 195, 123, 118, 82, 46, 40, 34, 28, 22, 22, 235]
+_GREEN_MSG = [231, 225, 219, 213, 207, 201, 165, 161, 125, 89, 89, 235]
+
+_ORANGE_MAIN = [231, 215, 209, 208, 202, 166, 130, 94, 58, 94, 94, 235]
+_ORANGE_MSG = [231, 195, 33, 27, 21, 21, 21, 18, 18, 18, 18, 235]
+
+_PURPLE_MAIN = [231, 225, 177, 171, 165, 135, 129, 93, 57, 57, 57, 235]
+_PURPLE_MSG = [231, 226, 226, 220, 220, 184, 184, 178, 178, 172, 172, 235]
+
+
+# ─── THEME REGISTRY ───────────────────────────────────────────────────────
+
+THEME_REGISTRY = {
+    "green": Theme("green", _GREEN_MAIN, _GREEN_MSG),
+    "orange": Theme("orange", _ORANGE_MAIN, _ORANGE_MSG),
+    "purple": Theme("purple", _PURPLE_MAIN, _PURPLE_MSG),
+}
+
+
+def get_theme(theme_id):
+    """Retrieve a theme by ID.
+
+    Args:
+        theme_id: Theme identifier string
+
+    Returns:
+        Theme object matching the ID
+
+    Raises:
+        KeyError: If theme_id is not in registry
+    """
+    return THEME_REGISTRY[theme_id]

hk.pkl

@@ -22,9 +22,6 @@ hooks {
                 prefix = "uv run"
                 check = "ruff check engine/ tests/"
             }
-            ["benchmark"] {
-                check = "uv run python -m engine.benchmark --hook --displays null --iterations 20"
-            }
         }
     }
 }

kitty_test.py

@@ -1,31 +0,0 @@
-#!/usr/bin/env python3
-"""Test script for Kitty graphics display."""
-
-import sys
-
-
-def test_kitty_simple():
-    """Test simple Kitty graphics output with embedded PNG."""
-    import base64
-
-    # Minimal 1x1 red pixel PNG (pre-encoded)
-    # This is a tiny valid PNG with a red pixel
-    png_red_1x1 = (
-        b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00"
-        b"\x01\x00\x00\x00\x01\x08\x02\x00\x00\x00\x90wS\xde"
-        b"\x00\x00\x00\x0cIDATx\x9cc\xf8\xcf\xc0\x00\x00\x00"
-        b"\x03\x00\x01\x00\x05\xfe\xd4\x00\x00\x00\x00IEND\xaeB`\x82"
-    )
-
-    encoded = base64.b64encode(png_red_1x1).decode("ascii")
-
-    graphic = f"\x1b_Gf=100,t=d,s=1,v=1,c=1,r=1;{encoded}\x1b\\"
-    sys.stdout.buffer.write(graphic.encode("utf-8"))
-    sys.stdout.flush()
-
-    print("\n[If you see a red dot above, Kitty graphics is working!]")
-    print("[If you see nothing or garbage, it's not working]")
-
-
-if __name__ == "__main__":
-    test_kitty_simple()

mise.toml

@@ -5,90 +5,48 @@ pkl = "latest"
 
 [tasks]
 # =====================
-# Testing
+# Development
 # =====================
 
 test = "uv run pytest"
-test-v = { run = "uv run pytest -v", depends = ["sync-all"] }
-test-cov = { run = "uv run pytest --cov=engine --cov-report=term-missing --cov-report=html", depends = ["sync-all"] }
-test-cov-open = { run = "mise run test-cov && open htmlcov/index.html", depends = ["sync-all"] }
-
-test-browser-install = { run = "uv run playwright install chromium", depends = ["sync-all"] }
-test-browser = { run = "uv run pytest tests/e2e/", depends = ["test-browser-install"] }
-
-# =====================
-# Linting & Formatting
-# =====================
+test-v = "uv run pytest -v"
+test-cov = "uv run pytest --cov=engine --cov-report=term-missing --cov-report=html"
+test-cov-open = "uv run pytest --cov=engine --cov-report=term-missing --cov-report=html && open htmlcov/index.html"
 
 lint = "uv run ruff check engine/ mainline.py"
 lint-fix = "uv run ruff check --fix engine/ mainline.py"
 format = "uv run ruff format engine/ mainline.py"
 
 # =====================
-# Runtime Modes
+# Runtime
 # =====================
 
 run = "uv run mainline.py"
 run-poetry = "uv run mainline.py --poetry"
 run-firehose = "uv run mainline.py --firehose"
 
-run-websocket = { run = "uv run mainline.py --display websocket", depends = ["sync-all"] }
-run-sixel = { run = "uv run mainline.py --display sixel", depends = ["sync-all"] }
-run-kitty = { run = "uv run mainline.py --display kitty", depends = ["sync-all"] }
-run-pygame = { run = "uv run mainline.py --display pygame", depends = ["sync-all"] }
-run-both = { run = "uv run mainline.py --display both", depends = ["sync-all"] }
-run-client = { run = "mise run run-both & sleep 2 && $(open http://localhost:8766 2>/dev/null || xdg-open http://localhost:8766 2>/dev/null || echo 'Open http://localhost:8766 manually'); wait", depends = ["sync-all"] }
-run-demo = { run = "uv run mainline.py --demo --display pygame", depends = ["sync-all"] }
-run-pipeline = "uv run mainline.py --pipeline-diagram"
-run-pipeline-demo = { run = "uv run mainline.py --pipeline-demo --display pygame", depends = ["sync-all"] }
-
-# =====================
-# Command & Control
-# =====================
-
-cmd = "uv run cmdline.py"
-cmd-stats = { run = "uv run cmdline.py -w \"/effects stats\"", depends = ["sync-all"] }
-
-# =====================
-# Benchmark
-# =====================
-
-benchmark = { run = "uv run python -m engine.benchmark", depends = ["sync-all"] }
-benchmark-json = { run = "uv run python -m engine.benchmark --format json --output benchmark.json", depends = ["sync-all"] }
-benchmark-report = { run = "uv run python -m engine.benchmark --output BENCHMARK.md", depends = ["sync-all"] }
-
-# Initialize ntfy topics (warm up before first use)
-topics-init = "curl -s -d 'init' https://ntfy.sh/klubhaus_terminal_mainline_cc_cmd > /dev/null && curl -s -d 'init' https://ntfy.sh/klubhaus_terminal_mainline_cc_resp > /dev/null && curl -s -d 'init' https://ntfy.sh/klubhaus_terminal_mainline > /dev/null"
-
-# =====================
-# Daemon
-# =====================
-
-daemon = "nohup uv run mainline.py > nohup.out 2>&1 &"
-daemon-stop = "pkill -f 'uv run mainline.py' 2>/dev/null || true"
-daemon-restart = "mise run daemon-stop && sleep 2 && mise run daemon"
-
 # =====================
 # Environment
 # =====================
 
 sync = "uv sync"
 sync-all = "uv sync --all-extras"
-install = "mise run sync"
-install-dev = { run = "mise run sync-all && uv sync --group dev", depends = ["sync-all"] }
-bootstrap = { run = "mise run sync-all && uv run mainline.py --help", depends = ["sync-all"] }
+install = "uv sync"
+install-dev = "uv sync --group dev"
 
-clean = "rm -rf .venv htmlcov .coverage tests/.pytest_cache .mainline_cache_*.json nohup.out"
-clobber = "git clean -fdx && rm -rf .venv htmlcov .coverage tests/.pytest_cache .mainline_cache_*.json nohup.out"
+bootstrap = "uv sync && uv run mainline.py --help"
+
+clean = "rm -rf .venv htmlcov .coverage tests/.pytest_cache"
 
 # =====================
 # CI/CD
 # =====================
 
-ci = { run = "mise run topics-init && mise run lint && mise run test-cov", depends = ["topics-init", "lint", "test-cov"] }
+ci = "uv sync --group dev && uv run pytest --cov=engine --cov-report=term-missing --cov-report=xml"
+ci-lint = "uv run ruff check engine/ mainline.py"
 
 # =====================
 # Git Hooks (via hk)
 # =====================
 
-pre-commit = "hk run pre-commit"
+pre-commit = "hk run pre-commit"

pyproject.toml

@@ -30,18 +30,6 @@ mic = [
     "sounddevice>=0.4.0",
     "numpy>=1.24.0",
 ]
-websocket = [
-    "websockets>=12.0",
-]
-sixel = [
-    "Pillow>=10.0.0",
-]
-pygame = [
-    "pygame>=2.0.0",
-]
-browser = [
-    "playwright>=1.40.0",
-]
 dev = [
     "pytest>=8.0.0",
     "pytest-cov>=4.1.0",
@@ -73,10 +61,6 @@ addopts = [
     "--tb=short",
     "-v",
 ]
-markers = [
-    "benchmark: marks tests as performance benchmarks (may be slow)",
-    "e2e: marks tests as end-to-end tests (require network/display)",
-]
 filterwarnings = [
     "ignore::DeprecationWarning",
 ]

tests/e2e/test_web_client.py

@@ -1,133 +0,0 @@
-"""
-End-to-end tests for web client with headless browser.
-"""
-
-import os
-import socketserver
-import threading
-from http.server import HTTPServer, SimpleHTTPRequestHandler
-from pathlib import Path
-
-import pytest
-
-CLIENT_DIR = Path(__file__).parent.parent.parent / "client"
-
-
-class ThreadedHTTPServer(socketserver.ThreadingMixIn, HTTPServer):
-    """Threaded HTTP server for handling concurrent requests."""
-
-    daemon_threads = True
-
-
-@pytest.fixture(scope="module")
-def http_server():
-    """Start a local HTTP server for the client."""
-    os.chdir(CLIENT_DIR)
-
-    handler = SimpleHTTPRequestHandler
-    server = ThreadedHTTPServer(("127.0.0.1", 0), handler)
-    port = server.server_address[1]
-
-    thread = threading.Thread(target=server.serve_forever, daemon=True)
-    thread.start()
-
-    yield f"http://127.0.0.1:{port}"
-
-    server.shutdown()
-
-
-class TestWebClient:
-    """Tests for the web client using Playwright."""
-
-    @pytest.fixture(autouse=True)
-    def setup_browser(self):
-        """Set up browser for tests."""
-        pytest.importorskip("playwright")
-        from playwright.sync_api import sync_playwright
-
-        self.playwright = sync_playwright().start()
-        self.browser = self.playwright.chromium.launch(headless=True)
-        self.context = self.browser.new_context()
-        self.page = self.context.new_page()
-
-        yield
-
-        self.page.close()
-        self.context.close()
-        self.browser.close()
-        self.playwright.stop()
-
-    def test_client_loads(self, http_server):
-        """Web client loads without errors."""
-        response = self.page.goto(http_server)
-        assert response.status == 200, f"Page load failed with status {response.status}"
-
-        self.page.wait_for_load_state("domcontentloaded")
-
-        content = self.page.content()
-        assert "<canvas" in content, "Canvas element not found in page"
-
-        canvas = self.page.locator("#terminal")
-        assert canvas.count() > 0, "Canvas not found"
-
-    def test_status_shows_connecting(self, http_server):
-        """Status shows connecting initially."""
-        self.page.goto(http_server)
-        self.page.wait_for_load_state("domcontentloaded")
-
-        status = self.page.locator("#status")
-        assert status.count() > 0, "Status element not found"
-
-    def test_canvas_has_dimensions(self, http_server):
-        """Canvas has correct dimensions after load."""
-        self.page.goto(http_server)
-        self.page.wait_for_load_state("domcontentloaded")
-
-        canvas = self.page.locator("#terminal")
-        assert canvas.count() > 0, "Canvas not found"
-
-    def test_no_console_errors_on_load(self, http_server):
-        """No JavaScript errors on page load (websocket errors are expected without server)."""
-        js_errors = []
-
-        def handle_console(msg):
-            if msg.type == "error":
-                text = msg.text
-                if "WebSocket" not in text:
-                    js_errors.append(text)
-
-        self.page.on("console", handle_console)
-        self.page.goto(http_server)
-        self.page.wait_for_load_state("domcontentloaded")
-
-        assert len(js_errors) == 0, f"JavaScript errors: {js_errors}"
-
-
-class TestWebClientProtocol:
-    """Tests for WebSocket protocol handling in client."""
-
-    @pytest.fixture(autouse=True)
-    def setup_browser(self):
-        """Set up browser for tests."""
-        pytest.importorskip("playwright")
-        from playwright.sync_api import sync_playwright
-
-        self.playwright = sync_playwright().start()
-        self.browser = self.playwright.chromium.launch(headless=True)
-        self.context = self.browser.new_context()
-        self.page = self.context.new_page()
-
-        yield
-
-        self.page.close()
-        self.context.close()
-        self.browser.close()
-        self.playwright.stop()
-
-    def test_websocket_reconnection(self, http_server):
-        """Client attempts reconnection on disconnect."""
-        self.page.goto(http_server)
-        self.page.wait_for_load_state("domcontentloaded")
-
-        status = self.page.locator("#status")
-        assert status.count() > 0, "Status element not found"

tests/test_app.py

@@ -1,55 +0,0 @@
-"""
-Tests for engine.app module.
-"""
-
-from engine.app import _normalize_preview_rows
-
-
-class TestNormalizePreviewRows:
-    """Tests for _normalize_preview_rows function."""
-
-    def test_empty_rows(self):
-        """Empty input returns empty list."""
-        result = _normalize_preview_rows([])
-        assert result == [""]
-
-    def test_strips_left_padding(self):
-        """Left padding is stripped."""
-        result = _normalize_preview_rows(["  content", "  more"])
-        assert all(not r.startswith(" ") for r in result)
-
-    def test_preserves_content(self):
-        """Content is preserved."""
-        result = _normalize_preview_rows(["  hello world  "])
-        assert "hello world" in result[0]
-
-    def test_handles_all_empty_rows(self):
-        """All empty rows returns single empty string."""
-        result = _normalize_preview_rows(["", "   ", ""])
-        assert result == [""]
-
-
-class TestAppConstants:
-    """Tests for app module constants."""
-
-    def test_title_defined(self):
-        """TITLE is defined."""
-        from engine.app import TITLE
-
-        assert len(TITLE) > 0
-
-    def test_title_lines_are_strings(self):
-        """TITLE contains string lines."""
-        from engine.app import TITLE
-
-        assert all(isinstance(line, str) for line in TITLE)
-
-
-class TestAppImports:
-    """Tests for app module imports."""
-
-    def test_app_imports_without_error(self):
-        """Module imports without error."""
-        from engine import app
-
-        assert app is not None

tests/test_benchmark.py

@@ -1,100 +0,0 @@
-"""
-Tests for engine.benchmark module - performance regression tests.
-"""
-
-from unittest.mock import patch
-
-import pytest
-
-from engine.display import NullDisplay
-
-
-class TestBenchmarkNullDisplay:
-    """Performance tests for NullDisplay - regression tests."""
-
-    @pytest.mark.benchmark
-    def test_null_display_minimum_fps(self):
-        """NullDisplay should meet minimum performance threshold."""
-        import time
-
-        display = NullDisplay()
-        display.init(80, 24)
-        buffer = ["x" * 80 for _ in range(24)]
-
-        iterations = 1000
-        start = time.perf_counter()
-        for _ in range(iterations):
-            display.show(buffer)
-        elapsed = time.perf_counter() - start
-
-        fps = iterations / elapsed
-        min_fps = 20000
-
-        assert fps >= min_fps, f"NullDisplay FPS {fps:.0f} below minimum {min_fps}"
-
-    @pytest.mark.benchmark
-    def test_effects_minimum_throughput(self):
-        """Effects should meet minimum processing throughput."""
-        import time
-
-        from effects_plugins import discover_plugins
-        from engine.effects import EffectContext, get_registry
-
-        discover_plugins()
-        registry = get_registry()
-        effect = registry.get("noise")
-        assert effect is not None, "Noise effect should be registered"
-
-        buffer = ["x" * 80 for _ in range(24)]
-        ctx = EffectContext(
-            terminal_width=80,
-            terminal_height=24,
-            scroll_cam=0,
-            ticker_height=20,
-            mic_excess=0.0,
-            grad_offset=0.0,
-            frame_number=0,
-            has_message=False,
-        )
-
-        iterations = 500
-        start = time.perf_counter()
-        for _ in range(iterations):
-            effect.process(buffer, ctx)
-        elapsed = time.perf_counter() - start
-
-        fps = iterations / elapsed
-        min_fps = 10000
-
-        assert fps >= min_fps, (
-            f"Effect processing FPS {fps:.0f} below minimum {min_fps}"
-        )
-
-
-class TestBenchmarkWebSocketDisplay:
-    """Performance tests for WebSocketDisplay."""
-
-    @pytest.mark.benchmark
-    def test_websocket_display_minimum_fps(self):
-        """WebSocketDisplay should meet minimum performance threshold."""
-        import time
-
-        with patch("engine.display.backends.websocket.websockets", None):
-            from engine.display import WebSocketDisplay
-
-            display = WebSocketDisplay()
-            display.init(80, 24)
-            buffer = ["x" * 80 for _ in range(24)]
-
-            iterations = 500
-            start = time.perf_counter()
-            for _ in range(iterations):
-                display.show(buffer)
-            elapsed = time.perf_counter() - start
-
-            fps = iterations / elapsed
-            min_fps = 10000
-
-            assert fps >= min_fps, (
-                f"WebSocketDisplay FPS {fps:.0f} below minimum {min_fps}"
-            )

tests/test_camera.py

@@ -1,69 +0,0 @@
-
-from engine.camera import Camera, CameraMode
-
-
-def test_camera_vertical_default():
-    """Test default vertical camera."""
-    cam = Camera()
-    assert cam.mode == CameraMode.VERTICAL
-    assert cam.x == 0
-    assert cam.y == 0
-
-
-def test_camera_vertical_factory():
-    """Test vertical factory method."""
-    cam = Camera.vertical(speed=2.0)
-    assert cam.mode == CameraMode.VERTICAL
-    assert cam.speed == 2.0
-
-
-def test_camera_horizontal():
-    """Test horizontal camera."""
-    cam = Camera.horizontal(speed=1.5)
-    assert cam.mode == CameraMode.HORIZONTAL
-    cam.update(1.0)
-    assert cam.x > 0
-
-
-def test_camera_omni():
-    """Test omnidirectional camera."""
-    cam = Camera.omni(speed=1.0)
-    assert cam.mode == CameraMode.OMNI
-    cam.update(1.0)
-    assert cam.x > 0
-    assert cam.y > 0
-
-
-def test_camera_floating():
-    """Test floating camera with sinusoidal motion."""
-    cam = Camera.floating(speed=1.0)
-    assert cam.mode == CameraMode.FLOATING
-    y_before = cam.y
-    cam.update(0.5)
-    y_after = cam.y
-    assert y_before != y_after
-
-
-def test_camera_reset():
-    """Test camera reset."""
-    cam = Camera.vertical()
-    cam.update(1.0)
-    assert cam.y > 0
-    cam.reset()
-    assert cam.x == 0
-    assert cam.y == 0
-
-
-def test_camera_custom_update():
-    """Test custom update function."""
-    call_count = 0
-
-    def custom_update(camera, dt):
-        nonlocal call_count
-        call_count += 1
-        camera.x += int(10 * dt)
-
-    cam = Camera.custom(custom_update)
-    cam.update(1.0)
-    assert call_count == 1
-    assert cam.x == 10

tests/test_controller.py

@@ -5,75 +5,7 @@ Tests for engine.controller module.
 from unittest.mock import MagicMock, patch
 
 from engine import config
-from engine.controller import StreamController, _get_display
-
-
-class TestGetDisplay:
-    """Tests for _get_display function."""
-
-    @patch("engine.controller.WebSocketDisplay")
-    @patch("engine.controller.TerminalDisplay")
-    def test_get_display_terminal(self, mock_terminal, mock_ws):
-        """returns TerminalDisplay for display=terminal."""
-        mock_terminal.return_value = MagicMock()
-        mock_ws.return_value = MagicMock()
-
-        cfg = config.Config(display="terminal")
-        display = _get_display(cfg)
-
-        mock_terminal.assert_called()
-        assert isinstance(display, MagicMock)
-
-    @patch("engine.controller.WebSocketDisplay")
-    @patch("engine.controller.TerminalDisplay")
-    def test_get_display_websocket(self, mock_terminal, mock_ws):
-        """returns WebSocketDisplay for display=websocket."""
-        mock_ws_instance = MagicMock()
-        mock_ws.return_value = mock_ws_instance
-        mock_terminal.return_value = MagicMock()
-
-        cfg = config.Config(display="websocket")
-        _get_display(cfg)
-
-        mock_ws.assert_called()
-        mock_ws_instance.start_server.assert_called()
-        mock_ws_instance.start_http_server.assert_called()
-
-    @patch("engine.controller.SixelDisplay")
-    def test_get_display_sixel(self, mock_sixel):
-        """returns SixelDisplay for display=sixel."""
-        mock_sixel.return_value = MagicMock()
-        cfg = config.Config(display="sixel")
-        _get_display(cfg)
-
-        mock_sixel.assert_called()
-
-    def test_get_display_unknown_returns_null(self):
-        """returns NullDisplay for unknown display mode."""
-        cfg = config.Config(display="unknown")
-        display = _get_display(cfg)
-
-        from engine.display import NullDisplay
-
-        assert isinstance(display, NullDisplay)
-
-    @patch("engine.controller.WebSocketDisplay")
-    @patch("engine.controller.TerminalDisplay")
-    @patch("engine.controller.MultiDisplay")
-    def test_get_display_both(self, mock_multi, mock_terminal, mock_ws):
-        """returns MultiDisplay for display=both."""
-        mock_terminal_instance = MagicMock()
-        mock_ws_instance = MagicMock()
-        mock_terminal.return_value = mock_terminal_instance
-        mock_ws.return_value = mock_ws_instance
-
-        cfg = config.Config(display="both")
-        _get_display(cfg)
-
-        mock_multi.assert_called()
-        call_args = mock_multi.call_args[0][0]
-        assert mock_terminal_instance in call_args
-        assert mock_ws_instance in call_args
+from engine.controller import StreamController
 
 
 class TestStreamController:
@@ -136,24 +68,6 @@ class TestStreamController:
         assert mic_ok is False
         assert ntfy_ok is True
 
-    @patch("engine.controller.MicMonitor")
-    def test_initialize_sources_cc_subscribed(self, mock_mic):
-        """initialize_sources subscribes C&C handler."""
-        mock_mic_instance = MagicMock()
-        mock_mic_instance.available = False
-        mock_mic_instance.start.return_value = False
-        mock_mic.return_value = mock_mic_instance
-
-        with patch("engine.controller.NtfyPoller") as mock_ntfy:
-            mock_ntfy_instance = MagicMock()
-            mock_ntfy_instance.start.return_value = True
-            mock_ntfy.return_value = mock_ntfy_instance
-
-            controller = StreamController()
-            controller.initialize_sources()
-
-            mock_ntfy_instance.subscribe.assert_called()
-
 
 class TestStreamControllerCleanup:
     """Tests for StreamController cleanup."""
@@ -169,3 +83,35 @@ class TestStreamControllerCleanup:
         controller.cleanup()
 
         mock_mic_instance.stop.assert_called_once()
+
+
+class TestStreamControllerWarmup:
+    """Tests for StreamController topic warmup."""
+
+    def test_warmup_topics_idempotent(self):
+        """warmup_topics can be called multiple times."""
+        StreamController._topics_warmed = False
+
+        with patch("urllib.request.urlopen") as mock_urlopen:
+            StreamController.warmup_topics()
+            StreamController.warmup_topics()
+
+            assert mock_urlopen.call_count >= 3
+
+    def test_warmup_topics_sets_flag(self):
+        """warmup_topics sets the warmed flag."""
+        StreamController._topics_warmed = False
+
+        with patch("urllib.request.urlopen"):
+            StreamController.warmup_topics()
+
+            assert StreamController._topics_warmed is True
+
+    def test_warmup_topics_skips_after_first(self):
+        """warmup_topics skips after first call."""
+        StreamController._topics_warmed = True
+
+        with patch("urllib.request.urlopen") as mock_urlopen:
+            StreamController.warmup_topics()
+
+            mock_urlopen.assert_not_called()

tests/test_display.py

@@ -2,10 +2,7 @@
 Tests for engine.display module.
 """
 
-from unittest.mock import MagicMock
-
-from engine.display import DisplayRegistry, NullDisplay, TerminalDisplay
-from engine.display.backends.multi import MultiDisplay
+from engine.display import NullDisplay, TerminalDisplay
 
 
 class TestDisplayProtocol:
@@ -28,66 +25,6 @@ class TestDisplayProtocol:
         assert hasattr(display, "cleanup")
 
 
-class TestDisplayRegistry:
-    """Tests for DisplayRegistry class."""
-
-    def setup_method(self):
-        """Reset registry before each test."""
-        DisplayRegistry._backends = {}
-        DisplayRegistry._initialized = False
-
-    def test_register_adds_backend(self):
-        """register adds a backend to the registry."""
-        DisplayRegistry.register("test", TerminalDisplay)
-        assert DisplayRegistry.get("test") == TerminalDisplay
-
-    def test_register_case_insensitive(self):
-        """register is case insensitive."""
-        DisplayRegistry.register("TEST", TerminalDisplay)
-        assert DisplayRegistry.get("test") == TerminalDisplay
-
-    def test_get_returns_none_for_unknown(self):
-        """get returns None for unknown backend."""
-        assert DisplayRegistry.get("unknown") is None
-
-    def test_list_backends_returns_all(self):
-        """list_backends returns all registered backends."""
-        DisplayRegistry.register("a", TerminalDisplay)
-        DisplayRegistry.register("b", NullDisplay)
-        backends = DisplayRegistry.list_backends()
-        assert "a" in backends
-        assert "b" in backends
-
-    def test_create_returns_instance(self):
-        """create returns a display instance."""
-        DisplayRegistry.register("test", NullDisplay)
-        display = DisplayRegistry.create("test")
-        assert isinstance(display, NullDisplay)
-
-    def test_create_returns_none_for_unknown(self):
-        """create returns None for unknown backend."""
-        display = DisplayRegistry.create("unknown")
-        assert display is None
-
-    def test_initialize_registers_defaults(self):
-        """initialize registers default backends."""
-        DisplayRegistry.initialize()
-        assert DisplayRegistry.get("terminal") == TerminalDisplay
-        assert DisplayRegistry.get("null") == NullDisplay
-        from engine.display.backends.sixel import SixelDisplay
-        from engine.display.backends.websocket import WebSocketDisplay
-
-        assert DisplayRegistry.get("websocket") == WebSocketDisplay
-        assert DisplayRegistry.get("sixel") == SixelDisplay
-
-    def test_initialize_idempotent(self):
-        """initialize can be called multiple times safely."""
-        DisplayRegistry.initialize()
-        DisplayRegistry._backends["custom"] = TerminalDisplay
-        DisplayRegistry.initialize()
-        assert "custom" in DisplayRegistry.list_backends()
-
-
 class TestTerminalDisplay:
     """Tests for TerminalDisplay class."""
 
@@ -140,71 +77,3 @@ class TestNullDisplay:
         """cleanup does nothing."""
         display = NullDisplay()
         display.cleanup()
-
-
-class TestMultiDisplay:
-    """Tests for MultiDisplay class."""
-
-    def test_init_stores_dimensions(self):
-        """init stores dimensions and forwards to displays."""
-        mock_display1 = MagicMock()
-        mock_display2 = MagicMock()
-        multi = MultiDisplay([mock_display1, mock_display2])
-
-        multi.init(120, 40)
-
-        assert multi.width == 120
-        assert multi.height == 40
-        mock_display1.init.assert_called_once_with(120, 40, reuse=False)
-        mock_display2.init.assert_called_once_with(120, 40, reuse=False)
-
-    def test_show_forwards_to_all_displays(self):
-        """show forwards buffer to all displays."""
-        mock_display1 = MagicMock()
-        mock_display2 = MagicMock()
-        multi = MultiDisplay([mock_display1, mock_display2])
-
-        buffer = ["line1", "line2"]
-        multi.show(buffer)
-
-        mock_display1.show.assert_called_once_with(buffer)
-        mock_display2.show.assert_called_once_with(buffer)
-
-    def test_clear_forwards_to_all_displays(self):
-        """clear forwards to all displays."""
-        mock_display1 = MagicMock()
-        mock_display2 = MagicMock()
-        multi = MultiDisplay([mock_display1, mock_display2])
-
-        multi.clear()
-
-        mock_display1.clear.assert_called_once()
-        mock_display2.clear.assert_called_once()
-
-    def test_cleanup_forwards_to_all_displays(self):
-        """cleanup forwards to all displays."""
-        mock_display1 = MagicMock()
-        mock_display2 = MagicMock()
-        multi = MultiDisplay([mock_display1, mock_display2])
-
-        multi.cleanup()
-
-        mock_display1.cleanup.assert_called_once()
-        mock_display2.cleanup.assert_called_once()
-
-    def test_empty_displays_list(self):
-        """handles empty displays list gracefully."""
-        multi = MultiDisplay([])
-        multi.init(80, 24)
-        multi.show(["test"])
-        multi.clear()
-        multi.cleanup()
-
-    def test_init_with_reuse(self):
-        """init passes reuse flag to child displays."""
-        mock_display = MagicMock()
-        multi = MultiDisplay([mock_display])
-
-        multi.init(80, 24, reuse=True)
-
-        mock_display.init.assert_called_once_with(80, 24, reuse=True)

tests/test_effects_controller.py

@@ -5,10 +5,8 @@ Tests for engine.effects.controller module.
 from unittest.mock import MagicMock, patch
 
 from engine.effects.controller import (
-    _format_stats,
     handle_effects_command,
     set_effect_chain_ref,
-    show_effects_menu,
 )
 
 
@@ -94,29 +92,6 @@ class TestHandleEffectsCommand:
                 assert "Reordered pipeline" in result
                 mock_chain_instance.reorder.assert_called_once_with(["noise", "fade"])
 
-    def test_reorder_failure(self):
-        """reorder returns error on failure."""
-        with patch("engine.effects.controller.get_registry") as mock_registry:
-            mock_registry.return_value.list_all.return_value = {}
-
-            with patch("engine.effects.controller._get_effect_chain") as mock_chain:
-                mock_chain_instance = MagicMock()
-                mock_chain_instance.reorder.return_value = False
-                mock_chain.return_value = mock_chain_instance
-
-                result = handle_effects_command("/effects reorder bad")
-
-                assert "Failed to reorder" in result
-
-    def test_unknown_effect(self):
-        """unknown effect returns error."""
-        with patch("engine.effects.controller.get_registry") as mock_registry:
-            mock_registry.return_value.list_all.return_value = {}
-
-            result = handle_effects_command("/effects unknown on")
-
-            assert "Unknown effect" in result
-
     def test_unknown_command(self):
         """unknown command returns error."""
         result = handle_effects_command("/unknown")
@@ -127,105 +102,6 @@ class TestHandleEffectsCommand:
         result = handle_effects_command("not a command")
         assert "Unknown command" in result
 
-    def test_invalid_intensity_value(self):
-        """invalid intensity value returns error."""
-        with patch("engine.effects.controller.get_registry") as mock_registry:
-            mock_plugin = MagicMock()
-            mock_registry.return_value.get.return_value = mock_plugin
-            mock_registry.return_value.list_all.return_value = {"noise": mock_plugin}
-
-            result = handle_effects_command("/effects noise intensity bad")
-
-            assert "Invalid intensity" in result
-
-    def test_missing_action(self):
-        """missing action returns usage."""
-        with patch("engine.effects.controller.get_registry") as mock_registry:
-            mock_plugin = MagicMock()
-            mock_registry.return_value.get.return_value = mock_plugin
-            mock_registry.return_value.list_all.return_value = {"noise": mock_plugin}
-
-            result = handle_effects_command("/effects noise")
-
-            assert "Usage" in result
-
-    def test_stats_command(self):
-        """stats command returns formatted stats."""
-        with patch("engine.effects.controller.get_monitor") as mock_monitor:
-            mock_monitor.return_value.get_stats.return_value = {
-                "frame_count": 100,
-                "pipeline": {"avg_ms": 1.5, "min_ms": 1.0, "max_ms": 2.0},
-                "effects": {},
-            }
-
-            result = handle_effects_command("/effects stats")
-
-            assert "Performance Stats" in result
-
-    def test_list_only_effects(self):
-        """list command works with just /effects."""
-        with patch("engine.effects.controller.get_registry") as mock_registry:
-            mock_plugin = MagicMock()
-            mock_plugin.config.enabled = False
-            mock_plugin.config.intensity = 0.5
-            mock_registry.return_value.list_all.return_value = {"noise": mock_plugin}
-
-            with patch("engine.effects.controller._get_effect_chain") as mock_chain:
-                mock_chain.return_value = None
-
-                result = handle_effects_command("/effects")
-
-                assert "noise: OFF" in result
-
-
-class TestShowEffectsMenu:
-    """Tests for show_effects_menu function."""
-
-    def test_returns_formatted_menu(self):
-        """returns formatted effects menu."""
-        with patch("engine.effects.controller.get_registry") as mock_registry:
-            mock_plugin = MagicMock()
-            mock_plugin.config.enabled = True
-            mock_plugin.config.intensity = 0.75
-            mock_registry.return_value.list_all.return_value = {"noise": mock_plugin}
-
-            with patch("engine.effects.controller._get_effect_chain") as mock_chain:
-                mock_chain_instance = MagicMock()
-                mock_chain_instance.get_order.return_value = ["noise"]
-                mock_chain.return_value = mock_chain_instance
-
-                result = show_effects_menu()
-
-                assert "EFFECTS MENU" in result
-                assert "noise" in result
-
-
-class TestFormatStats:
-    """Tests for _format_stats function."""
-
-    def test_returns_error_when_no_monitor(self):
-        """returns error when monitor unavailable."""
-        with patch("engine.effects.controller.get_monitor") as mock_monitor:
-            mock_monitor.return_value.get_stats.return_value = {"error": "No data"}
-
-            result = _format_stats()
-
-            assert "No data" in result
-
-    def test_formats_pipeline_stats(self):
-        """formats pipeline stats correctly."""
-        with patch("engine.effects.controller.get_monitor") as mock_monitor:
-            mock_monitor.return_value.get_stats.return_value = {
-                "frame_count": 50,
-                "pipeline": {"avg_ms": 2.5, "min_ms": 2.0, "max_ms": 3.0},
-                "effects": {"noise": {"avg_ms": 0.5, "min_ms": 0.4, "max_ms": 0.6}},
-            }
-
-            result = _format_stats()
-
-            assert "Pipeline" in result
-            assert "noise" in result
-
 
 class TestSetEffectChainRef:
     """Tests for set_effect_chain_ref function."""

tests/test_fetch.py

@@ -1,234 +0,0 @@
-"""
-Tests for engine.fetch module.
-"""
-
-import json
-from unittest.mock import MagicMock, patch
-
-from engine.fetch import (
-    _fetch_gutenberg,
-    fetch_all,
-    fetch_feed,
-    fetch_poetry,
-    load_cache,
-    save_cache,
-)
-
-
-class TestFetchFeed:
-    """Tests for fetch_feed function."""
-
-    @patch("engine.fetch.urllib.request.urlopen")
-    def test_fetch_success(self, mock_urlopen):
-        """Successful feed fetch returns parsed feed."""
-        mock_response = MagicMock()
-        mock_response.read.return_value = b"<rss>test</rss>"
-        mock_urlopen.return_value = mock_response
-
-        result = fetch_feed("http://example.com/feed")
-
-        assert result is not None
-
-    @patch("engine.fetch.urllib.request.urlopen")
-    def test_fetch_network_error(self, mock_urlopen):
-        """Network error returns None."""
-        mock_urlopen.side_effect = Exception("Network error")
-
-        result = fetch_feed("http://example.com/feed")
-
-        assert result is None
-
-
-class TestFetchAll:
-    """Tests for fetch_all function."""
-
-    @patch("engine.fetch.fetch_feed")
-    @patch("engine.fetch.strip_tags")
-    @patch("engine.fetch.skip")
-    @patch("engine.fetch.boot_ln")
-    def test_fetch_all_success(self, mock_boot, mock_skip, mock_strip, mock_fetch_feed):
-        """Successful fetch returns items."""
-        mock_feed = MagicMock()
-        mock_feed.bozo = False
-        mock_feed.entries = [
-            {"title": "Headline 1", "published_parsed": (2024, 1, 1, 12, 0, 0)},
-            {"title": "Headline 2", "updated_parsed": (2024, 1, 2, 12, 0, 0)},
-        ]
-        mock_fetch_feed.return_value = mock_feed
-        mock_skip.return_value = False
-        mock_strip.side_effect = lambda x: x
-
-        items, linked, failed = fetch_all()
-
-        assert linked > 0
-        assert failed == 0
-
-    @patch("engine.fetch.fetch_feed")
-    @patch("engine.fetch.boot_ln")
-    def test_fetch_all_feed_error(self, mock_boot, mock_fetch_feed):
-        """Feed error increments failed count."""
-        mock_fetch_feed.return_value = None
-
-        items, linked, failed = fetch_all()
-
-        assert failed > 0
-
-    @patch("engine.fetch.fetch_feed")
-    @patch("engine.fetch.strip_tags")
-    @patch("engine.fetch.skip")
-    @patch("engine.fetch.boot_ln")
-    def test_fetch_all_skips_filtered(
-        self, mock_boot, mock_skip, mock_strip, mock_fetch_feed
-    ):
-        """Filtered headlines are skipped."""
-        mock_feed = MagicMock()
-        mock_feed.bozo = False
-        mock_feed.entries = [
-            {"title": "Sports scores"},
-            {"title": "Valid headline"},
-        ]
-        mock_fetch_feed.return_value = mock_feed
-        mock_skip.side_effect = lambda x: x == "Sports scores"
-        mock_strip.side_effect = lambda x: x
-
-        items, linked, failed = fetch_all()
-
-        assert any("Valid headline" in item[0] for item in items)
-
-
-class TestFetchGutenberg:
-    """Tests for _fetch_gutenberg function."""
-
-    @patch("engine.fetch.urllib.request.urlopen")
-    def test_gutenberg_success(self, mock_urlopen):
-        """Successful gutenberg fetch returns items."""
-        text = """Project Gutenberg
-
-*** START OF THE PROJECT GUTENBERG ***
-This is a test poem with multiple lines
-that should be parsed as a block.
-
-Another stanza with more content here.
-
-*** END OF THE PROJECT GUTENBERG ***
-"""
-        mock_response = MagicMock()
-        mock_response.read.return_value = text.encode("utf-8")
-        mock_urlopen.return_value = mock_response
-
-        result = _fetch_gutenberg("http://example.com/test", "Test")
-
-        assert len(result) > 0
-
-    @patch("engine.fetch.urllib.request.urlopen")
-    def test_gutenberg_network_error(self, mock_urlopen):
-        """Network error returns empty list."""
-        mock_urlopen.side_effect = Exception("Network error")
-
-        result = _fetch_gutenberg("http://example.com/test", "Test")
-
-        assert result == []
-
-    @patch("engine.fetch.urllib.request.urlopen")
-    def test_gutenberg_skips_short_blocks(self, mock_urlopen):
-        """Blocks shorter than 20 chars are skipped."""
-        text = """*** START OF THE ***
-Short
-*** END OF THE ***
-"""
-        mock_response = MagicMock()
-        mock_response.read.return_value = text.encode("utf-8")
-        mock_urlopen.return_value = mock_response
-
-        result = _fetch_gutenberg("http://example.com/test", "Test")
-
-        assert result == []
-
-    @patch("engine.fetch.urllib.request.urlopen")
-    def test_gutenberg_skips_all_caps_headers(self, mock_urlopen):
-        """All-caps lines are skipped as headers."""
-        text = """*** START OF THE ***
-THIS IS ALL CAPS HEADER
-more content here
-*** END OF THE ***
-"""
-        mock_response = MagicMock()
-        mock_response.read.return_value = text.encode("utf-8")
-        mock_urlopen.return_value = mock_response
-
-        result = _fetch_gutenberg("http://example.com/test", "Test")
-
-        assert len(result) > 0
-
-
-class TestFetchPoetry:
-    """Tests for fetch_poetry function."""
-
-    @patch("engine.fetch._fetch_gutenberg")
-    @patch("engine.fetch.boot_ln")
-    def test_fetch_poetry_success(self, mock_boot, mock_fetch):
-        """Successful poetry fetch returns items."""
-        mock_fetch.return_value = [
-            ("Stanza 1 content here", "Test", ""),
-            ("Stanza 2 content here", "Test", ""),
-        ]
-
-        items, linked, failed = fetch_poetry()
-
-        assert linked > 0
-        assert failed == 0
-
-    @patch("engine.fetch._fetch_gutenberg")
-    @patch("engine.fetch.boot_ln")
-    def test_fetch_poetry_failure(self, mock_boot, mock_fetch):
-        """Failed fetch increments failed count."""
-        mock_fetch.return_value = []
-
-        items, linked, failed = fetch_poetry()
-
-        assert failed > 0
-
-
-class TestCache:
-    """Tests for cache functions."""
-
-    @patch("engine.fetch._cache_path")
-    def test_load_cache_success(self, mock_path):
-        """Successful cache load returns items."""
-        mock_path.return_value.__str__ = MagicMock(return_value="/tmp/cache")
-        mock_path.return_value.exists.return_value = True
-        mock_path.return_value.read_text.return_value = json.dumps(
-            {"items": [("title", "source", "time")]}
-        )
-
-        result = load_cache()
-
-        assert result is not None
-
-    @patch("engine.fetch._cache_path")
-    def test_load_cache_missing_file(self, mock_path):
-        """Missing cache file returns None."""
-        mock_path.return_value.exists.return_value = False
-
-        result = load_cache()
-
-        assert result is None
-
-    @patch("engine.fetch._cache_path")
-    def test_load_cache_invalid_json(self, mock_path):
-        """Invalid JSON returns None."""
-        mock_path.return_value.exists.return_value = True
-        mock_path.return_value.read_text.side_effect = json.JSONDecodeError("", "", 0)
-
-        result = load_cache()
-
-        assert result is None
-
-    @patch("engine.fetch._cache_path")
-    def test_save_cache_success(self, mock_path):
-        """Save cache writes to file."""
-        mock_path.return_value.__truediv__ = MagicMock(
-            return_value=mock_path.return_value
-        )
-
-        save_cache([("title", "source", "time")])

tests/test_fetch_code.py

@@ -0,0 +1,35 @@
+import re
+
+from engine.fetch_code import fetch_code
+
+
+def test_return_shape():
+    items, line_count, ignored = fetch_code()
+    assert isinstance(items, list)
+    assert line_count == len(items)
+    assert ignored == 0
+
+
+def test_items_are_tuples():
+    items, _, _ = fetch_code()
+    assert items, "expected at least one code line"
+    for item in items:
+        assert isinstance(item, tuple) and len(item) == 3
+        text, src, ts = item
+        assert isinstance(text, str)
+        assert isinstance(src, str)
+        assert isinstance(ts, str)
+
+
+def test_blank_and_comment_lines_excluded():
+    items, _, _ = fetch_code()
+    for text, _, _ in items:
+        assert text.strip(), "blank line should have been filtered"
+        assert not text.strip().startswith("#"), "comment line should have been filtered"
+
+
+def test_module_path_format():
+    items, _, _ = fetch_code()
+    pattern = re.compile(r"^engine\.\w+$")
+    for _, _, ts in items:
+        assert pattern.match(ts), f"unexpected module path: {ts!r}"

tests/test_hud.py

@@ -1,107 +0,0 @@
-
-from engine.effects.performance import PerformanceMonitor, set_monitor
-from engine.effects.types import EffectContext
-
-
-def test_hud_effect_adds_hud_lines():
-    """Test that HUD effect adds HUD lines to the buffer."""
-    from effects_plugins.hud import HudEffect
-
-    set_monitor(PerformanceMonitor())
-
-    hud = HudEffect()
-    hud.config.params["display_effect"] = "noise"
-    hud.config.params["display_intensity"] = 0.5
-
-    ctx = EffectContext(
-        terminal_width=80,
-        terminal_height=24,
-        scroll_cam=0,
-        ticker_height=24,
-        mic_excess=0.0,
-        grad_offset=0.0,
-        frame_number=0,
-        has_message=False,
-        items=[],
-    )
-
-    buf = [
-        "A" * 80,
-        "B" * 80,
-        "C" * 80,
-    ]
-
-    result = hud.process(buf, ctx)
-
-    assert len(result) >= 3, f"Expected at least 3 lines, got {len(result)}"
-
-    first_line = result[0]
-    assert "MAINLINE DEMO" in first_line, (
-        f"HUD not found in first line: {first_line[:50]}"
-    )
-
-    second_line = result[1]
-    assert "EFFECT:" in second_line, f"Effect line not found: {second_line[:50]}"
-
-    print("First line:", result[0])
-    print("Second line:", result[1])
-    if len(result) > 2:
-        print("Third line:", result[2])
-
-
-def test_hud_effect_shows_current_effect():
-    """Test that HUD displays the correct effect name."""
-    from effects_plugins.hud import HudEffect
-
-    set_monitor(PerformanceMonitor())
-
-    hud = HudEffect()
-    hud.config.params["display_effect"] = "fade"
-    hud.config.params["display_intensity"] = 0.75
-
-    ctx = EffectContext(
-        terminal_width=80,
-        terminal_height=24,
-        scroll_cam=0,
-        ticker_height=24,
-        mic_excess=0.0,
-        grad_offset=0.0,
-        frame_number=0,
-        has_message=False,
-        items=[],
-    )
-
-    buf = ["X" * 80]
-    result = hud.process(buf, ctx)
-
-    second_line = result[1]
-    assert "fade" in second_line, f"Effect name 'fade' not found in: {second_line}"
-
-
-def test_hud_effect_shows_intensity():
-    """Test that HUD displays intensity percentage."""
-    from effects_plugins.hud import HudEffect
-
-    set_monitor(PerformanceMonitor())
-
-    hud = HudEffect()
-    hud.config.params["display_effect"] = "glitch"
-    hud.config.params["display_intensity"] = 0.8
-
-    ctx = EffectContext(
-        terminal_width=80,
-        terminal_height=24,
-        scroll_cam=0,
-        ticker_height=24,
-        mic_excess=0.0,
-        grad_offset=0.0,
-        frame_number=0,
-        has_message=False,
-        items=[],
-    )
-
-    buf = ["Y" * 80]
-    result = hud.process(buf, ctx)
-
-    second_line = result[1]
-    assert "80%" in second_line, f"Intensity 80% not found in: {second_line}"

tests/test_layers.py

@@ -87,26 +87,10 @@ class TestRenderTickerZone:
 
     def test_returns_list(self):
         """Returns a list of strings."""
-        result, cache = layers.render_ticker_zone(
-            [],
-            scroll_cam=0,
-            camera_x=0,
-            ticker_h=10,
-            w=80,
-            noise_cache={},
-            grad_offset=0.0,
-        )
+        result, cache = layers.render_ticker_zone([], 0, 10, 80, {}, 0.0)
         assert isinstance(result, list)
 
     def test_returns_dict_for_cache(self):
         """Returns a dict for the noise cache."""
-        result, cache = layers.render_ticker_zone(
-            [],
-            scroll_cam=0,
-            camera_x=0,
-            ticker_h=10,
-            w=80,
-            noise_cache={},
-            grad_offset=0.0,
-        )
+        result, cache = layers.render_ticker_zone([], 0, 10, 80, {}, 0.0)
         assert isinstance(cache, dict)

tests/test_ntfy_integration.py

@@ -1,127 +0,0 @@
-"""
-Integration tests for ntfy topics.
-"""
-
-import json
-import time
-import urllib.request
-
-
-class TestNtfyTopics:
-    def test_cc_cmd_topic_exists_and_writable(self):
-        """Verify C&C CMD topic exists and accepts messages."""
-        from engine.config import NTFY_CC_CMD_TOPIC
-
-        topic_url = NTFY_CC_CMD_TOPIC.replace("/json", "")
-        test_message = f"test_{int(time.time())}"
-
-        req = urllib.request.Request(
-            topic_url,
-            data=test_message.encode("utf-8"),
-            headers={
-                "User-Agent": "mainline-test/0.1",
-                "Content-Type": "text/plain",
-            },
-            method="POST",
-        )
-
-        try:
-            with urllib.request.urlopen(req, timeout=10) as resp:
-                assert resp.status == 200
-        except Exception as e:
-            raise AssertionError(f"Failed to write to C&C CMD topic: {e}") from e
-
-    def test_cc_resp_topic_exists_and_writable(self):
-        """Verify C&C RESP topic exists and accepts messages."""
-        from engine.config import NTFY_CC_RESP_TOPIC
-
-        topic_url = NTFY_CC_RESP_TOPIC.replace("/json", "")
-        test_message = f"test_{int(time.time())}"
-
-        req = urllib.request.Request(
-            topic_url,
-            data=test_message.encode("utf-8"),
-            headers={
-                "User-Agent": "mainline-test/0.1",
-                "Content-Type": "text/plain",
-            },
-            method="POST",
-        )
-
-        try:
-            with urllib.request.urlopen(req, timeout=10) as resp:
-                assert resp.status == 200
-        except Exception as e:
-            raise AssertionError(f"Failed to write to C&C RESP topic: {e}") from e
-
-    def test_message_topic_exists_and_writable(self):
-        """Verify message topic exists and accepts messages."""
-        from engine.config import NTFY_TOPIC
-
-        topic_url = NTFY_TOPIC.replace("/json", "")
-        test_message = f"test_{int(time.time())}"
-
-        req = urllib.request.Request(
-            topic_url,
-            data=test_message.encode("utf-8"),
-            headers={
-                "User-Agent": "mainline-test/0.1",
-                "Content-Type": "text/plain",
-            },
-            method="POST",
-        )
-
-        try:
-            with urllib.request.urlopen(req, timeout=10) as resp:
-                assert resp.status == 200
-        except Exception as e:
-            raise AssertionError(f"Failed to write to message topic: {e}") from e
-
-    def test_cc_cmd_topic_readable(self):
-        """Verify we can read messages from C&C CMD topic."""
-        from engine.config import NTFY_CC_CMD_TOPIC
-
-        test_message = f"integration_test_{int(time.time())}"
-        topic_url = NTFY_CC_CMD_TOPIC.replace("/json", "")
-
-        req = urllib.request.Request(
-            topic_url,
-            data=test_message.encode("utf-8"),
-            headers={
-                "User-Agent": "mainline-test/0.1",
-                "Content-Type": "text/plain",
-            },
-            method="POST",
-        )
-
-        try:
-            urllib.request.urlopen(req, timeout=10)
-        except Exception as e:
-            raise AssertionError(f"Failed to write to C&C CMD topic: {e}") from e
-
-        time.sleep(1)
-
-        poll_url = f"{NTFY_CC_CMD_TOPIC}?poll=1&limit=1"
-        req = urllib.request.Request(
-            poll_url,
-            headers={"User-Agent": "mainline-test/0.1"},
-        )
-
-        try:
-            with urllib.request.urlopen(req, timeout=10) as resp:
-                body = resp.read().decode("utf-8")
-                if body.strip():
-                    data = json.loads(body.split("\n")[0])
-                    assert isinstance(data, dict)
-        except Exception as e:
-            raise AssertionError(f"Failed to read from C&C CMD topic: {e}") from e
-
-    def test_topics_are_different(self):
-        """Verify C&C CMD/RESP and message topics are different."""
-        from engine.config import NTFY_CC_CMD_TOPIC, NTFY_CC_RESP_TOPIC, NTFY_TOPIC
-
-        assert NTFY_CC_CMD_TOPIC != NTFY_TOPIC
-        assert NTFY_CC_RESP_TOPIC != NTFY_TOPIC
-        assert NTFY_CC_CMD_TOPIC != NTFY_CC_RESP_TOPIC
-        assert "_cc_cmd" in NTFY_CC_CMD_TOPIC
-        assert "_cc_resp" in NTFY_CC_RESP_TOPIC

tests/test_render.py

@@ -2,231 +2,300 @@
 Tests for engine.render module.
 """
 
-from unittest.mock import MagicMock, patch
-
 import pytest
 
-from engine.render import (
-    GRAD_COLS,
-    MSG_GRAD_COLS,
-    clear_font_cache,
-    font_for_lang,
-    lr_gradient,
-    lr_gradient_opposite,
-    make_block,
-)
+from engine import config, render
 
 
-class TestGradientConstants:
-    """Tests for gradient color constants."""
+class TestDefaultGradients:
+    """Tests for default gradient fallback functions."""
 
-    def test_grad_cols_defined(self):
-        """GRAD_COLS is defined with expected length."""
-        assert len(GRAD_COLS) > 0
-        assert all(isinstance(c, str) for c in GRAD_COLS)
+    def test_default_green_gradient_length(self):
+        """_default_green_gradient returns 12 colors."""
+        gradient = render._default_green_gradient()
+        assert len(gradient) == 12
 
-    def test_msg_grad_cols_defined(self):
-        """MSG_GRAD_COLS is defined with expected length."""
-        assert len(MSG_GRAD_COLS) > 0
-        assert all(isinstance(c, str) for c in MSG_GRAD_COLS)
+    def test_default_green_gradient_is_list(self):
+        """_default_green_gradient returns a list."""
+        gradient = render._default_green_gradient()
+        assert isinstance(gradient, list)
 
-    def test_grad_cols_start_with_white(self):
-        """GRAD_COLS starts with white."""
-        assert "231" in GRAD_COLS[0]
+    def test_default_green_gradient_all_strings(self):
+        """_default_green_gradient returns list of ANSI code strings."""
+        gradient = render._default_green_gradient()
+        assert all(isinstance(code, str) for code in gradient)
 
-    def test_msg_grad_cols_different_from_grad_cols(self):
-        """MSG_GRAD_COLS is different from GRAD_COLS."""
-        assert MSG_GRAD_COLS != GRAD_COLS
+    def test_default_magenta_gradient_length(self):
+        """_default_magenta_gradient returns 12 colors."""
+        gradient = render._default_magenta_gradient()
+        assert len(gradient) == 12
+
+    def test_default_magenta_gradient_is_list(self):
+        """_default_magenta_gradient returns a list."""
+        gradient = render._default_magenta_gradient()
+        assert isinstance(gradient, list)
+
+    def test_default_magenta_gradient_all_strings(self):
+        """_default_magenta_gradient returns list of ANSI code strings."""
+        gradient = render._default_magenta_gradient()
+        assert all(isinstance(code, str) for code in gradient)
 
 
-class TestLrGradient:
-    """Tests for lr_gradient function."""
+class TestLrGradientUsesActiveTheme:
+    """Tests for lr_gradient using active theme."""
 
-    def test_empty_rows(self):
-        """Empty input returns empty output."""
-        result = lr_gradient([], 0.0)
-        assert result == []
+    def test_lr_gradient_uses_active_theme_when_cols_none(self):
+        """lr_gradient uses ACTIVE_THEME.main_gradient when cols=None."""
+        # Save original state
+        original_theme = config.ACTIVE_THEME
 
-    def test_preserves_empty_rows(self):
-        """Empty rows are preserved."""
-        result = lr_gradient([""], 0.0)
-        assert result == [""]
+        try:
+            # Set a theme
+            config.set_active_theme("green")
 
-    def test_adds_gradient_to_content(self):
-        """Non-empty rows get gradient coloring."""
-        result = lr_gradient(["hello"], 0.0)
+            # Create simple test data
+            rows = ["text"]
+
+            # Call without cols parameter (cols=None)
+            result = render.lr_gradient(rows, offset=0.0)
+
+            # Should not raise and should return colored output
+            assert isinstance(result, list)
+            assert len(result) == 1
+            # Should have ANSI codes (no plain "text")
+            assert result[0] != "text"
+        finally:
+            # Restore original state
+            config.ACTIVE_THEME = original_theme
+
+    def test_lr_gradient_fallback_when_no_theme(self):
+        """lr_gradient uses fallback green when ACTIVE_THEME is None."""
+        # Save original state
+        original_theme = config.ACTIVE_THEME
+
+        try:
+            # Clear the theme
+            config.ACTIVE_THEME = None
+
+            # Create simple test data
+            rows = ["text"]
+
+            # Call without cols parameter (should use fallback)
+            result = render.lr_gradient(rows, offset=0.0)
+
+            # Should not raise and should return colored output
+            assert isinstance(result, list)
+            assert len(result) == 1
+            # Should have ANSI codes (no plain "text")
+            assert result[0] != "text"
+        finally:
+            # Restore original state
+            config.ACTIVE_THEME = original_theme
+
+    def test_lr_gradient_explicit_cols_parameter_still_works(self):
+        """lr_gradient with explicit cols parameter overrides theme."""
+        # Custom gradient
+        custom_cols = ["\033[38;5;1m", "\033[38;5;2m"] * 6
+
+        rows = ["xy"]
+        result = render.lr_gradient(rows, offset=0.0, cols=custom_cols)
+
+        # Should use the provided cols
+        assert isinstance(result, list)
         assert len(result) == 1
-        assert "\033[" in result[0]
 
-    def test_preserves_spaces(self):
-        """Spaces are preserved without coloring."""
-        result = lr_gradient(["hello world"], 0.0)
-        assert " " in result[0]
+    def test_lr_gradient_respects_cols_parameter_name(self):
+        """lr_gradient accepts cols as keyword argument."""
+        custom_cols = ["\033[38;5;1m", "\033[38;5;2m"] * 6
 
-    def test_offset_wraps_around(self):
-        """Offset wraps around at 1.0."""
-        result1 = lr_gradient(["hello"], 0.0)
-        result2 = lr_gradient(["hello"], 1.0)
-        assert result1 != result2 or result1 == result2
+        rows = ["xy"]
+        # Call with cols as keyword
+        result = render.lr_gradient(rows, offset=0.0, cols=custom_cols)
+
+        assert isinstance(result, list)
 
 
-class TestLrGradientOpposite:
-    """Tests for lr_gradient_opposite function."""
+class TestLrGradientBasicFunctionality:
+    """Tests to ensure lr_gradient basic functionality still works."""
 
-    def test_uses_msg_grad_cols(self):
-        """Uses MSG_GRAD_COLS instead of GRAD_COLS."""
-        result = lr_gradient_opposite(["test"])
-        assert "\033[" in result[0]
+    def test_lr_gradient_colors_non_space_chars(self):
+        """lr_gradient colors non-space characters."""
+        rows = ["hello"]
 
+        # Set a theme for the test
+        original_theme = config.ACTIVE_THEME
+        try:
+            config.set_active_theme("green")
+            result = render.lr_gradient(rows, offset=0.0)
 
-class TestClearFontCache:
-    """Tests for clear_font_cache function."""
+            # Result should have ANSI codes
+            assert any("\033[" in r for r in result), "Expected ANSI codes in result"
+        finally:
+            config.ACTIVE_THEME = original_theme
 
-    def test_clears_without_error(self):
-        """Function runs without error."""
-        clear_font_cache()
+    def test_lr_gradient_preserves_spaces(self):
+        """lr_gradient preserves spaces in output."""
+        rows = ["a b c"]
 
+        original_theme = config.ACTIVE_THEME
+        try:
+            config.set_active_theme("green")
+            result = render.lr_gradient(rows, offset=0.0)
 
-class TestFontForLang:
-    """Tests for font_for_lang function."""
+            # Spaces should be preserved (not colored)
+            assert " " in result[0]
+        finally:
+            config.ACTIVE_THEME = original_theme
 
-    @patch("engine.render.font")
-    def test_returns_default_for_none(self, mock_font):
-        """Returns default font when lang is None."""
-        result = font_for_lang(None)
-        assert result is not None
+    def test_lr_gradient_empty_rows(self):
+        """lr_gradient handles empty rows correctly."""
+        rows = [""]
 
-    @patch("engine.render.font")
-    def test_returns_default_for_unknown_lang(self, mock_font):
-        """Returns default font for unknown language."""
-        result = font_for_lang("unknown_lang")
-        assert result is not None
+        original_theme = config.ACTIVE_THEME
+        try:
+            config.set_active_theme("green")
+            result = render.lr_gradient(rows, offset=0.0)
 
-
-class TestMakeBlock:
-    """Tests for make_block function."""
-
-    @patch("engine.translate.translate_headline")
-    @patch("engine.translate.detect_location_language")
-    @patch("engine.render.font_for_lang")
-    @patch("engine.render.big_wrap")
-    @patch("engine.render.random")
-    def test_make_block_basic(
-        self, mock_random, mock_wrap, mock_font, mock_detect, mock_translate
-    ):
-        """Basic make_block returns content, color, meta index."""
-        mock_wrap.return_value = ["Headline content", ""]
-        mock_random.choice.return_value = "\033[38;5;46m"
-
-        content, color, meta_idx = make_block(
-            "Test headline", "TestSource", "12:00", 80
-        )
-
-        assert len(content) > 0
-        assert color is not None
-        assert meta_idx >= 0
-
-    @pytest.mark.skip(reason="Requires full PIL/font environment")
-    @patch("engine.translate.translate_headline")
-    @patch("engine.translate.detect_location_language")
-    @patch("engine.render.font_for_lang")
-    @patch("engine.render.big_wrap")
-    @patch("engine.render.random")
-    def test_make_block_translation(
-        self, mock_random, mock_wrap, mock_font, mock_detect, mock_translate
-    ):
-        """Translation is applied when mode is news."""
-        mock_wrap.return_value = ["Translated"]
-        mock_random.choice.return_value = "\033[38;5;46m"
-        mock_detect.return_value = "de"
-
-        with patch("engine.config.MODE", "news"):
-            content, _, _ = make_block("Test", "Source", "12:00", 80)
-            mock_translate.assert_called_once()
-
-    @patch("engine.translate.translate_headline")
-    @patch("engine.translate.detect_location_language")
-    @patch("engine.render.font_for_lang")
-    @patch("engine.render.big_wrap")
-    @patch("engine.render.random")
-    def test_make_block_no_translation_poetry(
-        self, mock_random, mock_wrap, mock_font, mock_detect, mock_translate
-    ):
-        """No translation when mode is poetry."""
-        mock_wrap.return_value = ["Poem content"]
-        mock_random.choice.return_value = "\033[38;5;46m"
-
-        with patch("engine.config.MODE", "poetry"):
-            make_block("Test", "Source", "12:00", 80)
-            mock_translate.assert_not_called()
-
-    @patch("engine.translate.translate_headline")
-    @patch("engine.translate.detect_location_language")
-    @patch("engine.render.font_for_lang")
-    @patch("engine.render.big_wrap")
-    @patch("engine.render.random")
-    def test_make_block_meta_format(
-        self, mock_random, mock_wrap, mock_font, mock_detect, mock_translate
-    ):
-        """Meta line includes source and timestamp."""
-        mock_wrap.return_value = ["Content"]
-        mock_random.choice.return_value = "\033[38;5;46m"
-
-        content, _, meta_idx = make_block("Test", "MySource", "14:30", 80)
-
-        meta_line = content[meta_idx]
-        assert "MySource" in meta_line
-        assert "14:30" in meta_line
-
-
-class TestRenderLine:
-    """Tests for render_line function."""
-
-    def test_empty_string(self):
-        """Empty string returns empty list."""
-        from engine.render import render_line
-
-        result = render_line("")
-        assert result == [""]
-
-    @pytest.mark.skip(reason="Requires real font/PIL setup")
-    def test_uses_default_font(self):
-        """Uses default font when none provided."""
-        from engine.render import render_line
-
-        with patch("engine.render.font") as mock_font:
-            mock_font.return_value = MagicMock()
-            mock_font.return_value.getbbox.return_value = (0, 0, 10, 10)
-            render_line("test")
-
-    def test_getbbox_returns_none(self):
-        """Handles None bbox gracefully."""
-        from engine.render import render_line
-
-        with patch("engine.render.font") as mock_font:
-            mock_font.return_value = MagicMock()
-            mock_font.return_value.getbbox.return_value = None
-            result = render_line("test")
             assert result == [""]
+        finally:
+            config.ACTIVE_THEME = original_theme
+
+    def test_lr_gradient_multiple_rows(self):
+        """lr_gradient handles multiple rows."""
+        rows = ["row1", "row2", "row3"]
+
+        original_theme = config.ACTIVE_THEME
+        try:
+            config.set_active_theme("green")
+            result = render.lr_gradient(rows, offset=0.0)
+
+            assert len(result) == 3
+        finally:
+            config.ACTIVE_THEME = original_theme
 
 
-class TestBigWrap:
-    """Tests for big_wrap function."""
+class TestMsgGradient:
+    """Tests for msg_gradient function (message/ntfy overlay coloring)."""
 
-    def test_empty_string(self):
-        """Empty string returns empty list."""
-        from engine.render import big_wrap
+    def test_msg_gradient_uses_active_theme(self):
+        """msg_gradient uses ACTIVE_THEME.message_gradient when theme is set."""
+        # Save original state
+        original_theme = config.ACTIVE_THEME
 
-        result = big_wrap("", 80)
-        assert result == []
+        try:
+            # Set a theme
+            config.set_active_theme("green")
 
-    @pytest.mark.skip(reason="Requires real font/PIL setup")
-    def test_single_word_fits(self):
-        """Single short word returns rendered."""
-        from engine.render import big_wrap
+            # Create simple test data
+            rows = ["MESSAGE"]
 
-        with patch("engine.render.font") as mock_font:
-            mock_font.return_value = MagicMock()
-            mock_font.return_value.getbbox.return_value = (0, 0, 10, 10)
-            result = big_wrap("test", 80)
-            assert len(result) > 0
+            # Call msg_gradient
+            result = render.msg_gradient(rows, offset=0.0)
+
+            # Should return colored output using theme's message_gradient
+            assert isinstance(result, list)
+            assert len(result) == 1
+            # Should have ANSI codes from the message gradient
+            assert result[0] != "MESSAGE"
+            assert "\033[" in result[0]
+        finally:
+            # Restore original state
+            config.ACTIVE_THEME = original_theme
+
+    def test_msg_gradient_fallback_when_no_theme(self):
+        """msg_gradient uses fallback magenta when ACTIVE_THEME is None."""
+        # Save original state
+        original_theme = config.ACTIVE_THEME
+
+        try:
+            # Clear the theme
+            config.ACTIVE_THEME = None
+
+            # Create simple test data
+            rows = ["MESSAGE"]
+
+            # Call msg_gradient
+            result = render.msg_gradient(rows, offset=0.0)
+
+            # Should return colored output using default magenta
+            assert isinstance(result, list)
+            assert len(result) == 1
+            # Should have ANSI codes
+            assert result[0] != "MESSAGE"
+            assert "\033[" in result[0]
+        finally:
+            # Restore original state
+            config.ACTIVE_THEME = original_theme
+
+    def test_msg_gradient_returns_colored_rows(self):
+        """msg_gradient returns properly colored rows with animation offset."""
+        # Save original state
+        original_theme = config.ACTIVE_THEME
+
+        try:
+            # Set a theme
+            config.set_active_theme("orange")
+
+            rows = ["NTFY", "ALERT"]
+
+            # Call with offset
+            result = render.msg_gradient(rows, offset=0.5)
+
+            # Should return same number of rows
+            assert len(result) == 2
+            # Both should be colored
+            assert all("\033[" in r for r in result)
+            # Should not be the original text
+            assert result != rows
+        finally:
+            config.ACTIVE_THEME = original_theme
+
+    def test_msg_gradient_different_themes_produce_different_results(self):
+        """msg_gradient produces different colors for different themes."""
+        original_theme = config.ACTIVE_THEME
+
+        try:
+            rows = ["TEST"]
+
+            # Get result with green theme
+            config.set_active_theme("green")
+            result_green = render.msg_gradient(rows, offset=0.0)
+
+            # Get result with orange theme
+            config.set_active_theme("orange")
+            result_orange = render.msg_gradient(rows, offset=0.0)
+
+            # Results should be different (different message gradients)
+            assert result_green != result_orange
+        finally:
+            config.ACTIVE_THEME = original_theme
+
+    def test_msg_gradient_preserves_spacing(self):
+        """msg_gradient preserves spaces in rows."""
+        original_theme = config.ACTIVE_THEME
+
+        try:
+            config.set_active_theme("purple")
+            rows = ["M E S S A G E"]
+
+            result = render.msg_gradient(rows, offset=0.0)
+
+            # Spaces should be preserved
+            assert " " in result[0]
+        finally:
+            config.ACTIVE_THEME = original_theme
+
+    def test_msg_gradient_empty_rows(self):
+        """msg_gradient handles empty rows correctly."""
+        original_theme = config.ACTIVE_THEME
+
+        try:
+            config.set_active_theme("green")
+            rows = [""]
+
+            result = render.msg_gradient(rows, offset=0.0)
+
+            # Empty row should stay empty
+            assert result == [""]
+        finally:
+            config.ACTIVE_THEME = original_theme

tests/test_sixel.py

@@ -1,128 +0,0 @@
-"""
-Tests for engine.display.backends.sixel module.
-"""
-
-from unittest.mock import MagicMock, patch
-
-
-class TestSixelDisplay:
-    """Tests for SixelDisplay class."""
-
-    def test_init_stores_dimensions(self):
-        """init stores dimensions."""
-        from engine.display.backends.sixel import SixelDisplay
-
-        display = SixelDisplay()
-        display.init(80, 24)
-        assert display.width == 80
-        assert display.height == 24
-
-    def test_init_custom_cell_size(self):
-        """init accepts custom cell size."""
-        from engine.display.backends.sixel import SixelDisplay
-
-        display = SixelDisplay(cell_width=12, cell_height=18)
-        assert display.cell_width == 12
-        assert display.cell_height == 18
-
-    def test_show_handles_empty_buffer(self):
-        """show handles empty buffer gracefully."""
-        from engine.display.backends.sixel import SixelDisplay
-
-        display = SixelDisplay()
-        display.init(80, 24)
-
-        with patch("engine.display.backends.sixel._encode_sixel") as mock_encode:
-            mock_encode.return_value = ""
-            display.show([])
-
-    def test_show_handles_pil_import_error(self):
-        """show gracefully handles missing PIL."""
-        from engine.display.backends.sixel import SixelDisplay
-
-        display = SixelDisplay()
-        display.init(80, 24)
-
-        with patch.dict("sys.modules", {"PIL": None}):
-            display.show(["test line"])
-
-    def test_clear_sends_escape_sequence(self):
-        """clear sends clear screen escape sequence."""
-        from engine.display.backends.sixel import SixelDisplay
-
-        display = SixelDisplay()
-
-        with patch("sys.stdout") as mock_stdout:
-            display.clear()
-            mock_stdout.buffer.write.assert_called()
-
-    def test_cleanup_does_nothing(self):
-        """cleanup does nothing."""
-        from engine.display.backends.sixel import SixelDisplay
-
-        display = SixelDisplay()
-        display.cleanup()
-
-
-class TestSixelAnsiParsing:
-    """Tests for ANSI parsing in SixelDisplay."""
-
-    def test_parse_empty_string(self):
-        """handles empty string."""
-        from engine.display.renderer import parse_ansi
-
-        result = parse_ansi("")
-        assert len(result) > 0
-
-    def test_parse_plain_text(self):
-        """parses plain text without ANSI codes."""
-        from engine.display.renderer import parse_ansi
-
-        result = parse_ansi("hello world")
-        assert len(result) == 1
-        text, fg, bg, bold = result[0]
-        assert text == "hello world"
-
-    def test_parse_with_color_codes(self):
-        """parses ANSI color codes."""
-        from engine.display.renderer import parse_ansi
-
-        result = parse_ansi("\033[31mred\033[0m")
-        assert len(result) == 1
-        assert result[0][0] == "red"
-        assert result[0][1] == (205, 49, 49)
-
-    def test_parse_with_bold(self):
-        """parses bold codes."""
-        from engine.display.renderer import parse_ansi
-
-        result = parse_ansi("\033[1mbold\033[0m")
-        assert len(result) == 1
-        assert result[0][0] == "bold"
-        assert result[0][3] is True
-
-    def test_parse_256_color(self):
-        """parses 256 color codes."""
-        from engine.display.renderer import parse_ansi
-
-        result = parse_ansi("\033[38;5;196mred\033[0m")
-        assert len(result) == 1
-        assert result[0][0] == "red"
-
-
-class TestSixelEncoding:
-    """Tests for Sixel encoding."""
-
-    def test_encode_empty_image(self):
-        """handles empty image."""
-        from engine.display.backends.sixel import _encode_sixel
-
-        with patch("PIL.Image.Image") as mock_image:
-            mock_img_instance = MagicMock()
-            mock_img_instance.convert.return_value = mock_img_instance
-            mock_img_instance.size = (0, 0)
-            mock_img_instance.load.return_value = {}
-            mock_image.return_value = mock_img_instance
-
-            result = _encode_sixel(mock_img_instance)
-            assert result == ""

tests/test_themes.py

@@ -0,0 +1,169 @@
+"""
+Tests for engine.themes module.
+"""
+
+import pytest
+
+from engine import themes
+
+
+class TestThemeConstruction:
+    """Tests for Theme class initialization."""
+
+    def test_theme_construction(self):
+        """Theme stores name and gradients correctly."""
+        main_grad = ["color1", "color2", "color3"]
+        msg_grad = ["msg1", "msg2", "msg3"]
+        theme = themes.Theme("test_theme", main_grad, msg_grad)
+
+        assert theme.name == "test_theme"
+        assert theme.main_gradient == main_grad
+        assert theme.message_gradient == msg_grad
+
+
+class TestGradientLength:
+    """Tests for gradient length validation."""
+
+    def test_gradient_length_green(self):
+        """Green theme has exactly 12 colors in each gradient."""
+        green = themes.THEME_REGISTRY["green"]
+        assert len(green.main_gradient) == 12
+        assert len(green.message_gradient) == 12
+
+    def test_gradient_length_orange(self):
+        """Orange theme has exactly 12 colors in each gradient."""
+        orange = themes.THEME_REGISTRY["orange"]
+        assert len(orange.main_gradient) == 12
+        assert len(orange.message_gradient) == 12
+
+    def test_gradient_length_purple(self):
+        """Purple theme has exactly 12 colors in each gradient."""
+        purple = themes.THEME_REGISTRY["purple"]
+        assert len(purple.main_gradient) == 12
+        assert len(purple.message_gradient) == 12
+
+
+class TestThemeRegistry:
+    """Tests for THEME_REGISTRY dictionary."""
+
+    def test_theme_registry_has_three_themes(self):
+        """Registry contains exactly three themes: green, orange, purple."""
+        assert len(themes.THEME_REGISTRY) == 3
+        assert set(themes.THEME_REGISTRY.keys()) == {"green", "orange", "purple"}
+
+    def test_registry_values_are_themes(self):
+        """All registry values are Theme instances."""
+        for theme_id, theme in themes.THEME_REGISTRY.items():
+            assert isinstance(theme, themes.Theme)
+            assert theme.name == theme_id
+
+
+class TestGetTheme:
+    """Tests for get_theme function."""
+
+    def test_get_theme_valid_green(self):
+        """get_theme('green') returns correct green Theme."""
+        green = themes.get_theme("green")
+        assert isinstance(green, themes.Theme)
+        assert green.name == "green"
+
+    def test_get_theme_valid_orange(self):
+        """get_theme('orange') returns correct orange Theme."""
+        orange = themes.get_theme("orange")
+        assert isinstance(orange, themes.Theme)
+        assert orange.name == "orange"
+
+    def test_get_theme_valid_purple(self):
+        """get_theme('purple') returns correct purple Theme."""
+        purple = themes.get_theme("purple")
+        assert isinstance(purple, themes.Theme)
+        assert purple.name == "purple"
+
+    def test_get_theme_invalid(self):
+        """get_theme with invalid ID raises KeyError."""
+        with pytest.raises(KeyError):
+            themes.get_theme("invalid_theme")
+
+    def test_get_theme_invalid_none(self):
+        """get_theme with None raises KeyError."""
+        with pytest.raises(KeyError):
+            themes.get_theme(None)
+
+
+class TestGreenTheme:
+    """Tests for green theme specific values."""
+
+    def test_green_theme_unchanged(self):
+        """Green theme maintains original color sequence."""
+        green = themes.get_theme("green")
+
+        # Expected main gradient: 231→195→123→118→82→46→40→34→28→22→22(dim)→235
+        expected_main = [231, 195, 123, 118, 82, 46, 40, 34, 28, 22, 22, 235]
+        # Expected msg gradient: 231→225→219→213→207→201→165→161→125→89→89(dim)→235
+        expected_msg = [231, 225, 219, 213, 207, 201, 165, 161, 125, 89, 89, 235]
+
+        assert green.main_gradient == expected_main
+        assert green.message_gradient == expected_msg
+
+    def test_green_theme_name(self):
+        """Green theme has correct name."""
+        green = themes.get_theme("green")
+        assert green.name == "green"
+
+
+class TestOrangeTheme:
+    """Tests for orange theme specific values."""
+
+    def test_orange_theme_unchanged(self):
+        """Orange theme maintains original color sequence."""
+        orange = themes.get_theme("orange")
+
+        # Expected main gradient: 231→215→209→208→202→166→130→94→58→94→94(dim)→235
+        expected_main = [231, 215, 209, 208, 202, 166, 130, 94, 58, 94, 94, 235]
+        # Expected msg gradient: 231→195→33→27→21→21→21→18→18→18→18(dim)→235
+        expected_msg = [231, 195, 33, 27, 21, 21, 21, 18, 18, 18, 18, 235]
+
+        assert orange.main_gradient == expected_main
+        assert orange.message_gradient == expected_msg
+
+    def test_orange_theme_name(self):
+        """Orange theme has correct name."""
+        orange = themes.get_theme("orange")
+        assert orange.name == "orange"
+
+
+class TestPurpleTheme:
+    """Tests for purple theme specific values."""
+
+    def test_purple_theme_unchanged(self):
+        """Purple theme maintains original color sequence."""
+        purple = themes.get_theme("purple")
+
+        # Expected main gradient: 231→225→177→171→165→135→129→93→57→57→57(dim)→235
+        expected_main = [231, 225, 177, 171, 165, 135, 129, 93, 57, 57, 57, 235]
+        # Expected msg gradient: 231→226→226→220→220→184→184→178→178→172→172(dim)→235
+        expected_msg = [231, 226, 226, 220, 220, 184, 184, 178, 178, 172, 172, 235]
+
+        assert purple.main_gradient == expected_main
+        assert purple.message_gradient == expected_msg
+
+    def test_purple_theme_name(self):
+        """Purple theme has correct name."""
+        purple = themes.get_theme("purple")
+        assert purple.name == "purple"
+
+
+class TestThemeDataOnly:
+    """Tests to ensure themes module has no problematic imports."""
+
+    def test_themes_module_imports(self):
+        """themes module should be data-only without config/render imports."""
+        import inspect
+        source = inspect.getsource(themes)
+        # Verify no imports of config or render (look for actual import statements)
+        lines = source.split('\n')
+        import_lines = [line for line in lines if line.strip().startswith('import ') or line.strip().startswith('from ')]
+        # Filter out empty and comment lines
+        import_lines = [line for line in import_lines if line.strip() and not line.strip().startswith('#')]
+        # Should have no import lines
+        assert len(import_lines) == 0, f"Found unexpected imports: {import_lines}"

tests/test_translate.py

@@ -1,115 +0,0 @@
-"""
-Tests for engine.translate module.
-"""
-
-import json
-from unittest.mock import MagicMock, patch
-
-from engine.translate import (
-    _translate_cached,
-    detect_location_language,
-    translate_headline,
-)
-
-
-def clear_translate_cache():
-    """Clear the LRU cache between tests."""
-    _translate_cached.cache_clear()
-
-
-class TestDetectLocationLanguage:
-    """Tests for detect_location_language function."""
-
-    def test_returns_none_for_unknown_location(self):
-        """Returns None when no location pattern matches."""
-        result = detect_location_language("Breaking news about technology")
-        assert result is None
-
-    def test_detects_berlin(self):
-        """Detects Berlin location."""
-        result = detect_location_language("Berlin police arrest protesters")
-        assert result == "de"
-
-    def test_detects_paris(self):
-        """Detects Paris location."""
-        result = detect_location_language("Paris fashion week begins")
-        assert result == "fr"
-
-    def test_detects_tokyo(self):
-        """Detects Tokyo location."""
-        result = detect_location_language("Tokyo stocks rise")
-        assert result == "ja"
-
-    def test_detects_berlin_again(self):
-        """Detects Berlin location again."""
-        result = detect_location_language("Berlin marathon set to begin")
-        assert result == "de"
-
-    def test_case_insensitive(self):
-        """Detection is case insensitive."""
-        result = detect_location_language("BERLIN SUMMER FESTIVAL")
-        assert result == "de"
-
-    def test_returns_first_match(self):
-        """Returns first matching pattern."""
-        result = detect_location_language("Berlin in Paris for the event")
-        assert result == "de"
-
-
-class TestTranslateHeadline:
-    """Tests for translate_headline function."""
-
-    def test_returns_translated_text(self):
-        """Returns translated text from cache."""
-        clear_translate_cache()
-        with patch("engine.translate.translate_headline") as mock_fn:
-            mock_fn.return_value = "Translated title"
-            from engine.translate import translate_headline as th
-
-            result = th("Original title", "de")
-            assert result == "Translated title"
-
-    def test_uses_cached_result(self):
-        """Translation uses LRU cache."""
-        clear_translate_cache()
-        result1 = translate_headline("Test unique", "es")
-        result2 = translate_headline("Test unique", "es")
-        assert result1 == result2
-
-
-class TestTranslateCached:
-    """Tests for _translate_cached function."""
-
-    def test_translation_network_error(self):
-        """Network error returns original text."""
-        clear_translate_cache()
-        with patch("engine.translate.urllib.request.urlopen") as mock_urlopen:
-            mock_urlopen.side_effect = Exception("Network error")
-
-            result = _translate_cached("Hello world", "de")
-
-            assert result == "Hello world"
-
-    def test_translation_invalid_json(self):
-        """Invalid JSON returns original text."""
-        clear_translate_cache()
-        with patch("engine.translate.urllib.request.urlopen") as mock_urlopen:
-            mock_response = MagicMock()
-            mock_response.read.return_value = b"invalid json"
-            mock_urlopen.return_value = mock_response
-
-            result = _translate_cached("Hello", "de")
-
-            assert result == "Hello"
-
-    def test_translation_empty_response(self):
-        """Empty translation response returns original text."""
-        clear_translate_cache()
-        with patch("engine.translate.urllib.request.urlopen") as mock_urlopen:
-            mock_response = MagicMock()
-            mock_response.read.return_value = json.dumps([[[""], None, "de"], None])
-            mock_urlopen.return_value = mock_response
-
-            result = _translate_cached("Hello", "de")
-
-            assert result == "Hello"

tests/test_vis_offset.py

@@ -1,32 +0,0 @@
-
-from engine.effects.legacy import vis_offset, vis_trunc
-
-
-def test_vis_offset_no_change():
-    """vis_offset with offset 0 returns original."""
-    result = vis_offset("hello", 0)
-    assert result == "hello"
-
-
-def test_vis_offset_trims_start():
-    """vis_offset skips first N characters."""
-    result = vis_offset("hello world", 6)
-    assert result == "world"
-
-
-def test_vis_offset_handles_ansi():
-    """vis_offset handles ANSI codes correctly."""
-    result = vis_offset("\033[31mhello\033[0m", 3)
-    assert result == "lo\x1b[0m" or "lo" in result
-
-
-def test_vis_offset_greater_than_length():
-    """vis_offset with offset > length returns empty-ish."""
-    result = vis_offset("hi", 10)
-    assert result == ""
-
-
-def test_vis_trunc_still_works():
-    """Ensure vis_trunc still works after changes."""
-    result = vis_trunc("hello world", 5)
-    assert result == "hello"

tests/test_websocket.py

@@ -1,161 +0,0 @@
-"""
-Tests for engine.display.backends.websocket module.
-"""
-
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from engine.display.backends.websocket import WebSocketDisplay
-
-
-class TestWebSocketDisplayImport:
-    """Test that websocket module can be imported."""
-
-    def test_import_does_not_error(self):
-        """Module imports without error."""
-        from engine.display import backends
-
-        assert backends is not None
-
-
-class TestWebSocketDisplayInit:
-    """Tests for WebSocketDisplay initialization."""
-
-    def test_default_init(self):
-        """Default initialization sets correct defaults."""
-        with patch("engine.display.backends.websocket.websockets", None):
-            display = WebSocketDisplay()
-            assert display.host == "0.0.0.0"
-            assert display.port == 8765
-            assert display.http_port == 8766
-            assert display.width == 80
-            assert display.height == 24
-
-    def test_custom_init(self):
-        """Custom initialization uses provided values."""
-        with patch("engine.display.backends.websocket.websockets", None):
-            display = WebSocketDisplay(host="localhost", port=9000, http_port=9001)
-            assert display.host == "localhost"
-            assert display.port == 9000
-            assert display.http_port == 9001
-
-    def test_is_available_when_websockets_present(self):
-        """is_available returns True when websockets is available."""
-        pytest.importorskip("websockets")
-        display = WebSocketDisplay()
-        assert display.is_available() is True
-
-    @pytest.mark.skipif(
-        pytest.importorskip("websockets") is not None, reason="websockets is available"
-    )
-    def test_is_available_when_websockets_missing(self):
-        """is_available returns False when websockets is not available."""
-        display = WebSocketDisplay()
-        assert display.is_available() is False
-
-
-class TestWebSocketDisplayProtocol:
-    """Test that WebSocketDisplay satisfies Display protocol."""
-
-    def test_websocket_display_is_display(self):
-        """WebSocketDisplay satisfies Display protocol."""
-        with patch("engine.display.backends.websocket.websockets", MagicMock()):
-            display = WebSocketDisplay()
-            assert hasattr(display, "init")
-            assert hasattr(display, "show")
-            assert hasattr(display, "clear")
-            assert hasattr(display, "cleanup")
-
-
-class TestWebSocketDisplayMethods:
-    """Tests for WebSocketDisplay methods."""
-
-    def test_init_stores_dimensions(self):
-        """init stores terminal dimensions."""
-        with patch("engine.display.backends.websocket.websockets", MagicMock()):
-            display = WebSocketDisplay()
-            display.init(100, 40)
-            assert display.width == 100
-            assert display.height == 40
-
-    def test_client_count_initially_zero(self):
-        """client_count returns 0 when no clients connected."""
-        with patch("engine.display.backends.websocket.websockets", MagicMock()):
-            display = WebSocketDisplay()
-            assert display.client_count() == 0
-
-    def test_get_ws_port(self):
-        """get_ws_port returns configured port."""
-        with patch("engine.display.backends.websocket.websockets", MagicMock()):
-            display = WebSocketDisplay(port=9000)
-            assert display.get_ws_port() == 9000
-
-    def test_get_http_port(self):
-        """get_http_port returns configured port."""
-        with patch("engine.display.backends.websocket.websockets", MagicMock()):
-            display = WebSocketDisplay(http_port=9001)
-            assert display.get_http_port() == 9001
-
-    def test_frame_delay_defaults_to_zero(self):
-        """get_frame_delay returns 0 by default."""
-        with patch("engine.display.backends.websocket.websockets", MagicMock()):
-            display = WebSocketDisplay()
-            assert display.get_frame_delay() == 0.0
-
-    def test_set_frame_delay(self):
-        """set_frame_delay stores the value."""
-        with patch("engine.display.backends.websocket.websockets", MagicMock()):
-            display = WebSocketDisplay()
-            display.set_frame_delay(0.05)
-            assert display.get_frame_delay() == 0.05
-
-
-class TestWebSocketDisplayCallbacks:
-    """Tests for WebSocketDisplay callback methods."""
-
-    def test_set_client_connected_callback(self):
-        """set_client_connected_callback stores callback."""
-        with patch("engine.display.backends.websocket.websockets", MagicMock()):
-            display = WebSocketDisplay()
-            callback = MagicMock()
-            display.set_client_connected_callback(callback)
-            assert display._client_connected_callback is callback
-
-    def test_set_client_disconnected_callback(self):
-        """set_client_disconnected_callback stores callback."""
-        with patch("engine.display.backends.websocket.websockets", MagicMock()):
-            display = WebSocketDisplay()
-            callback = MagicMock()
-            display.set_client_disconnected_callback(callback)
-            assert display._client_disconnected_callback is callback
-
-
-class TestWebSocketDisplayUnavailable:
-    """Tests when WebSocket support is unavailable."""
-
-    @pytest.mark.skipif(
-        pytest.importorskip("websockets") is not None, reason="websockets is available"
-    )
-    def test_start_server_noop_when_unavailable(self):
-        """start_server does nothing when websockets unavailable."""
-        display = WebSocketDisplay()
-        display.start_server()
-        assert display._server_thread is None
-
-    @pytest.mark.skipif(
-        pytest.importorskip("websockets") is not None, reason="websockets is available"
-    )
-    def test_start_http_server_noop_when_unavailable(self):
-        """start_http_server does nothing when websockets unavailable."""
-        display = WebSocketDisplay()
-        display.start_http_server()
-        assert display._http_thread is None
-
-    @pytest.mark.skipif(
-        pytest.importorskip("websockets") is not None, reason="websockets is available"
-    )
-    def test_show_noops_when_unavailable(self):
-        """show does nothing when websockets unavailable."""
-        display = WebSocketDisplay()
-        display.show(["line1", "line2"])

tests/test_websocket_e2e.py

@@ -1,78 +0,0 @@
-"""
-End-to-end tests for WebSocket display using Playwright.
-"""
-
-import time
-
-import pytest
-
-
-class TestWebSocketE2E:
-    """End-to-end tests for WebSocket display with browser."""
-
-    @pytest.mark.e2e
-    def test_websocket_server_starts(self):
-        """Test that WebSocket server starts and serves HTTP."""
-        import threading
-
-        from engine.display.backends.websocket import WebSocketDisplay
-
-        display = WebSocketDisplay(host="127.0.0.1", port=18765)
-
-        server_thread = threading.Thread(target=display.start_http_server)
-        server_thread.daemon = True
-        server_thread.start()
-
-        time.sleep(1)
-
-        try:
-            import urllib.request
-
-            response = urllib.request.urlopen("http://127.0.0.1:18765", timeout=5)
-            assert response.status == 200
-            content = response.read().decode("utf-8")
-            assert len(content) > 0
-        finally:
-            display.cleanup()
-            time.sleep(0.5)
-
-    @pytest.mark.e2e
-    @pytest.mark.skipif(
-        not pytest.importorskip("playwright", reason="playwright not installed"),
-        reason="playwright not installed",
-    )
-    def test_websocket_browser_connection(self):
-        """Test WebSocket connection with actual browser."""
-        import threading
-
-        from playwright.sync_api import sync_playwright
-
-        from engine.display.backends.websocket import WebSocketDisplay
-
-        display = WebSocketDisplay(host="127.0.0.1", port=18767)
-
-        server_thread = threading.Thread(target=display.start_server)
-        server_thread.daemon = True
-        server_thread.start()
-
-        http_thread = threading.Thread(target=display.start_http_server)
-        http_thread.daemon = True
-        http_thread.start()
-
-        time.sleep(1)
-
-        try:
-            with sync_playwright() as p:
-                browser = p.chromium.launch(headless=True)
-                page = browser.new_page()
-
-                page.goto("http://127.0.0.1:18767")
-                time.sleep(0.5)
-
-                title = page.title()
-                assert len(title) >= 0
-
-                browser.close()
-        finally:
-            display.cleanup()
-            time.sleep(0.5)