feat: add ServiceRegistry, ScopeWindowFactory, ButtonPanel, and System Monitor

Major architectural refactoring to add reusable services and components.

NEW SERVICES:
- ServiceRegistry: Centralized widget/service registration and lookup
  - AutoRegisterServiceMixin for automatic registration
  - Type-based service resolution
  - Breaks circular dependencies (no more floating_windows)
- ScopeWindowFactory: Handler-based window creation system
  - Regex pattern matching for scope_ids
  - Handler registration with callback dispatch
  - Time-travel integration with object_state parameter
- PersistentSystemMonitor: Background thread-based system monitoring
  - Non-blocking metric collection (CPU, RAM, GPU, VRAM)
  - Thread-safe history management
  - PyQt6 signal integration

NEW COMPONENTS:
- ButtonPanel: Reusable button panel with BUTTON_CONFIGS pattern
  - Extracted from AbstractManagerWidget
  - Declarative configuration: [(label, action_id, tooltip), ...]
  - Flexible layout: grid_columns parameter
- SystemMonitorWidget: PyQt6 system monitor (migrated from Textual TUI)
  - Real-time graphs with PyQtGraph
  - Lazy pyqtgraph import (8+ second startup delay avoided)
  - Declarative button configuration

LOG VIEWER SYSTEM:
- LogStreamer: Stream log lines as JSONL chunks
- LogHighlighter: Subprocess-based log line highlighting
  - Timestamps (gray), Log levels (color+bold), Logger names (purple)
  - File paths (green), Python strings (brown), Numbers (light gray-green)
- LogLoader: Efficient log file loading
- LogHighlightClient: Coordinates subprocess communication
- LogViewerWidget: UI widget with syntax highlighting

FLASH ANIMATION ENHANCEMENTS:
- Widget-type-specific masking strategies
  - Checkbox: Square cutout (no rounding) for textless checkboxes
  - Label: Tight masking using sizeHint()
  - Help button: Fixed square masking when _square_size set
  - Function pane: Title row widgets masking
- INVERSE mode: Masks title + leaf_widget + label_widget
- get_child_mask_rect(): Single source of truth for child masking

PARAMETER FORM LIFECYCLE:
- Sequence number tracking (_pfm_seq) for form manager instances
- Enhanced debug logging for async widget creation
- Nested form manager tracking
- Batch widget creation with progressive scope accent styling

PERFORMANCE MONITORING:
- Performance logger changed from DEBUG to WARNING
- Timer context manager for performance tracking
- Performance metrics for common operations documented

SERVICE INTEGRATION:
- All widget lookups migrated from QApplication.topLevelWidgets()
  to ServiceRegistry.get()
- Removed floating_windows dictionary from main window
- AutoRegisterServiceMixin for automatic service registration
- WindowFactory.create_window_for_scope() with time-travel support

DOCUMENTATION:
- service_registry.rst: ServiceRegistry pattern and usage
- scope_window_factory.rst: Generic scope window factory
- button_panel.rst: ButtonPanel component documentation
- system_monitor.rst: PyQt6 system monitor
- system_monitor_core.rst: Framework-agnostic monitoring core
- persistent_system_monitor.rst: Background thread monitor
- log_viewer_system.rst: Log viewer with syntax highlighting
- Updated flash_animation_system.rst: Widget-type-specific masking
- Updated gui_performance_patterns.rst: Performance monitoring
- Updated parameter_form_lifecycle.rst: Sequence tracking
- Updated index.rst: New docs added

Related to OpenHCS ServiceRegistry integration refactoring.

Author: trissim

docs/architecture/button_panel.rst

@@ -0,0 +1,232 @@
+Button Panel Component
+=====================
+
+**Reusable button panel with declarative configuration.**
+
+**Module**: ``pyqt_reactive.widgets.shared.button_panel``
+
+Overview
+--------
+
+``ButtonPanel`` provides a reusable button panel component that can be used by any widget without requiring inheritance. It uses a declarative ``BUTTON_CONFIGS`` format for specifying buttons.
+
+This component was extracted from ``AbstractManagerWidget`` to allow widgets to use the same button panel pattern without inheriting from the full manager class.
+
+Architecture
+------------
+
+``ButtonPanel`` uses a simple declarative configuration:
+
+.. code-block:: python
+
+    BUTTON_CONFIGS = [
+        ("Refresh", "refresh", "Refresh the display"),
+        ("Toggle", "toggle_layout", "Toggle between layouts"),
+        ("Export", "export", "Export data"),
+    ]
+
+Each button configuration is a tuple of:
+- **label**: Button text (e.g., "Refresh")
+- **action_id**: Identifier passed to callback (e.g., "refresh")
+- **tooltip**: Tooltip text (e.g., "Refresh the display")
+
+Usage
+-----
+
+Basic Usage
+~~~~~~~~~~
+
+.. code-block:: python
+
+    from pyqt_reactive.widgets.shared.button_panel import ButtonPanel
+    from pyqt_reactive.theming import StyleSheetGenerator
+
+    # Define button configurations
+    BUTTON_CONFIGS = [
+        ("Refresh", "refresh", "Refresh the display"),
+        ("Toggle", "toggle_layout", "Toggle between layouts"),
+        ("Export", "export", "Export data"),
+    ]
+
+    # Create button panel
+    panel = ButtonPanel(
+        button_configs=BUTTON_CONFIGS,
+        on_action=self.handle_button_action,
+        style_generator=self.style_generator,
+    )
+
+    # Add panel to layout
+    layout.addWidget(panel)
+
+Action Handler
+~~~~~~~~~~~~~~~
+
+The ``on_action`` callback receives the ``action_id`` from the clicked button:
+
+.. code-block:: python
+
+    def handle_button_action(self, action_id: str):
+        """Handle button actions."""
+        if action_id == "refresh":
+            self.refresh_display()
+        elif action_id == "toggle_layout":
+            self.toggle_layout()
+        elif action_id == "export":
+            self.export_data()
+
+Grid Layout
+~~~~~~~~~~~~
+
+By default, buttons are laid out in a single horizontal row. You can specify a grid layout:
+
+.. code-block:: python
+
+    panel = ButtonPanel(
+        button_configs=self.BUTTON_CONFIGS,
+        on_action=self.handle_button_action,
+        grid_columns=2,  # 2 columns
+    )
+
+This creates a grid with the specified number of columns:
+
+.. list-table::
+   :header-rows: 1
+
+   * - grid_columns
+     - Layout
+   * - 0
+     - Single horizontal row
+   * - 1
+     - Single vertical column
+   * - 2
+     - 2x2 grid
+   * - 3
+     - 3x2 grid
+   * - 4
+     - 4x2 grid
+
+Integration with SystemMonitor
+---------------------------
+
+``SystemMonitor`` uses ``ButtonPanel`` for its action buttons:
+
+.. code-block:: python
+
+    class SystemMonitorWidget(QWidget):
+        """System Monitor Widget."""
+
+        # Declarative button configuration
+        BUTTON_CONFIGS = [
+            ("Global Config", "global_config", "Open global configuration editor"),
+            ("Log Viewer", "log_viewer", "Open log viewer window"),
+            ("Custom Functions", "custom_functions", "Manage custom functions"),
+            ("Test Plate", "test_plate", "Generate synthetic test plate"),
+        ]
+
+        BUTTON_GRID_COLUMNS = 0  # Single row
+
+        def __init__(self, color_scheme=None, config=None, parent=None):
+            super().__init__(parent)
+
+            # Create button panel
+            self.button_panel = ButtonPanel(
+                button_configs=self.BUTTON_CONFIGS,
+                style_generator=self.style_generator,
+                grid_columns=self.BUTTON_GRID_COLUMNS,
+            )
+
+            # Connect actions
+            self.button_panel.action_triggered.connect(self.handle_button_action)
+
+        def handle_button_action(self, action_id: str):
+            """Handle button panel actions."""
+            if action_id == "global_config":
+                self.show_global_config.emit()
+            elif action_id == "log_viewer":
+                self.show_log_viewer.emit()
+            # ... etc
+
+Styling
+-------
+
+``ButtonPanel`` integrates with ``StyleSheetGenerator`` for consistent styling:
+
+.. code-block:: python
+
+    from pyqt_reactive.theming import StyleSheetGenerator, ColorScheme
+
+    color_scheme = ColorScheme()
+    style_generator = StyleSheetGenerator(color_scheme)
+
+    panel = ButtonPanel(
+        button_configs=self.BUTTON_CONFIGS,
+        on_action=self.handle_button_action,
+        style_generator=style_generator,  # Apply styles
+    )
+
+Signals
+-------
+
+**action_triggered** (pyqtSignal)
+
+Emitted when a button is clicked. Provides the ``action_id``:
+
+.. code-block:: python
+
+    panel.action_triggered.connect(lambda action_id: print(f"Action: {action_id}"))
+
+Migration from AbstractManagerWidget
+----------------------------------
+
+Before (AbstractManagerWidget):
+
+.. code-block:: python
+
+    class MyWidget(AbstractManagerWidget):
+        """Widget with button panel."""
+
+        BUTTON_CONFIGS = [
+            ("Refresh", "refresh", "Refresh the display"),
+        ]
+
+        def __init__(self):
+            super().__init__()
+            # Button panel created automatically by AbstractManagerWidget
+
+After (ButtonPanel):
+
+.. code-block:: python
+
+    class MyWidget(QWidget):
+        """Widget with button panel."""
+
+        def __init__(self):
+            super().__init__()
+
+            # Create button panel manually
+            self.button_panel = ButtonPanel(
+                button_configs=[
+                    ("Refresh", "refresh", "Refresh the display"),
+                ],
+                on_action=self.handle_button_action,
+            )
+
+        def handle_button_action(self, action_id: str):
+            if action_id == "refresh":
+                self.refresh()
+
+Benefits
+---------
+
+- **No inheritance required**: Use with any widget class
+- **Declarative configuration**: Define buttons in a list
+- **Flexible layout**: Single row or grid layout
+- **Consistent styling**: Integrates with StyleSheetGenerator
+- **Action-based**: Simple callback interface with action IDs
+
+See Also
+--------
+
+- :doc:`abstract_manager_widget` - Abstract manager widget (original button panel location)
+- :doc:`responsive_layout_widgets` - Responsive layout components
+- :doc:`system_monitor` - System monitor usage example

docs/architecture/flash_animation_system.rst

@@ -73,6 +73,53 @@ Flash animations have three phases with configurable durations:
 2. **hold** (50ms): Hold at maximum intensity
 3. **fade_out** (350ms): Slow fade-out with InOutCubic easing
 
+Widget-Type-Specific Masking
+--------------------------------
+
+Flash animations use widget-type-specific masking strategies for precise visual feedback:
+
+**Masking Strategies**:
+
+- **Checkbox**: Tight mask for indicator + label text using Qt style subelement rects
+- **Label**: Tight mask using ``sizeHint()`` to avoid empty layout space
+- **Help Button**: Fixed square mask when ``_square_size`` is set
+- **All other widgets**: Full rectangle mask
+
+**Checkbox Square Cutout**:
+
+Textless checkboxes (no label) use square cutouts to avoid rounding:
+
+.. code-block:: python
+
+    def _needs_square_checkbox_mask(widget: QWidget) -> bool:
+        return isinstance(widget, QCheckBox) and not widget.text()
+
+**Function Pane Title Masking**:
+
+Function panes mask title row widgets tightly:
+
+.. code-block:: python
+
+    def _get_function_pane_title_widgets(groupbox: QWidget) -> List[QWidget]:
+        pane = groupbox
+        while pane is not None:
+            if hasattr(pane, "_flash_title_container") or hasattr(pane, "_module_path_label"):
+                break
+            pane = pane.parentWidget()
+
+        widgets = []
+        module_label = getattr(pane, "_module_path_label", None)
+        if module_label and module_label.isVisible():
+            widgets.append(module_label)
+
+        title_container = getattr(pane, "_flash_title_container", None)
+        if title_container and title_container.isVisible():
+            for child in title_container.findChildren(QWidget):
+                if child.isVisible() and isinstance(child, LEAF_WIDGET_TYPES):
+                    widgets.append(child)
+
+        return widgets
+
 FlashElement Types
 ------------------
 
@@ -86,14 +133,38 @@ The system supports multiple element types via ``FlashElement`` dataclass:
      - Use Case
    * - Groupbox
      - ``create_groupbox_element()``
-     - Form section headers
+     - Form section headers (STANDARD mode masks all children, INVERSE mode masks title + leaf_widget)
+   * - Groupbox (full rect)
+     - ``create_groupbox_element(..., use_full_rect=True)``
+     - Flash entire groupbox geometry (no margin-top offset)
    * - Tree Item
      - ``create_tree_item_element()``
      - Config hierarchy trees
    * - List Item
      - ``create_list_item_element()``
      - Step/function lists
 
+INVERSE Mode with Label Widget Masking
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+INVERSE mode now masks title + leaf_widget + label_widget (not all title row widgets):
+
+.. code-block:: python
+
+    self.register_flash_leaf(
+        key="my_field",
+        groupbox=my_groupbox,
+        leaf_widget=my_widget,
+        label_widget=my_label  # NEW: mask label too
+    )
+
+This highlights "all fields that inherited the change" while keeping the changed field and its label visible.
+
+**Masking Behavior**:
+
+- **STANDARD mode** (``leaf_widget=None``): Mask ALL children, flash only frame/background
+- **INVERSE mode** (``leaf_widget=widget``): Mask title + leaf_widget + label_widget, flash frame + all siblings
+
 Usage with FlashMixin
 ---------------------
 

docs/architecture/gui_performance_patterns.rst

@@ -1000,3 +1000,55 @@ When editing ``WellFilterConfig.well_filter`` in ``PipelineConfig``:
 - Before: 3-5 sibling refreshes per keystroke (all siblings)
 - After: 0-2 sibling refreshes per keystroke (only affected siblings)
 - Measured improvement: ~5-10ms per keystroke in complex configs
+
+Performance Monitoring
+---------------------
+
+The system includes a performance monitor for tracking widget creation and form operations.
+
+**Performance Logger**:
+
+.. code-block:: python
+
+    from pyqt_reactive.core.performance_monitor import perf_logger
+
+    perf_logger.debug(f"Operation took {duration_ms:.2f}ms")
+
+**Logging Level**:
+
+Performance logger uses ``WARNING`` level by default to reduce log noise:
+
+.. code-block:: python
+
+    perf_logger.setLevel(logging.WARNING)
+
+This suppresses routine performance measurements in normal operation while still logging performance issues when they occur.
+
+**Timer Context Manager**:
+
+.. code-block:: python
+
+    from pyqt_reactive.core.performance_monitor import timer
+
+    with timer("Widget creation", threshold_ms=5.0):
+        widget = create_complex_widget()
+
+Operations slower than ``threshold_ms`` are logged to ``perf_logger``.
+
+**Usage Guidelines**:
+
+- Use ``timer`` for operations that may be slow (>5ms)
+- Set appropriate ``threshold_ms`` for each context
+- Only log operations that are likely to be performance bottlenecks
+- Avoid excessive logging in hot paths (like paint events)
+
+**Performance Metrics**:
+
+Common operation timings:
+
+- Widget creation: 1-50ms (depends on complexity)
+- Form initialization: 10-200ms (depends on parameter count)
+- Placeholder refresh: 1-10ms (per field)
+- Cross-window update: 5-20ms (per affected window)
+
+Operations exceeding these thresholds are flagged for investigation.