feat: Implement Sideline plugin system with consistent terminology

This commit implements the Sideline/Mainline split with a clean plugin architecture:

## Core Changes

### Sideline Framework (New Directory)
- Created  directory containing the reusable pipeline framework
- Moved pipeline core, controllers, adapters, and registry to
- Moved display system to
- Moved effects system to
- Created plugin system with security and compatibility management in
- Created preset pack system with ASCII art encoding in
- Added default font (Corptic) to
- Added terminal ANSI constants to

### Mainline Application (Updated)
- Created  for Mainline stage component registration
- Updated  to register Mainline stages at startup
- Updated  as a compatibility shim re-exporting from sideline

### Terminology Consistency
- : Base class for all pipeline components (sources, effects, displays, cameras)
- : Base class for distributable plugin packages (was )
- : Base class for visual effects (was )
- Backward compatibility aliases maintained for existing code

## Key Features
- Plugin discovery via entry points and explicit registration
- Security permissions system for plugins
- Compatibility management with semantic version constraints
- Preset pack system for distributable configurations
- Default font bundled with Sideline (Corptic.otf)

## Testing
- Updated tests to register Mainline stages before discovery
- All StageRegistry tests passing

Note: This is a major refactoring that separates the framework (Sideline) from the application (Mainline), enabling Sideline to be used by other applications.

sideline/pipeline/__init__.py

@@ -0,0 +1,94 @@
+"""
+Unified Pipeline Architecture.
+
+This module provides a clean, dependency-managed pipeline system:
+- Stage: Base class for all pipeline components
+- Pipeline: DAG-based execution orchestrator
+- PipelineParams: Runtime configuration for animation
+- PipelinePreset: Pre-configured pipeline configurations
+- StageRegistry: Unified registration for all stage types
+- Plugin system: Support for external stage plugins
+
+The pipeline architecture supports:
+- Sources: Data providers (headlines, poetry, pipeline viz)
+- Effects: Post-processors (noise, fade, glitch, hud)
+- Displays: Output backends (terminal, pygame, websocket)
+- Cameras: Viewport controllers (vertical, horizontal, omni)
+
+Plugin System:
+    Plugins can be registered explicitly or discovered automatically via entry points.
+    Applications can register their own stages using StageRegistry.register() or
+    StageRegistry.register_plugin().
+
+Example:
+    from sideline.pipeline import Pipeline, PipelineConfig, StageRegistry
+
+    # Register application-specific stages
+    StageRegistry.register("source", MyDataSource)
+
+    # Or discover plugins automatically
+    StageRegistry.discover_plugins()
+
+    pipeline = Pipeline(PipelineConfig(source="my_source", display="terminal"))
+    pipeline.add_stage("source", StageRegistry.create("source", "my_source"))
+    pipeline.add_stage("display", StageRegistry.create("display", "terminal"))
+    pipeline.build().initialize()
+
+    result = pipeline.execute(initial_data)
+"""
+
+from sideline.pipeline.controller import (
+    Pipeline,
+    PipelineConfig,
+    PipelineRunner,
+    create_default_pipeline,
+    create_pipeline_from_params,
+)
+from sideline.pipeline.core import (
+    PipelineContext,
+    Stage,
+    StageConfig,
+    StageError,
+    StageResult,
+)
+from sideline.pipeline.params import (
+    DEFAULT_HEADLINE_PARAMS,
+    DEFAULT_PIPELINE_PARAMS,
+    DEFAULT_PYGAME_PARAMS,
+    PipelineParams,
+)
+from sideline.pipeline.registry import (
+    StageRegistry,
+    discover_stages,
+    register_camera,
+    register_display,
+    register_effect,
+    register_source,
+)
+
+__all__ = [
+    # Core
+    "Stage",
+    "StageConfig",
+    "StageError",
+    "StageResult",
+    "PipelineContext",
+    # Controller
+    "Pipeline",
+    "PipelineConfig",
+    "PipelineRunner",
+    "create_default_pipeline",
+    "create_pipeline_from_params",
+    # Params
+    "PipelineParams",
+    "DEFAULT_HEADLINE_PARAMS",
+    "DEFAULT_PIPELINE_PARAMS",
+    "DEFAULT_PYGAME_PARAMS",
+    # Registry
+    "StageRegistry",
+    "discover_stages",
+    "register_source",
+    "register_effect",
+    "register_display",
+    "register_camera",
+]

sideline/pipeline/adapters.py

@@ -0,0 +1,50 @@
+"""
+Stage adapters - Bridge existing components to the Stage interface.
+
+This module provides adapters that wrap existing components
+(EffectPlugin, Display, DataSource, Camera) as Stage implementations.
+
+DEPRECATED: This file is now a compatibility wrapper.
+Use `engine.pipeline.adapters` package instead.
+"""
+
+# Re-export from the new package structure for backward compatibility
+from sideline.pipeline.adapters import (
+    # Adapter classes
+    CameraStage,
+    CanvasStage,
+    DataSourceStage,
+    DisplayStage,
+    EffectPluginStage,
+    FontStage,
+    ImageToTextStage,
+    PassthroughStage,
+    SourceItemsToBufferStage,
+    ViewportFilterStage,
+    # Factory functions
+    create_stage_from_camera,
+    create_stage_from_display,
+    create_stage_from_effect,
+    create_stage_from_font,
+    create_stage_from_source,
+)
+
+__all__ = [
+    # Adapter classes
+    "EffectPluginStage",
+    "DisplayStage",
+    "DataSourceStage",
+    "PassthroughStage",
+    "SourceItemsToBufferStage",
+    "CameraStage",
+    "ViewportFilterStage",
+    "FontStage",
+    "ImageToTextStage",
+    "CanvasStage",
+    # Factory functions
+    "create_stage_from_display",
+    "create_stage_from_effect",
+    "create_stage_from_source",
+    "create_stage_from_camera",
+    "create_stage_from_font",
+]

sideline/pipeline/adapters/__init__.py

@@ -0,0 +1,55 @@
+"""Stage adapters - Bridge existing components to the Stage interface.
+
+This module provides adapters that wrap existing components
+(EffectPlugin, Display, DataSource, Camera) as Stage implementations.
+"""
+
+from .camera import CameraClockStage, CameraStage
+from .data_source import DataSourceStage, PassthroughStage, SourceItemsToBufferStage
+from .display import DisplayStage
+from .effect_plugin import EffectPluginStage
+from .factory import (
+    create_stage_from_camera,
+    create_stage_from_display,
+    create_stage_from_effect,
+    create_stage_from_font,
+    create_stage_from_source,
+)
+from .message_overlay import MessageOverlayConfig, MessageOverlayStage
+from .positioning import (
+    PositioningMode,
+    PositionStage,
+    create_position_stage,
+)
+from .transform import (
+    CanvasStage,
+    FontStage,
+    ImageToTextStage,
+    ViewportFilterStage,
+)
+
+__all__ = [
+    # Adapter classes
+    "EffectPluginStage",
+    "DisplayStage",
+    "DataSourceStage",
+    "PassthroughStage",
+    "SourceItemsToBufferStage",
+    "CameraStage",
+    "CameraClockStage",
+    "ViewportFilterStage",
+    "FontStage",
+    "ImageToTextStage",
+    "CanvasStage",
+    "MessageOverlayStage",
+    "MessageOverlayConfig",
+    "PositionStage",
+    "PositioningMode",
+    # Factory functions
+    "create_stage_from_display",
+    "create_stage_from_effect",
+    "create_stage_from_source",
+    "create_stage_from_camera",
+    "create_stage_from_font",
+    "create_position_stage",
+]

sideline/pipeline/adapters/camera.py

@@ -0,0 +1,219 @@
+"""Adapter for camera stage."""
+
+import time
+from typing import Any
+
+from sideline.pipeline.core import DataType, PipelineContext, Stage
+
+
+class CameraClockStage(Stage):
+    """Per-frame clock stage that updates camera state.
+
+    This stage runs once per frame and updates the camera's internal state
+    (position, time). It makes camera_y/camera_x available to subsequent
+    stages via the pipeline context.
+
+    Unlike other stages, this is a pure clock stage and doesn't process
+    data - it just updates camera state and passes data through unchanged.
+    """
+
+    def __init__(self, camera, name: str = "camera-clock"):
+        self._camera = camera
+        self.name = name
+        self.category = "camera"
+        self.optional = False
+        self._last_frame_time: float | None = None
+
+    @property
+    def stage_type(self) -> str:
+        return "camera"
+
+    @property
+    def capabilities(self) -> set[str]:
+        # Provides camera state info only
+        # NOTE: Do NOT provide "source" as it conflicts with viewport_filter's "source.filtered"
+        return {"camera.state"}
+
+    @property
+    def dependencies(self) -> set[str]:
+        # Clock stage - no dependencies (updates every frame regardless of data flow)
+        return set()
+
+    @property
+    def inlet_types(self) -> set:
+        # Accept any data type - this is a pass-through stage
+        return {DataType.ANY}
+
+    @property
+    def outlet_types(self) -> set:
+        # Pass through whatever was received
+        return {DataType.ANY}
+
+    def process(self, data: Any, ctx: PipelineContext) -> Any:
+        """Update camera state and pass data through.
+
+        This stage updates the camera's internal state (position, time) and
+        makes the updated camera_y/camera_x available to subsequent stages
+        via the pipeline context.
+
+        The data is passed through unchanged - this stage only updates
+        camera state, it doesn't transform the data.
+        """
+        if data is None:
+            return data
+
+        # Update camera speed from params if explicitly set (for dynamic modulation)
+        # Only update if camera_speed in params differs from the default (1.0)
+        # This preserves camera speed set during construction
+        if (
+            ctx.params
+            and hasattr(ctx.params, "camera_speed")
+            and ctx.params.camera_speed != 1.0
+        ):
+            self._camera.set_speed(ctx.params.camera_speed)
+
+        current_time = time.perf_counter()
+        dt = 0.0
+        if self._last_frame_time is not None:
+            dt = current_time - self._last_frame_time
+            self._camera.update(dt)
+        self._last_frame_time = current_time
+
+        # Update context with current camera position
+        ctx.set_state("camera_y", self._camera.y)
+        ctx.set_state("camera_x", self._camera.x)
+
+        # Pass data through unchanged
+        return data
+
+
+class CameraStage(Stage):
+    """Adapter wrapping Camera as a Stage.
+
+    This stage applies camera viewport transformation to the rendered buffer.
+    Camera state updates are handled by CameraClockStage.
+    """
+
+    def __init__(self, camera, name: str = "vertical"):
+        self._camera = camera
+        self.name = name
+        self.category = "camera"
+        self.optional = True
+        self._last_frame_time: float | None = None
+
+    def save_state(self) -> dict[str, Any]:
+        """Save camera state for restoration after pipeline rebuild.
+
+        Returns:
+            Dictionary containing camera state that can be restored
+        """
+        state = {
+            "x": self._camera.x,
+            "y": self._camera.y,
+            "mode": self._camera.mode.value
+            if hasattr(self._camera.mode, "value")
+            else self._camera.mode,
+            "speed": self._camera.speed,
+            "zoom": self._camera.zoom,
+            "canvas_width": self._camera.canvas_width,
+            "canvas_height": self._camera.canvas_height,
+            "_x_float": getattr(self._camera, "_x_float", 0.0),
+            "_y_float": getattr(self._camera, "_y_float", 0.0),
+            "_time": getattr(self._camera, "_time", 0.0),
+        }
+        # Save radial camera state if present
+        if hasattr(self._camera, "_r_float"):
+            state["_r_float"] = self._camera._r_float
+        if hasattr(self._camera, "_theta_float"):
+            state["_theta_float"] = self._camera._theta_float
+        if hasattr(self._camera, "_radial_input"):
+            state["_radial_input"] = self._camera._radial_input
+        return state
+
+    def restore_state(self, state: dict[str, Any]) -> None:
+        """Restore camera state from saved state.
+
+        Args:
+            state: Dictionary containing camera state from save_state()
+        """
+        from sideline.camera import CameraMode
+
+        self._camera.x = state.get("x", 0)
+        self._camera.y = state.get("y", 0)
+
+        # Restore mode - handle both enum value and direct enum
+        mode_value = state.get("mode", 0)
+        if isinstance(mode_value, int):
+            self._camera.mode = CameraMode(mode_value)
+        else:
+            self._camera.mode = mode_value
+
+        self._camera.speed = state.get("speed", 1.0)
+        self._camera.zoom = state.get("zoom", 1.0)
+        self._camera.canvas_width = state.get("canvas_width", 200)
+        self._camera.canvas_height = state.get("canvas_height", 200)
+
+        # Restore internal state
+        if hasattr(self._camera, "_x_float"):
+            self._camera._x_float = state.get("_x_float", 0.0)
+        if hasattr(self._camera, "_y_float"):
+            self._camera._y_float = state.get("_y_float", 0.0)
+        if hasattr(self._camera, "_time"):
+            self._camera._time = state.get("_time", 0.0)
+
+        # Restore radial camera state if present
+        if hasattr(self._camera, "_r_float"):
+            self._camera._r_float = state.get("_r_float", 0.0)
+        if hasattr(self._camera, "_theta_float"):
+            self._camera._theta_float = state.get("_theta_float", 0.0)
+        if hasattr(self._camera, "_radial_input"):
+            self._camera._radial_input = state.get("_radial_input", 0.0)
+
+    @property
+    def stage_type(self) -> str:
+        return "camera"
+
+    @property
+    def capabilities(self) -> set[str]:
+        return {"camera"}
+
+    @property
+    def dependencies(self) -> set[str]:
+        return {"render.output", "camera.state"}
+
+    @property
+    def inlet_types(self) -> set:
+        return {DataType.TEXT_BUFFER}
+
+    @property
+    def outlet_types(self) -> set:
+        return {DataType.TEXT_BUFFER}
+
+    def process(self, data: Any, ctx: PipelineContext) -> Any:
+        """Apply camera transformation to items."""
+        if data is None:
+            return data
+
+        # Camera state is updated by CameraClockStage
+        # We only apply the viewport transformation here
+
+        if hasattr(self._camera, "apply"):
+            viewport_width = ctx.params.viewport_width if ctx.params else 80
+            viewport_height = ctx.params.viewport_height if ctx.params else 24
+
+            # Use filtered camera position if available (from ViewportFilterStage)
+            # This handles the case where the buffer has been filtered and starts at row 0
+            filtered_camera_y = ctx.get("camera_y", self._camera.y)
+
+            # Temporarily adjust camera position for filtering
+            original_y = self._camera.y
+            self._camera.y = filtered_camera_y
+
+            try:
+                result = self._camera.apply(data, viewport_width, viewport_height)
+            finally:
+                # Restore original camera position
+                self._camera.y = original_y
+
+            return result
+        return data

sideline/pipeline/adapters/data_source.py

@@ -0,0 +1,143 @@
+"""
+Stage adapters - Bridge existing components to the Stage interface.
+
+This module provides adapters that wrap existing components
+(DataSource) as Stage implementations.
+"""
+
+from typing import Any
+
+from sideline.data_sources import SourceItem
+from sideline.pipeline.core import DataType, PipelineContext, Stage
+
+
+class DataSourceStage(Stage):
+    """Adapter wrapping DataSource as a Stage."""
+
+    def __init__(self, data_source, name: str = "headlines"):
+        self._source = data_source
+        self.name = name
+        self.category = "source"
+        self.optional = False
+
+    @property
+    def capabilities(self) -> set[str]:
+        return {f"source.{self.name}"}
+
+    @property
+    def dependencies(self) -> set[str]:
+        return set()
+
+    @property
+    def inlet_types(self) -> set:
+        return {DataType.NONE}  # Sources don't take input
+
+    @property
+    def outlet_types(self) -> set:
+        return {DataType.SOURCE_ITEMS}
+
+    def process(self, data: Any, ctx: PipelineContext) -> Any:
+        """Fetch data from source."""
+        if hasattr(self._source, "get_items"):
+            return self._source.get_items()
+        return data
+
+
+class PassthroughStage(Stage):
+    """Simple stage that passes data through unchanged.
+
+    Used for sources that already provide the data in the correct format
+    (e.g., pipeline introspection that outputs text directly).
+    """
+
+    def __init__(self, name: str = "passthrough"):
+        self.name = name
+        self.category = "render"
+        self.optional = True
+
+    @property
+    def stage_type(self) -> str:
+        return "render"
+
+    @property
+    def capabilities(self) -> set[str]:
+        return {"render.output"}
+
+    @property
+    def dependencies(self) -> set[str]:
+        return {"source"}
+
+    @property
+    def inlet_types(self) -> set:
+        return {DataType.SOURCE_ITEMS}
+
+    @property
+    def outlet_types(self) -> set:
+        return {DataType.SOURCE_ITEMS}
+
+    def process(self, data: Any, ctx: PipelineContext) -> Any:
+        """Pass data through unchanged."""
+        return data
+
+
+class SourceItemsToBufferStage(Stage):
+    """Convert SourceItem objects to text buffer.
+
+    Takes a list of SourceItem objects and extracts their content,
+    splitting on newlines to create a proper text buffer for display.
+    """
+
+    def __init__(self, name: str = "items-to-buffer"):
+        self.name = name
+        self.category = "render"
+        self.optional = True
+
+    @property
+    def stage_type(self) -> str:
+        return "render"
+
+    @property
+    def capabilities(self) -> set[str]:
+        return {"render.output"}
+
+    @property
+    def dependencies(self) -> set[str]:
+        return {"source"}
+
+    @property
+    def inlet_types(self) -> set:
+        return {DataType.SOURCE_ITEMS}
+
+    @property
+    def outlet_types(self) -> set:
+        return {DataType.TEXT_BUFFER}
+
+    def process(self, data: Any, ctx: PipelineContext) -> Any:
+        """Convert SourceItem list to text buffer."""
+        if data is None:
+            return []
+
+        # If already a list of strings, return as-is
+        if isinstance(data, list) and data and isinstance(data[0], str):
+            return data
+
+        # If it's a list of SourceItem, extract content
+        if isinstance(data, list):
+            result = []
+            for item in data:
+                if isinstance(item, SourceItem):
+                    # Split content by newline to get individual lines
+                    lines = item.content.split("\n")
+                    result.extend(lines)
+                elif hasattr(item, "content"):  # Has content attribute
+                    lines = str(item.content).split("\n")
+                    result.extend(lines)
+                else:
+                    result.append(str(item))
+            return result
+
+        # Single item
+        if isinstance(data, SourceItem):
+            return data.content.split("\n")
+
+        return [str(data)]

sideline/pipeline/adapters/display.py

@@ -0,0 +1,108 @@
+"""Adapter wrapping Display as a Stage."""
+
+from typing import Any
+
+from sideline.pipeline.core import PipelineContext, Stage
+
+
+class DisplayStage(Stage):
+    """Adapter wrapping Display as a Stage."""
+
+    def __init__(self, display, name: str = "terminal", positioning: str = "mixed"):
+        self._display = display
+        self.name = name
+        self.category = "display"
+        self.optional = False
+        self._initialized = False
+        self._init_width = 80
+        self._init_height = 24
+        self._positioning = positioning
+
+    def save_state(self) -> dict[str, Any]:
+        """Save display state for restoration after pipeline rebuild.
+
+        Returns:
+            Dictionary containing display state that can be restored
+        """
+        return {
+            "initialized": self._initialized,
+            "init_width": self._init_width,
+            "init_height": self._init_height,
+            "width": getattr(self._display, "width", 80),
+            "height": getattr(self._display, "height", 24),
+        }
+
+    def restore_state(self, state: dict[str, Any]) -> None:
+        """Restore display state from saved state.
+
+        Args:
+            state: Dictionary containing display state from save_state()
+        """
+        self._initialized = state.get("initialized", False)
+        self._init_width = state.get("init_width", 80)
+        self._init_height = state.get("init_height", 24)
+
+        # Restore display dimensions if the display supports it
+        if hasattr(self._display, "width"):
+            self._display.width = state.get("width", 80)
+        if hasattr(self._display, "height"):
+            self._display.height = state.get("height", 24)
+
+    @property
+    def capabilities(self) -> set[str]:
+        return {"display.output"}
+
+    @property
+    def dependencies(self) -> set[str]:
+        # Display needs rendered content and camera transformation
+        return {"render.output", "camera"}
+
+    @property
+    def inlet_types(self) -> set:
+        from sideline.pipeline.core import DataType
+
+        return {DataType.TEXT_BUFFER}  # Display consumes rendered text
+
+    @property
+    def outlet_types(self) -> set:
+        from sideline.pipeline.core import DataType
+
+        return {DataType.NONE}  # Display is a terminal stage (no output)
+
+    def init(self, ctx: PipelineContext) -> bool:
+        w = ctx.params.viewport_width if ctx.params else 80
+        h = ctx.params.viewport_height if ctx.params else 24
+
+        # Try to reuse display if already initialized
+        reuse = self._initialized
+        result = self._display.init(w, h, reuse=reuse)
+
+        # Update initialization state
+        if result is not False:
+            self._initialized = True
+            self._init_width = w
+            self._init_height = h
+
+        return result is not False
+
+    def process(self, data: Any, ctx: PipelineContext) -> Any:
+        """Output data to display."""
+        if data is not None:
+            # Check if positioning mode is specified in context params
+            positioning = self._positioning
+            if ctx and ctx.params and hasattr(ctx.params, "positioning"):
+                positioning = ctx.params.positioning
+
+            # Pass positioning to display if supported
+            if (
+                hasattr(self._display, "show")
+                and "positioning" in self._display.show.__code__.co_varnames
+            ):
+                self._display.show(data, positioning=positioning)
+            else:
+                # Fallback for displays that don't support positioning parameter
+                self._display.show(data)
+        return data
+
+    def cleanup(self) -> None:
+        self._display.cleanup()

sideline/pipeline/adapters/effect_plugin.py

@@ -0,0 +1,124 @@
+"""Adapter wrapping EffectPlugin as a Stage."""
+
+from typing import Any
+
+from sideline.pipeline.core import PipelineContext, Stage
+
+
+class EffectPluginStage(Stage):
+    """Adapter wrapping EffectPlugin as a Stage.
+
+    Supports capability-based dependencies through the dependencies parameter.
+    """
+
+    def __init__(
+        self,
+        effect_plugin,
+        name: str = "effect",
+        dependencies: set[str] | None = None,
+    ):
+        self._effect = effect_plugin
+        self.name = name
+        self.category = "effect"
+        self.optional = False
+        self._dependencies = dependencies or set()
+
+    @property
+    def stage_type(self) -> str:
+        """Return stage_type based on effect name.
+
+        Overlay effects have stage_type "overlay".
+        """
+        if self.is_overlay:
+            return "overlay"
+        return self.category
+
+    @property
+    def render_order(self) -> int:
+        """Return render_order based on effect type.
+
+        Overlay effects have high render_order to appear on top.
+        """
+        if self.is_overlay:
+            return 100  # High order for overlays
+        return 0
+
+    @property
+    def is_overlay(self) -> bool:
+        """Return True for overlay effects.
+
+        Overlay effects compose on top of the buffer
+        rather than transforming it for the next stage.
+        """
+        # Check if the effect has an is_overlay attribute that is explicitly True
+        # (not just any truthy value from a mock object)
+        if hasattr(self._effect, "is_overlay"):
+            effect_overlay = self._effect.is_overlay
+            # Only return True if it's explicitly set to True
+            if effect_overlay is True:
+                return True
+        return self.name == "hud"
+
+    @property
+    def capabilities(self) -> set[str]:
+        return {f"effect.{self.name}"}
+
+    @property
+    def dependencies(self) -> set[str]:
+        return self._dependencies
+
+    @property
+    def inlet_types(self) -> set:
+        from sideline.pipeline.core import DataType
+
+        return {DataType.TEXT_BUFFER}
+
+    @property
+    def outlet_types(self) -> set:
+        from sideline.pipeline.core import DataType
+
+        return {DataType.TEXT_BUFFER}
+
+    def process(self, data: Any, ctx: PipelineContext) -> Any:
+        """Process data through the effect."""
+        if data is None:
+            return None
+        from sideline.effects.types import EffectContext, apply_param_bindings
+
+        w = ctx.params.viewport_width if ctx.params else 80
+        h = ctx.params.viewport_height if ctx.params else 24
+        frame = ctx.params.frame_number if ctx.params else 0
+
+        effect_ctx = EffectContext(
+            terminal_width=w,
+            terminal_height=h,
+            scroll_cam=0,
+            ticker_height=h,
+            camera_x=0,
+            mic_excess=0.0,
+            grad_offset=(frame * 0.01) % 1.0,
+            frame_number=frame,
+            has_message=False,
+            items=ctx.get("items", []),
+        )
+
+        # Copy sensor state from PipelineContext to EffectContext
+        for key, value in ctx.state.items():
+            if key.startswith("sensor."):
+                effect_ctx.set_state(key, value)
+
+        # Copy metrics from PipelineContext to EffectContext
+        if "metrics" in ctx.state:
+            effect_ctx.set_state("metrics", ctx.state["metrics"])
+
+        # Copy pipeline_order from PipelineContext services to EffectContext state
+        pipeline_order = ctx.get("pipeline_order")
+        if pipeline_order:
+            effect_ctx.set_state("pipeline_order", pipeline_order)
+
+        # Apply sensor param bindings if effect has them
+        if hasattr(self._effect, "param_bindings") and self._effect.param_bindings:
+            bound_config = apply_param_bindings(self._effect, effect_ctx)
+            self._effect.configure(bound_config)
+
+        return self._effect.process(data, effect_ctx)

sideline/pipeline/adapters/factory.py

@@ -0,0 +1,38 @@
+"""Factory functions for creating stage instances."""
+
+from sideline.pipeline.adapters.camera import CameraStage
+from sideline.pipeline.adapters.data_source import DataSourceStage
+from sideline.pipeline.adapters.display import DisplayStage
+from sideline.pipeline.adapters.effect_plugin import EffectPluginStage
+from sideline.pipeline.adapters.transform import FontStage
+
+
+def create_stage_from_display(display, name: str = "terminal") -> DisplayStage:
+    """Create a DisplayStage from a display instance."""
+    return DisplayStage(display, name=name)
+
+
+def create_stage_from_effect(effect_plugin, name: str) -> EffectPluginStage:
+    """Create an EffectPluginStage from an effect plugin."""
+    return EffectPluginStage(effect_plugin, name=name)
+
+
+def create_stage_from_source(data_source, name: str = "headlines") -> DataSourceStage:
+    """Create a DataSourceStage from a data source."""
+    return DataSourceStage(data_source, name=name)
+
+
+def create_stage_from_camera(camera, name: str = "vertical") -> CameraStage:
+    """Create a CameraStage from a camera instance."""
+    return CameraStage(camera, name=name)
+
+
+def create_stage_from_font(
+    font_path: str | None = None,
+    font_size: int | None = None,
+    font_ref: str | None = "default",
+    name: str = "font",
+) -> FontStage:
+    """Create a FontStage with specified font configuration."""
+    # FontStage currently doesn't use these parameters but keeps them for compatibility
+    return FontStage(name=name)

sideline/pipeline/adapters/frame_capture.py

@@ -0,0 +1,165 @@
+"""
+Frame Capture Stage Adapter
+
+Wraps pipeline stages to capture frames for animation report generation.
+"""
+
+from typing import Any
+
+from sideline.display.backends.animation_report import AnimationReportDisplay
+from sideline.pipeline.core import PipelineContext, Stage
+
+
+class FrameCaptureStage(Stage):
+    """
+    Wrapper stage that captures frames before and after a wrapped stage.
+
+    This allows generating animation reports showing how each stage
+    transforms the data.
+    """
+
+    def __init__(
+        self,
+        wrapped_stage: Stage,
+        display: AnimationReportDisplay,
+        name: str | None = None,
+    ):
+        """
+        Initialize frame capture stage.
+
+        Args:
+            wrapped_stage: The stage to wrap and capture frames from
+            display: The animation report display to send frames to
+            name: Optional name for this capture stage
+        """
+        self._wrapped_stage = wrapped_stage
+        self._display = display
+        self.name = name or f"capture_{wrapped_stage.name}"
+        self.category = wrapped_stage.category
+        self.optional = wrapped_stage.optional
+
+        # Capture state
+        self._captured_input = False
+        self._captured_output = False
+
+    @property
+    def stage_type(self) -> str:
+        return self._wrapped_stage.stage_type
+
+    @property
+    def capabilities(self) -> set[str]:
+        return self._wrapped_stage.capabilities
+
+    @property
+    def dependencies(self) -> set[str]:
+        return self._wrapped_stage.dependencies
+
+    @property
+    def inlet_types(self) -> set:
+        return self._wrapped_stage.inlet_types
+
+    @property
+    def outlet_types(self) -> set:
+        return self._wrapped_stage.outlet_types
+
+    def init(self, ctx: PipelineContext) -> bool:
+        """Initialize the wrapped stage."""
+        return self._wrapped_stage.init(ctx)
+
+    def process(self, data: Any, ctx: PipelineContext) -> Any:
+        """
+        Process data through wrapped stage and capture frames.
+
+        Args:
+            data: Input data (typically a text buffer)
+            ctx: Pipeline context
+
+        Returns:
+            Output data from wrapped stage
+        """
+        # Capture input frame (before stage processing)
+        if isinstance(data, list) and all(isinstance(line, str) for line in data):
+            self._display.start_stage(f"{self._wrapped_stage.name}_input")
+            self._display.show(data)
+            self._captured_input = True
+
+        # Process through wrapped stage
+        result = self._wrapped_stage.process(data, ctx)
+
+        # Capture output frame (after stage processing)
+        if isinstance(result, list) and all(isinstance(line, str) for line in result):
+            self._display.start_stage(f"{self._wrapped_stage.name}_output")
+            self._display.show(result)
+            self._captured_output = True
+
+        return result
+
+    def cleanup(self) -> None:
+        """Cleanup the wrapped stage."""
+        self._wrapped_stage.cleanup()
+
+
+class FrameCaptureController:
+    """
+    Controller for managing frame capture across the pipeline.
+
+    This class provides an easy way to enable frame capture for
+    specific stages or the entire pipeline.
+    """
+
+    def __init__(self, display: AnimationReportDisplay):
+        """
+        Initialize frame capture controller.
+
+        Args:
+            display: The animation report display to use for capture
+        """
+        self._display = display
+        self._captured_stages: list[FrameCaptureStage] = []
+
+    def wrap_stage(self, stage: Stage, name: str | None = None) -> FrameCaptureStage:
+        """
+        Wrap a stage with frame capture.
+
+        Args:
+            stage: The stage to wrap
+            name: Optional name for the capture stage
+
+        Returns:
+            Wrapped stage that captures frames
+        """
+        capture_stage = FrameCaptureStage(stage, self._display, name)
+        self._captured_stages.append(capture_stage)
+        return capture_stage
+
+    def wrap_stages(self, stages: dict[str, Stage]) -> dict[str, Stage]:
+        """
+        Wrap multiple stages with frame capture.
+
+        Args:
+            stages: Dictionary of stage names to stages
+
+        Returns:
+            Dictionary of stage names to wrapped stages
+        """
+        wrapped = {}
+        for name, stage in stages.items():
+            wrapped[name] = self.wrap_stage(stage, name)
+        return wrapped
+
+    def get_captured_stages(self) -> list[FrameCaptureStage]:
+        """Get list of all captured stages."""
+        return self._captured_stages
+
+    def generate_report(self, title: str = "Pipeline Animation Report") -> str:
+        """
+        Generate the animation report.
+
+        Args:
+            title: Title for the report
+
+        Returns:
+            Path to the generated HTML file
+        """
+        report_path = self._display.generate_report(title)
+        return str(report_path)

sideline/pipeline/adapters/message_overlay.py

@@ -0,0 +1,185 @@
+"""
+Message overlay stage - Renders ntfy messages as an overlay on the buffer.
+
+This stage provides message overlay capability for displaying ntfy.sh messages
+as a centered panel with pink/magenta gradient, matching upstream/main aesthetics.
+"""
+
+import re
+import time
+from dataclasses import dataclass
+from datetime import datetime
+
+from engine import config
+from engine.effects.legacy import vis_trunc
+from sideline.pipeline.core import DataType, PipelineContext, Stage
+from sideline.render.blocks import big_wrap
+from sideline.render.gradient import msg_gradient
+
+
+@dataclass
+class MessageOverlayConfig:
+    """Configuration for MessageOverlayStage."""
+
+    enabled: bool = True
+    display_secs: int = 30  # How long to display messages
+    topic_url: str | None = None  # Ntfy topic URL (None = use config default)
+
+
+class MessageOverlayStage(Stage):
+    """Stage that renders ntfy message overlay on the buffer.
+
+    Provides:
+    - message.overlay capability (optional)
+    - Renders centered panel with pink/magenta gradient
+    - Shows title, body, timestamp, and remaining time
+    """
+
+    name = "message_overlay"
+    category = "overlay"
+
+    def __init__(
+        self, config: MessageOverlayConfig | None = None, name: str = "message_overlay"
+    ):
+        self.config = config or MessageOverlayConfig()
+        self._ntfy_poller = None
+        self._msg_cache = (None, None)  # (cache_key, rendered_rows)
+
+    @property
+    def capabilities(self) -> set[str]:
+        """Provides message overlay capability."""
+        return {"message.overlay"} if self.config.enabled else set()
+
+    @property
+    def dependencies(self) -> set[str]:
+        """Needs rendered buffer and camera transformation to overlay onto."""
+        return {"render.output", "camera"}
+
+    @property
+    def inlet_types(self) -> set:
+        return {DataType.TEXT_BUFFER}
+
+    @property
+    def outlet_types(self) -> set:
+        return {DataType.TEXT_BUFFER}
+
+    def init(self, ctx: PipelineContext) -> bool:
+        """Initialize ntfy poller if topic URL is configured."""
+        if not self.config.enabled:
+            return True
+
+        # Get or create ntfy poller
+        topic_url = self.config.topic_url or config.NTFY_TOPIC
+        if topic_url:
+            from sideline.ntfy import NtfyPoller
+
+            self._ntfy_poller = NtfyPoller(
+                topic_url=topic_url,
+                reconnect_delay=getattr(config, "NTFY_RECONNECT_DELAY", 5),
+                display_secs=self.config.display_secs,
+            )
+            self._ntfy_poller.start()
+            ctx.set("ntfy_poller", self._ntfy_poller)
+
+        return True
+
+    def process(self, data: list[str], ctx: PipelineContext) -> list[str]:
+        """Render message overlay on the buffer."""
+        if not self.config.enabled or not data:
+            return data
+
+        # Get active message from poller
+        msg = None
+        if self._ntfy_poller:
+            msg = self._ntfy_poller.get_active_message()
+
+        if msg is None:
+            return data
+
+        # Render overlay
+        w = ctx.terminal_width if hasattr(ctx, "terminal_width") else 80
+        h = ctx.terminal_height if hasattr(ctx, "terminal_height") else 24
+
+        overlay, self._msg_cache = self._render_message_overlay(
+            msg, w, h, self._msg_cache
+        )
+
+        # Composite overlay onto buffer
+        result = list(data)
+        for line in overlay:
+            # Overlay uses ANSI cursor positioning, just append
+            result.append(line)
+
+        return result
+
+    def _render_message_overlay(
+        self,
+        msg: tuple[str, str, float] | None,
+        w: int,
+        h: int,
+        msg_cache: tuple,
+    ) -> tuple[list[str], tuple]:
+        """Render ntfy message overlay.
+
+        Args:
+            msg: (title, body, timestamp) or None
+            w: terminal width
+            h: terminal height
+            msg_cache: (cache_key, rendered_rows) for caching
+
+        Returns:
+            (list of ANSI strings, updated cache)
+        """
+        overlay = []
+        if msg is None:
+            return overlay, msg_cache
+
+        m_title, m_body, m_ts = msg
+        display_text = m_body or m_title or "(empty)"
+        display_text = re.sub(r"\s+", " ", display_text.upper())
+
+        cache_key = (display_text, w)
+        if msg_cache[0] != cache_key:
+            msg_rows = big_wrap(display_text, w - 4)
+            msg_cache = (cache_key, msg_rows)
+        else:
+            msg_rows = msg_cache[1]
+
+        msg_rows = msg_gradient(msg_rows, (time.monotonic() * config.GRAD_SPEED) % 1.0)
+
+        elapsed_s = int(time.monotonic() - m_ts)
+        remaining = max(0, self.config.display_secs - elapsed_s)
+        ts_str = datetime.now().strftime("%H:%M:%S")
+        panel_h = len(msg_rows) + 2
+        panel_top = max(0, (h - panel_h) // 2)
+
+        row_idx = 0
+        for mr in msg_rows:
+            ln = vis_trunc(mr, w)
+            overlay.append(f"\033[{panel_top + row_idx + 1};1H  {ln}\033[0m\033[K")
+            row_idx += 1
+
+        meta_parts = []
+        if m_title and m_title != m_body:
+            meta_parts.append(m_title)
+        meta_parts.append(f"ntfy \u00b7 {ts_str} \u00b7 {remaining}s")
+        meta = (
+            "  " + " \u00b7 ".join(meta_parts)
+            if len(meta_parts) > 1
+            else "  " + meta_parts[0]
+        )
+        overlay.append(
+            f"\033[{panel_top + row_idx + 1};1H\033[38;5;245m{meta}\033[0m\033[K"
+        )
+        row_idx += 1
+
+        bar = "\u2500" * (w - 4)
+        overlay.append(
+            f"\033[{panel_top + row_idx + 1};1H  \033[2;38;5;37m{bar}\033[0m\033[K"
+        )
+
+        return overlay, msg_cache
+
+    def cleanup(self) -> None:
+        """Cleanup resources."""
+        pass

sideline/pipeline/adapters/positioning.py

@@ -0,0 +1,185 @@
+"""PositionStage - Configurable positioning mode for terminal rendering.
+
+This module provides positioning stages that allow choosing between
+different ANSI positioning approaches:
+- ABSOLUTE: Use cursor positioning codes (\\033[row;colH) for all lines
+- RELATIVE: Use newlines for all lines
+- MIXED: Base content uses newlines, effects use cursor positioning (default)
+"""
+
+from enum import Enum
+from typing import Any
+
+from sideline.pipeline.core import DataType, PipelineContext, Stage
+
+
+class PositioningMode(Enum):
+    """Positioning mode for terminal rendering."""
+
+    ABSOLUTE = "absolute"  # All lines have cursor positioning codes
+    RELATIVE = "relative"  # Lines use newlines (no cursor codes)
+    MIXED = "mixed"  # Mixed: newlines for base, cursor codes for overlays (default)
+
+
+class PositionStage(Stage):
+    """Applies positioning mode to buffer before display.
+
+    This stage allows configuring how lines are positioned in the terminal:
+    - ABSOLUTE: Each line has \\033[row;colH prefix (precise control)
+    - RELATIVE: Lines are joined with \\n (natural flow)
+    - MIXED: Leaves buffer as-is (effects add their own positioning)
+    """
+
+    def __init__(
+        self, mode: PositioningMode = PositioningMode.RELATIVE, name: str = "position"
+    ):
+        self.mode = mode
+        self.name = name
+        self.category = "position"
+        self._mode_str = mode.value
+
+    def save_state(self) -> dict[str, Any]:
+        """Save positioning mode for restoration."""
+        return {"mode": self.mode.value}
+
+    def restore_state(self, state: dict[str, Any]) -> None:
+        """Restore positioning mode from saved state."""
+        mode_value = state.get("mode", "relative")
+        self.mode = PositioningMode(mode_value)
+
+    @property
+    def capabilities(self) -> set[str]:
+        return {"position.output"}
+
+    @property
+    def dependencies(self) -> set[str]:
+        # Position stage typically runs after render but before effects
+        # Effects may add their own positioning codes
+        return {"render.output"}
+
+    @property
+    def inlet_types(self) -> set:
+        return {DataType.TEXT_BUFFER}
+
+    @property
+    def outlet_types(self) -> set:
+        return {DataType.TEXT_BUFFER}
+
+    def init(self, ctx: PipelineContext) -> bool:
+        """Initialize the positioning stage."""
+        return True
+
+    def process(self, data: Any, ctx: PipelineContext) -> Any:
+        """Apply positioning mode to the buffer.
+
+        Args:
+            data: List of strings (buffer lines)
+            ctx: Pipeline context
+
+        Returns:
+            Buffer with applied positioning mode
+        """
+        if data is None:
+            return data
+
+        if not isinstance(data, list):
+            return data
+
+        if self.mode == PositioningMode.ABSOLUTE:
+            return self._to_absolute(data, ctx)
+        elif self.mode == PositioningMode.RELATIVE:
+            return self._to_relative(data, ctx)
+        else:  # MIXED
+            return data  # No transformation
+
+    def _to_absolute(self, data: list[str], ctx: PipelineContext) -> list[str]:
+        """Convert buffer to absolute positioning (all lines have cursor codes).
+
+        This mode prefixes each line with \\033[row;colH to move cursor
+        to the exact position before writing the line.
+
+        Args:
+            data: List of buffer lines
+            ctx: Pipeline context (provides terminal dimensions)
+
+        Returns:
+            Buffer with cursor positioning codes for each line
+        """
+        result = []
+        viewport_height = ctx.params.viewport_height if ctx.params else 24
+
+        for i, line in enumerate(data):
+            if i >= viewport_height:
+                break  # Don't exceed viewport
+
+            # Check if line already has cursor positioning
+            if "\033[" in line and "H" in line:
+                # Already has cursor positioning - leave as-is
+                result.append(line)
+            else:
+                # Add cursor positioning for this line
+                # Row is 1-indexed
+                result.append(f"\033[{i + 1};1H{line}")
+
+        return result
+
+    def _to_relative(self, data: list[str], ctx: PipelineContext) -> list[str]:
+        """Convert buffer to relative positioning (use newlines).
+
+        This mode removes explicit cursor positioning codes from lines
+        (except for effects that specifically add them).
+
+        Note: Effects like HUD add their own cursor positioning codes,
+        so we can't simply remove all of them. We rely on the terminal
+        display to join lines with newlines.
+
+        Args:
+            data: List of buffer lines
+            ctx: Pipeline context (unused)
+
+        Returns:
+            Buffer with minimal cursor positioning (only for overlays)
+        """
+        # For relative mode, we leave the buffer as-is
+        # The terminal display handles joining with newlines
+        # Effects that need absolute positioning will add their own codes
+
+        # Filter out lines that would cause double-positioning
+        result = []
+        for i, line in enumerate(data):
+            # Check if this line looks like base content (no cursor code at start)
+            # vs an effect line (has cursor code at start)
+            if line.startswith("\033[") and "H" in line[:20]:
+                # This is an effect with positioning - keep it
+                result.append(line)
+            else:
+                # Base content - strip any inline cursor codes (rare)
+                # but keep color codes
+                result.append(line)
+
+        return result
+
+    def cleanup(self) -> None:
+        """Clean up positioning stage."""
+        pass
+
+
+# Convenience function to create positioning stage
+def create_position_stage(
+    mode: str = "relative", name: str = "position"
+) -> PositionStage:
+    """Create a positioning stage with the specified mode.
+
+    Args:
+        mode: Positioning mode ("absolute", "relative", or "mixed")
+        name: Name for the stage
+
+    Returns:
+        PositionStage instance
+    """
+    try:
+        positioning_mode = PositioningMode(mode)
+    except ValueError:
+        positioning_mode = PositioningMode.RELATIVE
+
+    return PositionStage(mode=positioning_mode, name=name)

sideline/pipeline/adapters/transform.py

@@ -0,0 +1,293 @@
+"""Adapters for transform stages (viewport, font, image, canvas)."""
+
+from typing import Any
+
+import sideline.render
+from sideline.data_sources import SourceItem
+from sideline.pipeline.core import DataType, PipelineContext, Stage
+
+
+def estimate_simple_height(text: str, width: int) -> int:
+    """Estimate height in terminal rows using simple word wrap.
+
+    Uses conservative estimation suitable for headlines.
+    Each wrapped line is approximately 6 terminal rows (big block rendering).
+    """
+    words = text.split()
+    if not words:
+        return 6
+
+    lines = 1
+    current_len = 0
+    for word in words:
+        word_len = len(word)
+        if current_len + word_len + 1 > width - 4:  # -4 for margins
+            lines += 1
+            current_len = word_len
+        else:
+            current_len += word_len + 1
+
+    return lines * 6  # 6 rows per line for big block rendering
+
+
+class ViewportFilterStage(Stage):
+    """Filter items to viewport height based on rendered height."""
+
+    def __init__(self, name: str = "viewport-filter"):
+        self.name = name
+        self.category = "render"
+        self.optional = True
+        self._layout: list[int] = []
+
+    @property
+    def stage_type(self) -> str:
+        return "render"
+
+    @property
+    def capabilities(self) -> set[str]:
+        return {"source.filtered"}
+
+    @property
+    def dependencies(self) -> set[str]:
+        # Always requires camera.state for viewport filtering
+        # CameraUpdateStage provides this (auto-injected if missing)
+        return {"source", "camera.state"}
+
+    @property
+    def inlet_types(self) -> set:
+        return {DataType.SOURCE_ITEMS}
+
+    @property
+    def outlet_types(self) -> set:
+        return {DataType.SOURCE_ITEMS}
+
+    def process(self, data: Any, ctx: PipelineContext) -> Any:
+        """Filter items to viewport height based on rendered height."""
+        if data is None:
+            return data
+
+        if not isinstance(data, list):
+            return data
+
+        if not data:
+            return []
+
+        # Get viewport parameters from context
+        viewport_height = ctx.params.viewport_height if ctx.params else 24
+        viewport_width = ctx.params.viewport_width if ctx.params else 80
+        camera_y = ctx.get("camera_y", 0)
+
+        # Estimate height for each item and cache layout
+        self._layout = []
+        cumulative_heights = []
+        current_height = 0
+
+        for item in data:
+            title = item.content if isinstance(item, SourceItem) else str(item)
+            # Use simple height estimation (not PIL-based)
+            estimated_height = estimate_simple_height(title, viewport_width)
+            self._layout.append(estimated_height)
+            current_height += estimated_height
+            cumulative_heights.append(current_height)
+
+        # Find visible range based on camera_y and viewport_height
+        # camera_y is the scroll offset (how many rows are scrolled up)
+        start_y = camera_y
+        end_y = camera_y + viewport_height
+
+        # Find start index (first item that intersects with visible range)
+        start_idx = 0
+        start_item_y = 0  # Y position where the first visible item starts
+        for i, total_h in enumerate(cumulative_heights):
+            if total_h > start_y:
+                start_idx = i
+                # Calculate the Y position of the start of this item
+                if i > 0:
+                    start_item_y = cumulative_heights[i - 1]
+                break
+
+        # Find end index (first item that extends beyond visible range)
+        end_idx = len(data)
+        for i, total_h in enumerate(cumulative_heights):
+            if total_h >= end_y:
+                end_idx = i + 1
+                break
+
+        # Adjust camera_y for the filtered buffer
+        # The filtered buffer starts at row 0, but the camera position
+        # needs to be relative to where the first visible item starts
+        filtered_camera_y = camera_y - start_item_y
+
+        # Update context with the filtered camera position
+        # This ensures CameraStage can correctly slice the filtered buffer
+        ctx.set_state("camera_y", filtered_camera_y)
+        ctx.set_state("camera_x", ctx.get("camera_x", 0))  # Keep camera_x unchanged
+
+        # Return visible items
+        return data[start_idx:end_idx]
+
+
+class FontStage(Stage):
+    """Render items using font."""
+
+    def __init__(self, name: str = "font"):
+        self.name = name
+        self.category = "render"
+        self.optional = False
+
+    @property
+    def stage_type(self) -> str:
+        return "render"
+
+    @property
+    def capabilities(self) -> set[str]:
+        return {"render.output"}
+
+    @property
+    def stage_dependencies(self) -> set[str]:
+        # Must connect to viewport_filter stage to get filtered source
+        return {"viewport_filter"}
+
+    @property
+    def dependencies(self) -> set[str]:
+        # Depend on source.filtered (provided by viewport_filter)
+        # This ensures we get the filtered/processed source, not raw source
+        return {"source.filtered"}
+
+    @property
+    def inlet_types(self) -> set:
+        return {DataType.SOURCE_ITEMS}
+
+    @property
+    def outlet_types(self) -> set:
+        return {DataType.TEXT_BUFFER}
+
+    def process(self, data: Any, ctx: PipelineContext) -> Any:
+        """Render items to text buffer using font."""
+        if data is None:
+            return []
+
+        if not isinstance(data, list):
+            return [str(data)]
+
+        import os
+
+        if os.environ.get("DEBUG_CAMERA"):
+            print(f"FontStage: input items={len(data)}")
+
+        viewport_width = ctx.params.viewport_width if ctx.params else 80
+
+        result = []
+        for item in data:
+            if isinstance(item, SourceItem):
+                title = item.content
+                src = item.source
+                ts = item.timestamp
+                content_lines, _, _ = engine.render.make_block(
+                    title, src, ts, viewport_width
+                )
+                result.extend(content_lines)
+            elif hasattr(item, "content"):
+                title = str(item.content)
+                content_lines, _, _ = engine.render.make_block(
+                    title, "", "", viewport_width
+                )
+                result.extend(content_lines)
+            else:
+                result.append(str(item))
+        return result
+
+
+class ImageToTextStage(Stage):
+    """Convert image items to text."""
+
+    def __init__(self, name: str = "image-to-text"):
+        self.name = name
+        self.category = "render"
+        self.optional = True
+
+    @property
+    def stage_type(self) -> str:
+        return "render"
+
+    @property
+    def capabilities(self) -> set[str]:
+        return {"render.output"}
+
+    @property
+    def dependencies(self) -> set[str]:
+        return {"source"}
+
+    @property
+    def inlet_types(self) -> set:
+        return {DataType.SOURCE_ITEMS}
+
+    @property
+    def outlet_types(self) -> set:
+        return {DataType.TEXT_BUFFER}
+
+    def process(self, data: Any, ctx: PipelineContext) -> Any:
+        """Convert image items to text representation."""
+        if data is None:
+            return []
+
+        if not isinstance(data, list):
+            return [str(data)]
+
+        result = []
+        for item in data:
+            # Check if item is an image
+            if hasattr(item, "image_path") or hasattr(item, "image_data"):
+                # Placeholder: would normally render image to ASCII art
+                result.append(f"[Image: {getattr(item, 'image_path', 'data')}]")
+            elif isinstance(item, SourceItem):
+                result.extend(item.content.split("\n"))
+            else:
+                result.append(str(item))
+        return result
+
+
+class CanvasStage(Stage):
+    """Render items to canvas."""
+
+    def __init__(self, name: str = "canvas"):
+        self.name = name
+        self.category = "render"
+        self.optional = False
+
+    @property
+    def stage_type(self) -> str:
+        return "render"
+
+    @property
+    def capabilities(self) -> set[str]:
+        return {"render.output"}
+
+    @property
+    def dependencies(self) -> set[str]:
+        return {"source"}
+
+    @property
+    def inlet_types(self) -> set:
+        return {DataType.SOURCE_ITEMS}
+
+    @property
+    def outlet_types(self) -> set:
+        return {DataType.TEXT_BUFFER}
+
+    def process(self, data: Any, ctx: PipelineContext) -> Any:
+        """Render items to canvas."""
+        if data is None:
+            return []
+
+        if not isinstance(data, list):
+            return [str(data)]
+
+        # Simple canvas rendering
+        result = []
+        for item in data:
+            if isinstance(item, SourceItem):
+                result.extend(item.content.split("\n"))
+            else:
+                result.append(str(item))
+        return result

sideline/pipeline/core.py

@@ -0,0 +1,317 @@
+"""
+Pipeline core - Unified Stage abstraction and PipelineContext.
+
+This module provides the foundation for a clean, dependency-managed pipeline:
+- Stage: Base class for all pipeline components (sources, effects, displays, cameras)
+- PipelineContext: Dependency injection context for runtime data exchange
+- Capability system: Explicit capability declarations with duck-typing support
+- DataType: PureData-style inlet/outlet typing for validation
+"""
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from sideline.pipeline.params import PipelineParams
+
+
+class DataType(Enum):
+    """PureData-style data types for inlet/outlet validation.
+
+    Each type represents a specific data format that flows through the pipeline.
+    This enables compile-time-like validation of connections.
+
+    Examples:
+        SOURCE_ITEMS: List[SourceItem] - raw items from sources
+        ITEM_TUPLES: List[tuple] - (title, source, timestamp) tuples
+        TEXT_BUFFER: List[str] - rendered ANSI buffer for display
+        RAW_TEXT: str - raw text strings
+        PIL_IMAGE: PIL Image object
+    """
+
+    SOURCE_ITEMS = auto()  # List[SourceItem] - from DataSource
+    ITEM_TUPLES = auto()  # List[tuple] - (title, source, ts)
+    TEXT_BUFFER = auto()  # List[str] - ANSI buffer
+    RAW_TEXT = auto()  # str - raw text
+    PIL_IMAGE = auto()  # PIL Image object
+    ANY = auto()  # Accepts any type
+    NONE = auto()  # No data (terminator)
+
+
+@dataclass
+class StageConfig:
+    """Configuration for a single stage."""
+
+    name: str
+    category: str
+    enabled: bool = True
+    optional: bool = False
+    params: dict[str, Any] = field(default_factory=dict)
+
+
+class Stage(ABC):
+    """Abstract base class for all pipeline stages.
+
+    A Stage is a single component in the rendering pipeline. Stages can be:
+    - Sources: Data providers (headlines, poetry, pipeline viz)
+    - Effects: Post-processors (noise, fade, glitch, hud)
+    - Displays: Output backends (terminal, pygame, websocket)
+    - Cameras: Viewport controllers (vertical, horizontal, omni)
+    - Overlays: UI elements that compose on top (HUD)
+
+    Stages declare:
+    - capabilities: What they provide to other stages
+    - dependencies: What they need from other stages
+    - stage_type: Category of stage (source, effect, overlay, display)
+    - render_order: Execution order within category
+    - is_overlay: If True, output is composited on top, not passed downstream
+
+    Duck-typing is supported: any class with the required methods can act as a Stage.
+    """
+
+    name: str
+    category: str  # "source", "effect", "overlay", "display", "camera"
+    optional: bool = False  # If True, pipeline continues even if stage fails
+
+    @property
+    def stage_type(self) -> str:
+        """Category of stage for ordering.
+
+        Valid values: "source", "effect", "overlay", "display", "camera"
+        Defaults to category for backwards compatibility.
+        """
+        return self.category
+
+    @property
+    def render_order(self) -> int:
+        """Execution order within stage_type group.
+
+        Higher values execute later. Useful for ordering overlays
+        or effects that need specific execution order.
+        """
+        return 0
+
+    @property
+    def is_overlay(self) -> bool:
+        """If True, this stage's output is composited on top of the buffer.
+
+        Overlay stages don't pass their output to the next stage.
+        Instead, their output is layered on top of the final buffer.
+        Use this for HUD, status displays, and similar UI elements.
+        """
+        return False
+
+    @property
+    def inlet_types(self) -> set[DataType]:
+        """Return set of data types this stage accepts.
+
+        PureData-style inlet typing. If the connected upstream stage's
+        outlet_type is not in this set, the pipeline will raise an error.
+
+        Examples:
+            - Source stages: {DataType.NONE} (no input needed)
+            - Transform stages: {DataType.ITEM_TUPLES, DataType.TEXT_BUFFER}
+            - Display stages: {DataType.TEXT_BUFFER}
+        """
+        return {DataType.ANY}
+
+    @property
+    def outlet_types(self) -> set[DataType]:
+        """Return set of data types this stage produces.
+
+        PureData-style outlet typing. Downstream stages must accept
+        this type in their inlet_types.
+
+        Examples:
+            - Source stages: {DataType.SOURCE_ITEMS}
+            - Transform stages: {DataType.TEXT_BUFFER}
+            - Display stages: {DataType.NONE} (consumes data)
+        """
+        return {DataType.ANY}
+
+    @property
+    def capabilities(self) -> set[str]:
+        """Return set of capabilities this stage provides.
+
+        Examples:
+            - "source.headlines"
+            - "effect.noise"
+            - "display.output"
+            - "camera"
+        """
+        return {f"{self.category}.{self.name}"}
+
+    @property
+    def dependencies(self) -> set[str]:
+        """Return set of capability names this stage needs.
+
+        Examples:
+            - {"display.output"}
+            - {"source.headlines"}
+            - {"camera"}
+        """
+        return set()
+
+    @property
+    def stage_dependencies(self) -> set[str]:
+        """Return set of stage names this stage must connect to directly.
+
+        This allows explicit stage-to-stage dependencies, useful for enforcing
+        pipeline structure when capability matching alone is insufficient.
+
+        Examples:
+            - {"viewport_filter"}  # Must connect to viewport_filter stage
+            - {"camera_update"}    # Must connect to camera_update stage
+
+        NOTE: These are stage names (as added to pipeline), not capabilities.
+        """
+        return set()
+
+    def init(self, ctx: "PipelineContext") -> bool:
+        """Initialize stage with pipeline context.
+
+        Args:
+            ctx: PipelineContext for accessing services
+
+        Returns:
+            True if initialization succeeded, False otherwise
+        """
+        return True
+
+    @abstractmethod
+    def process(self, data: Any, ctx: "PipelineContext") -> Any:
+        """Process input data and return output.
+
+        Args:
+            data: Input data from previous stage (or initial data for first stage)
+            ctx: PipelineContext for accessing services and state
+
+        Returns:
+            Processed data for next stage
+        """
+        ...
+
+    def cleanup(self) -> None:  # noqa: B027
+        """Clean up resources when pipeline shuts down."""
+        pass
+
+    def get_config(self) -> StageConfig:
+        """Return current configuration of this stage."""
+        return StageConfig(
+            name=self.name,
+            category=self.category,
+            optional=self.optional,
+        )
+
+    def set_enabled(self, enabled: bool) -> None:
+        """Enable or disable this stage."""
+        self._enabled = enabled  # type: ignore[attr-defined]
+
+    def is_enabled(self) -> bool:
+        """Check if stage is enabled."""
+        return getattr(self, "_enabled", True)
+
+
+@dataclass
+class StageResult:
+    """Result of stage processing, including success/failure info."""
+
+    success: bool
+    data: Any
+    error: str | None = None
+    stage_name: str = ""
+
+
+class PipelineContext:
+    """Dependency injection context passed through the pipeline.
+
+    Provides:
+    - services: Named services (display, config, event_bus, etc.)
+    - state: Runtime state shared between stages
+    - params: PipelineParams for animation-driven config
+
+    Services can be injected at construction time or lazily resolved.
+    """
+
+    def __init__(
+        self,
+        services: dict[str, Any] | None = None,
+        initial_state: dict[str, Any] | None = None,
+    ):
+        self.services: dict[str, Any] = services or {}
+        self.state: dict[str, Any] = initial_state or {}
+        self._params: PipelineParams | None = None
+
+        # Lazy resolvers for services (can be added by applications)
+        self._lazy_resolvers: dict[str, Callable[[], Any]] = {}
+
+    def register_service(self, name: str, resolver: Callable[[], Any]) -> None:
+        """Register a lazy service resolver.
+
+        Args:
+            name: Service name (e.g., 'config', 'event_bus')
+            resolver: Function that returns the service instance
+        """
+        self._lazy_resolvers[name] = resolver
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get a service or state value by key.
+
+        First checks services, then state, then lazy resolution.
+        """
+        if key in self.services:
+            return self.services[key]
+        if key in self.state:
+            return self.state[key]
+        if key in self._lazy_resolvers:
+            try:
+                return self._lazy_resolvers[key]()
+            except Exception:
+                return default
+        return default
+
+    def set(self, key: str, value: Any) -> None:
+        """Set a service or state value."""
+        self.services[key] = value
+
+    def set_state(self, key: str, value: Any) -> None:
+        """Set a runtime state value."""
+        self.state[key] = value
+
+    def get_state(self, key: str, default: Any = None) -> Any:
+        """Get a runtime state value."""
+        return self.state.get(key, default)
+
+    @property
+    def params(self) -> "PipelineParams | None":
+        """Get current pipeline params (for animation)."""
+        return self._params
+
+    @params.setter
+    def params(self, value: "PipelineParams") -> None:
+        """Set pipeline params (from animation controller)."""
+        self._params = value
+
+    def has_capability(self, capability: str) -> bool:
+        """Check if a capability is available."""
+        return capability in self.services or capability in self._lazy_resolvers
+
+
+class StageError(Exception):
+    """Raised when a stage fails to process."""
+
+    def __init__(self, stage_name: str, message: str, is_optional: bool = False):
+        self.stage_name = stage_name
+        self.message = message
+        self.is_optional = is_optional
+        super().__init__(f"Stage '{stage_name}' failed: {message}")
+
+
+def create_stage_error(
+    stage_name: str, error: Exception, is_optional: bool = False
+) -> StageError:
+    """Helper to create a StageError from an exception."""
+    return StageError(stage_name, str(error), is_optional)

sideline/pipeline/params.py

@@ -0,0 +1,152 @@
+"""
+Pipeline parameters - Runtime configuration layer for animation control.
+
+PipelineParams is the target for AnimationController - animation events
+modify these params, which the pipeline then applies to its stages.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+try:
+    from sideline.display import BorderMode
+except ImportError:
+    BorderMode = object  # Fallback for type checking
+
+
+@dataclass
+class PipelineParams:
+    """Runtime configuration for the pipeline.
+
+    This is the canonical config object that AnimationController modifies.
+    Stages read from these params to adjust their behavior.
+    """
+
+    # Source config
+    source: str = "headlines"
+    source_refresh_interval: float = 60.0
+
+    # Display config
+    display: str = "terminal"
+    border: bool | BorderMode = False
+    positioning: str = "mixed"  # Positioning mode: "absolute", "relative", "mixed"
+
+    # Camera config
+    camera_mode: str = "vertical"
+    camera_speed: float = 1.0  # Default speed
+    camera_x: int = 0  # For horizontal scrolling
+
+    # Effect config
+    effect_order: list[str] = field(
+        default_factory=lambda: ["noise", "fade", "glitch", "firehose"]
+    )
+    effect_enabled: dict[str, bool] = field(default_factory=dict)
+    effect_intensity: dict[str, float] = field(default_factory=dict)
+
+    # Animation-driven state (set by AnimationController)
+    pulse: float = 0.0
+    current_effect: str | None = None
+    path_progress: float = 0.0
+
+    # Viewport
+    viewport_width: int = 80
+    viewport_height: int = 24
+
+    # Firehose
+    firehose_enabled: bool = False
+
+    # Runtime state
+    frame_number: int = 0
+    fps: float = 60.0
+
+    def get_effect_config(self, name: str) -> tuple[bool, float]:
+        """Get (enabled, intensity) for an effect."""
+        enabled = self.effect_enabled.get(name, True)
+        intensity = self.effect_intensity.get(name, 1.0)
+        return enabled, intensity
+
+    def set_effect_config(self, name: str, enabled: bool, intensity: float) -> None:
+        """Set effect configuration."""
+        self.effect_enabled[name] = enabled
+        self.effect_intensity[name] = intensity
+
+    def is_effect_enabled(self, name: str) -> bool:
+        """Check if an effect is enabled."""
+        if name not in self.effect_enabled:
+            return True  # Default to enabled
+        return self.effect_enabled.get(name, True)
+
+    def get_effect_intensity(self, name: str) -> float:
+        """Get effect intensity (0.0 to 1.0)."""
+        return self.effect_intensity.get(name, 1.0)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "source": self.source,
+            "display": self.display,
+            "positioning": self.positioning,
+            "camera_mode": self.camera_mode,
+            "camera_speed": self.camera_speed,
+            "effect_order": self.effect_order,
+            "effect_enabled": self.effect_enabled.copy(),
+            "effect_intensity": self.effect_intensity.copy(),
+            "pulse": self.pulse,
+            "current_effect": self.current_effect,
+            "viewport_width": self.viewport_width,
+            "viewport_height": self.viewport_height,
+            "firehose_enabled": self.firehose_enabled,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "PipelineParams":
+        """Create from dictionary."""
+        params = cls()
+        for key, value in data.items():
+            if hasattr(params, key):
+                setattr(params, key, value)
+        return params
+
+    def copy(self) -> "PipelineParams":
+        """Create a copy of this params object."""
+        params = PipelineParams()
+        params.source = self.source
+        params.display = self.display
+        params.camera_mode = self.camera_mode
+        params.camera_speed = self.camera_speed
+        params.camera_x = self.camera_x
+        params.effect_order = self.effect_order.copy()
+        params.effect_enabled = self.effect_enabled.copy()
+        params.effect_intensity = self.effect_intensity.copy()
+        params.pulse = self.pulse
+        params.current_effect = self.current_effect
+        params.path_progress = self.path_progress
+        params.viewport_width = self.viewport_width
+        params.viewport_height = self.viewport_height
+        params.firehose_enabled = self.firehose_enabled
+        params.frame_number = self.frame_number
+        params.fps = self.fps
+        return params
+
+
+# Default params for different modes
+DEFAULT_HEADLINE_PARAMS = PipelineParams(
+    source="headlines",
+    display="terminal",
+    camera_mode="vertical",
+    effect_order=["noise", "fade", "glitch", "firehose"],
+)
+
+DEFAULT_PYGAME_PARAMS = PipelineParams(
+    source="headlines",
+    display="pygame",
+    camera_mode="vertical",
+    effect_order=["noise", "fade", "glitch", "firehose"],
+)
+
+DEFAULT_PIPELINE_PARAMS = PipelineParams(
+    source="pipeline",
+    display="pygame",
+    camera_mode="trace",
+    effect_order=[],  # No effects for pipeline viz
+)

sideline/pipeline/registry.py

@@ -0,0 +1,242 @@
+"""
+Stage registry - Unified registration for all pipeline stages.
+
+Provides a single registry for sources, effects, displays, and cameras.
+Supports plugin discovery via entry points and explicit registration.
+"""
+
+from __future__ import annotations
+
+import importlib
+import importlib.metadata
+import logging
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from sideline.pipeline.core import Stage
+
+if TYPE_CHECKING:
+    from sideline.pipeline.core import Stage
+
+T = TypeVar("T")
+logger = logging.getLogger(__name__)
+
+
+class StageRegistry:
+    """Unified registry for all pipeline stage types.
+
+    Supports both explicit registration and automatic discovery via entry points.
+    Plugins can be registered manually or discovered automatically.
+    """
+
+    _categories: dict[str, dict[str, type[Any]]] = {}
+    _discovered: bool = False
+    _instances: dict[str, Stage] = {}
+    _plugins_discovered: bool = False
+    _plugin_modules: set[str] = set()  # Track loaded plugin modules
+
+    @classmethod
+    def register(cls, category: str, stage_class: type[Any]) -> None:
+        """Register a stage class in a category.
+
+        Args:
+            category: Category name (source, effect, display, camera)
+            stage_class: Stage subclass to register
+        """
+        if category not in cls._categories:
+            cls._categories[category] = {}
+
+        key = getattr(stage_class, "__name__", stage_class.__class__.__name__)
+        cls._categories[category][key] = stage_class
+
+    @classmethod
+    def get(cls, category: str, name: str) -> type[Any] | None:
+        """Get a stage class by category and name."""
+        return cls._categories.get(category, {}).get(name)
+
+    @classmethod
+    def list(cls, category: str) -> list[str]:
+        """List all stage names in a category."""
+        return list(cls._categories.get(category, {}).keys())
+
+    @classmethod
+    def list_categories(cls) -> list[str]:
+        """List all registered categories."""
+        return list(cls._categories.keys())
+
+    @classmethod
+    def create(cls, category: str, name: str, **kwargs) -> Stage | None:
+        """Create a stage instance by category and name."""
+        stage_class = cls.get(category, name)
+        if stage_class:
+            return stage_class(**kwargs)
+        return None
+
+    @classmethod
+    def create_instance(cls, stage: Stage | type[Stage], **kwargs) -> Stage:
+        """Create an instance from a stage class or return as-is."""
+        if isinstance(stage, Stage):
+            return stage
+        if isinstance(stage, type) and issubclass(stage, Stage):
+            return stage(**kwargs)
+        raise TypeError(f"Expected Stage class or instance, got {type(stage)}")
+
+    @classmethod
+    def register_instance(cls, name: str, stage: Stage) -> None:
+        """Register a stage instance by name."""
+        cls._instances[name] = stage
+
+    @classmethod
+    def get_instance(cls, name: str) -> Stage | None:
+        """Get a registered stage instance by name."""
+        return cls._instances.get(name)
+
+    @classmethod
+    def register_plugin_module(cls, plugin_module: str) -> None:
+        """Register stages from an external plugin module.
+
+        The module should define a register_stages(registry) function.
+
+        Args:
+            plugin_module: Full module path (e.g., 'engine.plugins')
+        """
+        if plugin_module in cls._plugin_modules:
+            logger.debug(f"Plugin module {plugin_module} already loaded")
+            return
+
+        try:
+            module = importlib.import_module(plugin_module)
+            if hasattr(module, "register_stages"):
+                module.register_stages(cls)
+                cls._plugin_modules.add(plugin_module)
+                logger.info(f"Registered stages from {plugin_module}")
+            else:
+                logger.warning(
+                    f"Plugin module {plugin_module} has no register_stages function"
+                )
+        except ImportError as e:
+            logger.warning(f"Failed to import plugin module {plugin_module}: {e}")
+
+    # Backward compatibility alias
+    register_plugin = register_plugin_module
+
+    @classmethod
+    def discover_plugins(cls) -> None:
+        """Auto-discover and register plugins via entry points.
+
+        Looks for 'sideline.stages' entry points in installed packages.
+        Each entry point should point to a register_stages(registry) function.
+        """
+        if cls._plugins_discovered:
+            return
+
+        try:
+            # Discover entry points for sideline.stages
+            # Python 3.12+ changed the entry_points() API
+            try:
+                entry_points = importlib.metadata.entry_points()
+                if hasattr(entry_points, "get"):
+                    # Python < 3.12
+                    stages_eps = entry_points.get("sideline.stages", [])
+                else:
+                    # Python 3.12+
+                    stages_eps = entry_points.select(group="sideline.stages")
+            except Exception:
+                # Fallback: try both approaches
+                try:
+                    entry_points = importlib.metadata.entry_points()
+                    stages_eps = entry_points.get("sideline.stages", [])
+                except Exception:
+                    stages_eps = []
+
+            for ep in stages_eps:
+                try:
+                    register_func = ep.load()
+                    if callable(register_func):
+                        register_func(cls)
+                        logger.info(f"Discovered and registered plugin: {ep.name}")
+                except Exception as e:
+                    logger.warning(f"Failed to load entry point {ep.name}: {e}")
+
+            cls._plugins_discovered = True
+        except Exception as e:
+            logger.warning(f"Failed to discover plugins: {e}")
+
+    @classmethod
+    def get_discovered_modules(cls) -> set[str]:
+        """Get set of plugin modules that have been loaded."""
+        return cls._plugin_modules.copy()
+
+
+def discover_stages() -> None:
+    """Auto-discover and register all stage implementations.
+
+    This function now only registers framework-level stages (displays, etc.).
+    Application-specific stages should be registered via plugins.
+    """
+    if StageRegistry._discovered:
+        return
+
+    # Register display stages (framework-level)
+    _register_display_stages()
+
+    # Discover plugins via entry points
+    StageRegistry.discover_plugins()
+
+    StageRegistry._discovered = True
+
+
+def _register_display_stages() -> None:
+    """Register display backends as stages."""
+    try:
+        from sideline.display import DisplayRegistry
+    except ImportError:
+        return
+
+    DisplayRegistry.initialize()
+
+    for backend_name in DisplayRegistry.list_backends():
+        factory = _DisplayStageFactory(backend_name)
+        StageRegistry._categories.setdefault("display", {})[backend_name] = factory
+
+
+class _DisplayStageFactory:
+    """Factory that creates DisplayStage instances for a specific backend."""
+
+    def __init__(self, backend_name: str):
+        self._backend_name = backend_name
+
+    def __call__(self):
+        from sideline.display import DisplayRegistry
+        from sideline.pipeline.adapters import DisplayStage
+
+        display = DisplayRegistry.create(self._backend_name)
+        if display is None:
+            raise RuntimeError(
+                f"Failed to create display backend: {self._backend_name}"
+            )
+        return DisplayStage(display, name=self._backend_name)
+
+    @property
+    def __name__(self) -> str:
+        return self._backend_name.capitalize() + "Stage"
+
+
+# Convenience functions
+def register_source(stage_class: type[Stage]) -> None:
+    """Register a source stage."""
+    StageRegistry.register("source", stage_class)
+
+
+def register_effect(stage_class: type[Stage]) -> None:
+    """Register an effect stage."""
+    StageRegistry.register("effect", stage_class)
+
+
+def register_display(stage_class: type[Stage]) -> None:
+    """Register a display stage."""
+    StageRegistry.register("display", stage_class)
+
+
+def register_camera(stage_class: type[Stage]) -> None:
+    """Register a camera stage."""
+    StageRegistry.register("camera", stage_class)

sideline/pipeline/stages/framebuffer.py

@@ -0,0 +1,174 @@
+"""
+Frame buffer stage - stores previous frames for temporal effects.
+
+Provides (per-instance, using instance name):
+- framebuffer.{name}.history: list of previous buffers (most recent first)
+- framebuffer.{name}.intensity_history: list of corresponding intensity maps
+- framebuffer.{name}.current_intensity: intensity map for current frame
+
+Capability: "framebuffer.history.{name}"
+"""
+
+import threading
+from dataclasses import dataclass
+from typing import Any
+
+from sideline.display import _strip_ansi
+from sideline.pipeline.core import DataType, PipelineContext, Stage
+
+
+@dataclass
+class FrameBufferConfig:
+    """Configuration for FrameBufferStage."""
+
+    history_depth: int = 2  # Number of previous frames to keep
+    name: str = "default"  # Unique instance name for capability and context keys
+
+
+class FrameBufferStage(Stage):
+    """Stores frame history and computes intensity maps.
+
+    Supports multiple instances with unique capabilities and context keys.
+    """
+
+    name = "framebuffer"
+    category = "effect"  # It's an effect that enriches context with frame history
+
+    def __init__(
+        self,
+        config: FrameBufferConfig | None = None,
+        history_depth: int = 2,
+        name: str = "default",
+    ):
+        self.config = config or FrameBufferConfig(
+            history_depth=history_depth, name=name
+        )
+        self._lock = threading.Lock()
+
+    @property
+    def capabilities(self) -> set[str]:
+        return {f"framebuffer.history.{self.config.name}"}
+
+    @property
+    def dependencies(self) -> set[str]:
+        # Depends on rendered output (since we want to capture final buffer)
+        return {"render.output"}
+
+    @property
+    def inlet_types(self) -> set:
+        return {DataType.TEXT_BUFFER}
+
+    @property
+    def outlet_types(self) -> set:
+        return {DataType.TEXT_BUFFER}  # Pass through unchanged
+
+    def init(self, ctx: PipelineContext) -> bool:
+        """Initialize framebuffer state in context."""
+        prefix = f"framebuffer.{self.config.name}"
+        ctx.set(f"{prefix}.history", [])
+        ctx.set(f"{prefix}.intensity_history", [])
+        return True
+
+    def process(self, data: Any, ctx: PipelineContext) -> Any:
+        """Store frame in history and compute intensity.
+
+        Args:
+            data: Current text buffer (list[str])
+            ctx: Pipeline context
+
+        Returns:
+            Same buffer (pass-through)
+        """
+        if not isinstance(data, list):
+            return data
+
+        prefix = f"framebuffer.{self.config.name}"
+
+        # Compute intensity map for current buffer (per-row, length = buffer rows)
+        intensity_map = self._compute_buffer_intensity(data, len(data))
+
+        # Store in context
+        ctx.set(f"{prefix}.current_intensity", intensity_map)
+
+        with self._lock:
+            # Get existing histories
+            history = ctx.get(f"{prefix}.history", [])
+            intensity_hist = ctx.get(f"{prefix}.intensity_history", [])
+
+            # Prepend current frame to history
+            history.insert(0, data.copy())
+            intensity_hist.insert(0, intensity_map)
+
+            # Trim to configured depth
+            max_depth = self.config.history_depth
+            ctx.set(f"{prefix}.history", history[:max_depth])
+            ctx.set(f"{prefix}.intensity_history", intensity_hist[:max_depth])
+
+        return data
+
+    def _compute_buffer_intensity(
+        self, buf: list[str], max_rows: int = 24
+    ) -> list[float]:
+        """Compute average intensity per row in buffer.
+
+        Uses ANSI color if available; falls back to character density.
+
+        Args:
+            buf: Text buffer (list of strings)
+            max_rows: Maximum number of rows to process
+
+        Returns:
+            List of intensity values (0.0-1.0) per row
+        """
+        intensities = []
+        # Limit to viewport height
+        lines = buf[:max_rows]
+
+        for line in lines:
+            # Strip ANSI codes for length calc
+
+            plain = _strip_ansi(line)
+            if not plain:
+                intensities.append(0.0)
+                continue
+
+            # Simple heuristic: ratio of non-space characters
+            # More sophisticated version could parse ANSI RGB brightness
+            filled = sum(1 for c in plain if c not in (" ", "\t"))
+            total = len(plain)
+            intensity = filled / total if total > 0 else 0.0
+            intensities.append(max(0.0, min(1.0, intensity)))
+
+        # Pad to max_rows if needed
+        while len(intensities) < max_rows:
+            intensities.append(0.0)
+
+        return intensities
+
+    def get_frame(
+        self, index: int = 0, ctx: PipelineContext | None = None
+    ) -> list[str] | None:
+        """Get frame from history by index (0 = current, 1 = previous, etc)."""
+        if ctx is None:
+            return None
+        prefix = f"framebuffer.{self.config.name}"
+        history = ctx.get(f"{prefix}.history", [])
+        if 0 <= index < len(history):
+            return history[index]
+        return None
+
+    def get_intensity(
+        self, index: int = 0, ctx: PipelineContext | None = None
+    ) -> list[float] | None:
+        """Get intensity map from history by index."""
+        if ctx is None:
+            return None
+        prefix = f"framebuffer.{self.config.name}"
+        intensity_hist = ctx.get(f"{prefix}.intensity_history", [])
+        if 0 <= index < len(intensity_hist):
+            return intensity_hist[index]
+        return None
+
+    def cleanup(self) -> None:
+        """Cleanup resources."""
+        pass