fix(tools-tab): don't expose filesystem paths in OSError messages

CodeQL flagged str(exc) flowing into the JSON response for the
install_plugin_requirements action. Use exc.strerror instead, which
gives the OS error description ("No such file or directory",
"Permission denied") without the internal filesystem path.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.codacy.yml

@@ -4,3 +4,4 @@ exclude_paths:
   - "plugins/**"
   - "assets/**"
   - "test/**"
+  - "scripts/debug/**"

.cursor/README.md

@@ -0,0 +1,145 @@
+# Cursor Helper Files for LEDMatrix Plugin Development
+
+This directory contains Cursor-specific helper files to assist with plugin development in the LEDMatrix project.
+
+## Files Overview
+
+### `.cursorrules`
+Comprehensive rules file that Cursor uses to understand plugin development patterns, best practices, and workflows. This file is automatically loaded by Cursor and helps guide AI-assisted development.
+
+### `plugins_guide.md`
+Detailed guide covering:
+- Plugin system overview
+- Creating new plugins
+- Running plugins (emulator and hardware)
+- Loading and configuring plugins
+- Development workflow
+- Testing strategies
+- Troubleshooting
+
+### `plugin_templates/`
+Template files for quick plugin creation:
+- `manifest.json.template` - Plugin metadata template
+- `manager.py.template` - Plugin class template
+- `config_schema.json.template` - Configuration schema template
+- `README.md.template` - Plugin documentation template
+- `requirements.txt.template` - Dependencies template
+- `QUICK_START.md` - Quick start guide for using templates
+
+## Quick Reference
+
+### Creating a New Plugin
+
+1. **Using templates** (recommended):
+```bash
+# See QUICK_START.md in plugin_templates/
+cd plugins
+mkdir my-plugin
+cd my-plugin
+cp ../../.cursor/plugin_templates/*.template .
+# Edit files, replacing PLUGIN_ID and other placeholders
+```
+
+2. **Using dev_plugin_setup.sh**:
+```bash
+# Link from GitHub
+./scripts/dev/dev_plugin_setup.sh link-github my-plugin
+
+# Link local repo
+./scripts/dev/dev_plugin_setup.sh link my-plugin /path/to/repo
+```
+
+### Running the Display
+
+```bash
+# Emulator mode (development, no hardware required)
+python3 run.py --emulator
+# (equivalent: EMULATOR=true python3 run.py)
+
+# Hardware (production, requires the rpi-rgb-led-matrix submodule built)
+python3 run.py
+
+# As a systemd service
+sudo systemctl start ledmatrix
+
+# Dev preview server (renders plugins to a browser without running run.py)
+python3 scripts/dev_server.py  # then open http://localhost:5001
+```
+
+The `-e`/`--emulator` CLI flag is defined in `run.py:19-20` and
+sets `os.environ["EMULATOR"] = "true"` before any display imports,
+which `src/display_manager.py:2` then reads to switch between the
+hardware and emulator backends.
+
+### Managing Plugins
+
+```bash
+# List plugins
+./scripts/dev/dev_plugin_setup.sh list
+
+# Check status
+./scripts/dev/dev_plugin_setup.sh status
+
+# Update plugin(s)
+./scripts/dev/dev_plugin_setup.sh update [plugin-name]
+
+# Unlink plugin
+./scripts/dev/dev_plugin_setup.sh unlink <plugin-name>
+```
+
+## Using These Files with Cursor
+
+### `.cursorrules`
+Cursor automatically reads this file to understand:
+- Plugin structure and requirements
+- Development workflows
+- Best practices
+- Common patterns
+- API reference
+
+When asking Cursor to help with plugins, it will use this context to provide better assistance.
+
+### Plugin Templates
+Use templates when creating new plugins:
+1. Copy templates from `.cursor/plugin_templates/`
+2. Replace placeholders (PLUGIN_ID, PluginClassName, etc.)
+3. Customize for your plugin's needs
+4. Follow the guide in `plugins_guide.md`
+
+### Documentation
+Refer to `plugins_guide.md` for:
+- Detailed explanations
+- Troubleshooting steps
+- Best practices
+- Examples and patterns
+
+## Plugin Development Workflow
+
+1. **Plan**: Determine plugin functionality and requirements
+2. **Create**: Use templates or dev_plugin_setup.sh to create plugin structure
+3. **Develop**: Implement plugin logic following BasePlugin interface
+4. **Test**: Test with emulator first, then on hardware
+5. **Configure**: Add plugin config to config/config.json
+6. **Iterate**: Refine based on testing and feedback
+
+## Resources
+
+- **Plugin System**: `src/plugin_system/`
+- **Base Plugin**: `src/plugin_system/base_plugin.py`
+- **Plugin Manager**: `src/plugin_system/plugin_manager.py`
+- **Example Plugins**: see the
+  [`ledmatrix-plugins`](https://github.com/ChuckBuilds/ledmatrix-plugins)
+  repo for canonical sources (e.g. `plugins/hockey-scoreboard/`,
+  `plugins/football-scoreboard/`). Installed plugins land in
+  `plugin-repos/` (default) or `plugins/` (dev fallback).
+- **Architecture Docs**: `docs/PLUGIN_ARCHITECTURE_SPEC.md`
+- **Development Setup**: `scripts/dev/dev_plugin_setup.sh`
+
+## Getting Help
+
+1. Check `plugins_guide.md` for detailed documentation
+2. Review `.cursorrules` for development patterns
+3. Look at existing plugins for examples
+4. Check logs for error messages
+5. Review plugin system code in `src/plugin_system/`
+

.cursor/plans/implement_audit_fixes_plan.md

@@ -0,0 +1,202 @@
+# Implementation Plan: Fix Config Schema Validation Issues
+
+Based on audit results showing 186 issues across 20 plugins.
+
+## Overview
+
+Three priority fixes identified from audit:
+1. **Priority 1 (HIGH)**: Remove core properties from required array - will fix ~150 issues
+2. **Priority 2 (MEDIUM)**: Verify default merging logic - will fix remaining required field issues
+3. **Priority 3 (LOW)**: Calendar plugin schema cleanup - will fix 3 extra field warnings
+
+## Priority 1: Remove Core Properties from Required Array
+
+### Problem
+Core properties (`enabled`, `display_duration`, `live_priority`) are system-managed but listed in schema `required` arrays. SchemaManager injects them into properties but doesn't remove them from `required`, causing validation failures.
+
+### Solution
+**File**: `src/plugin_system/schema_manager.py`
+**Location**: `validate_config_against_schema()` method, after line 295
+
+### Implementation Steps
+
+1. **Add code to remove core properties from required array**:
+   ```python
+   # After injecting core properties (around line 295), add:
+   # Remove core properties from required array (they're system-managed)
+   if "required" in enhanced_schema:
+       core_prop_names = list(core_properties.keys())
+       enhanced_schema["required"] = [
+           field for field in enhanced_schema["required"] 
+           if field not in core_prop_names
+       ]
+   ```
+
+2. **Add logging for debugging** (optional but helpful):
+   ```python
+   if "required" in enhanced_schema and core_prop_names:
+       removed_from_required = [
+           field for field in enhanced_schema.get("required", [])
+           if field in core_prop_names
+       ]
+       if removed_from_required and plugin_id:
+           self.logger.debug(
+               f"Removed core properties from required array for {plugin_id}: {removed_from_required}"
+           )
+   ```
+
+3. **Test the fix**:
+   - Run audit script: `python scripts/audit_plugin_configs.py`
+   - Expected: Issue count drops from 186 to ~30-40
+   - All "enabled" related errors should be eliminated
+
+### Expected Outcome
+- All 20 plugins should no longer fail validation due to missing `enabled` field
+- ~150 issues resolved (all enabled-related validation errors)
+
+## Priority 2: Verify Default Merging Logic
+
+### Problem
+Some plugins have required fields with defaults that should be applied before validation. Need to verify the default merging happens correctly and handles nested objects.
+
+### Solution
+**File**: `web_interface/blueprints/api_v3.py`
+**Location**: `save_plugin_config()` method, around lines 3218-3221
+
+### Implementation Steps
+
+1. **Review current default merging logic**:
+   - Check that `merge_with_defaults()` is called before validation (line 3220)
+   - Verify it's called after preserving enabled state but before validation
+
+2. **Verify merge_with_defaults handles nested objects**:
+   - Check `src/plugin_system/schema_manager.py` → `merge_with_defaults()` method
+   - Ensure it recursively merges nested objects (it does use deep_merge)
+   - Test with plugins that have nested required fields
+
+3. **Check if defaults are applied for nested required fields**:
+   - Review how `generate_default_config()` extracts defaults from nested schemas
+   - Verify nested required fields with defaults are included
+
+4. **Test with problematic plugins**:
+   - `ledmatrix-weather`: required fields `api_key`, `location_city` (check if defaults exist)
+   - `mqtt-notifications`: required field `mqtt` object (check if default exists)
+   - `text-display`: required field `text` (check if default exists)
+   - `ledmatrix-music`: required field `preferred_source` (check if default exists)
+
+5. **If defaults don't exist in schemas**:
+   - Either add defaults to schemas, OR
+   - Make fields optional in schemas if they're truly optional
+
+### Expected Outcome
+- Plugins with required fields that have schema defaults should pass validation
+- Issue count further reduced from ~30-40 to ~5-10
+
+## Priority 3: Calendar Plugin Schema Cleanup
+
+### Problem
+Calendar plugin config has fields not in schema:
+- `show_all_day` (config) but schema has `show_all_day_events` (field name mismatch)
+- `date_format` (not in schema, not used in manager.py)
+- `time_format` (not in schema, not used in manager.py)
+
+### Investigation Results
+- Schema defines: `show_all_day_events` (boolean, default: true)
+- Manager.py uses: `show_all_day_events` (line 82: `config.get('show_all_day_events', True)`)
+- Config has: `show_all_day` (wrong field name - should be `show_all_day_events`)
+- `date_format` and `time_format` appear to be deprecated (not used in manager.py)
+
+### Solution
+
+**File**: `config/config.json` → `calendar` section
+
+### Implementation Steps
+
+1. **Fix field name mismatch**:
+   - Rename `show_all_day` → `show_all_day_events` in config.json
+   - This matches the schema and manager.py code
+
+2. **Remove deprecated fields**:
+   - Remove `date_format` from config (not used in code)
+   - Remove `time_format` from config (not used in code)
+
+3. **Alternative (if fields are needed)**: Add `date_format` and `time_format` to schema
+   - Only if these fields should be supported
+   - Check if they're used anywhere else in the codebase
+
+4. **Test calendar plugin**:
+   - Run audit for calendar plugin specifically
+   - Verify no extra field warnings remain
+   - Test calendar plugin functionality to ensure it still works
+
+### Expected Outcome
+- Calendar plugin shows 0 extra field warnings
+- Final issue count: ~3-5 (only edge cases remain)
+
+## Testing Strategy
+
+### After Each Priority Fix
+
+1. **Run local audit**:
+   ```bash
+   python scripts/audit_plugin_configs.py
+   ```
+
+2. **Check issue count reduction**:
+   - Priority 1: Should drop from 186 to ~30-40
+   - Priority 2: Should drop from ~30-40 to ~5-10
+   - Priority 3: Should drop from ~5-10 to ~3-5
+
+3. **Review specific plugin results**:
+   ```bash
+   python scripts/audit_plugin_configs.py --plugin <plugin-id>
+   ```
+
+### After All Fixes
+
+1. **Full audit run**:
+   ```bash
+   python scripts/audit_plugin_configs.py
+   ```
+
+2. **Deploy to Pi**:
+   ```bash
+   ./scripts/deploy_to_pi.sh src/plugin_system/schema_manager.py web_interface/blueprints/api_v3.py
+   ```
+
+3. **Run audit on Pi**:
+   ```bash
+   ./scripts/run_audit_on_pi.sh
+   ```
+
+4. **Manual web interface testing**:
+   - Access each problematic plugin's config page
+   - Try saving configuration
+   - Verify no validation errors appear
+   - Check that configs save successfully
+
+## Success Criteria
+
+- [ ] Priority 1: All "enabled" related validation errors eliminated
+- [ ] Priority 1: Issue count reduced from 186 to ~30-40
+- [ ] Priority 2: Plugins with required fields + defaults pass validation
+- [ ] Priority 2: Issue count reduced to ~5-10
+- [ ] Priority 3: Calendar plugin extra field warnings resolved
+- [ ] Priority 3: Final issue count at ~3-5 (only edge cases)
+- [ ] All fixes work on Pi (not just local)
+- [ ] Web interface saves configs without validation errors
+
+## Files to Modify
+
+1. `src/plugin_system/schema_manager.py` - Remove core properties from required array
+2. `plugins/calendar/config_schema.json` OR `config/config.json` - Calendar cleanup (if needed)
+3. `web_interface/blueprints/api_v3.py` - May need minor adjustments for default merging (if needed)
+
+## Risk Assessment
+
+**Priority 1**: Low risk - Only affects validation logic, doesn't change behavior
+**Priority 2**: Low risk - Only ensures defaults are applied (already intended behavior)
+**Priority 3**: Very low risk - Only affects calendar plugin, cosmetic issue
+
+All changes are backward compatible and improve the system rather than changing core functionality.
+

.cursor/plugin_templates/QUICK_START.md

@@ -0,0 +1,247 @@
+# Quick Start: Creating a New Plugin
+
+This guide will help you create a new plugin using the templates in `.cursor/plugin_templates/`.
+
+## Step 1: Create Plugin Directory
+
+```bash
+cd /path/to/LEDMatrix
+mkdir -p plugins/my-plugin
+cd plugins/my-plugin
+```
+
+## Step 2: Copy Templates
+
+```bash
+# Copy all template files
+cp ../../.cursor/plugin_templates/manifest.json.template ./manifest.json
+cp ../../.cursor/plugin_templates/manager.py.template ./manager.py
+cp ../../.cursor/plugin_templates/config_schema.json.template ./config_schema.json
+cp ../../.cursor/plugin_templates/README.md.template ./README.md
+cp ../../.cursor/plugin_templates/requirements.txt.template ./requirements.txt
+```
+
+## Step 3: Customize Files
+
+### manifest.json
+
+Replace placeholders:
+- `PLUGIN_ID` → `my-plugin` (lowercase, use hyphens)
+- `Plugin Name` → Your plugin's display name
+- `PluginClassName` → `MyPlugin` (PascalCase)
+- Update description, author, homepage, etc.
+
+### manager.py
+
+Replace placeholders:
+- `PluginClassName` → `MyPlugin` (must match manifest)
+- Implement `_fetch_data()` method
+- Implement `_render_content()` method
+- Add any custom validation in `validate_config()`
+
+### config_schema.json
+
+Customize:
+- Update description
+- Add/remove configuration properties
+- Set default values
+- Add validation rules
+
+### README.md
+
+Replace placeholders:
+- `PLUGIN_ID` → `my-plugin`
+- `Plugin Name` → Your plugin's name
+- Fill in features, installation, configuration sections
+
+### requirements.txt
+
+Add your plugin's dependencies:
+```txt
+requests>=2.28.0
+pillow>=9.0.0
+```
+
+## Step 4: Enable Plugin
+
+Edit `config/config.json`:
+
+```json
+{
+  "my-plugin": {
+    "enabled": true,
+    "display_duration": 15
+  }
+}
+```
+
+## Step 5: Test Plugin
+
+### Test with Emulator
+
+```bash
+cd /path/to/LEDMatrix
+python run.py --emulator
+```
+
+### Check Plugin Loading
+
+Look for logs like:
+```
+[INFO] Discovered 1 plugin(s)
+[INFO] Loaded plugin: my-plugin v1.0.0
+[INFO] Added plugin mode: my-plugin
+```
+
+### Test Plugin Display
+
+The plugin should appear in the display rotation. Check logs for any errors.
+
+## Step 6: Develop and Iterate
+
+1. Edit `manager.py` to implement your plugin logic
+2. Test with emulator: `python run.py --emulator`
+3. Check logs for errors
+4. Iterate until working correctly
+
+## Step 7: Test on Hardware (Optional)
+
+When ready, test on Raspberry Pi:
+
+```bash
+# Deploy to Pi
+rsync -avz plugins/my-plugin/ pi@raspberrypi:/path/to/LEDMatrix/plugins/my-plugin/
+
+# Or if using git
+ssh pi@raspberrypi "cd /path/to/LEDMatrix/plugins/my-plugin && git pull"
+
+# Restart service
+ssh pi@raspberrypi "sudo systemctl restart ledmatrix"
+```
+
+## Common Customizations
+
+### Adding API Integration
+
+1. Add API key to `config_schema.json`:
+```json
+{
+  "api_key": {
+    "type": "string",
+    "description": "API key for service"
+  }
+}
+```
+
+2. Implement API call in `_fetch_data()`:
+```python
+import requests
+
+def _fetch_data(self):
+    response = requests.get(
+        "https://api.example.com/data",
+        headers={"Authorization": f"Bearer {self.api_key}"}
+    )
+    return response.json()
+```
+
+3. Store API key in `config/config_secrets.json`:
+```json
+{
+  "my-plugin": {
+    "api_key": "your-secret-key"
+  }
+}
+```
+
+### Adding Image Rendering
+
+There is no `draw_image()` helper on `DisplayManager`. To render an
+image, paste it directly onto the underlying PIL `Image`
+(`display_manager.image`) and then call `update_display()`:
+
+```python
+def _render_content(self):
+    # Load and paste image onto the display canvas
+    image = Image.open("assets/logo.png").convert("RGB")
+    self.display_manager.image.paste(image, (0, 0))
+
+    # Draw text overlay
+    self.display_manager.draw_text(
+        "Text",
+        x=10, y=20,
+        color=(255, 255, 255)
+    )
+
+    self.display_manager.update_display()
+```
+
+For transparency, paste with a mask:
+
+```python
+icon = Image.open("assets/icon.png").convert("RGBA")
+self.display_manager.image.paste(icon, (5, 5), icon)
+```
+
+
+### Adding Live Priority
+
+1. Enable in config:
+```json
+{
+  "my-plugin": {
+    "live_priority": true
+  }
+}
+```
+
+2. Implement `has_live_content()`:
+```python
+def has_live_content(self) -> bool:
+    return self.data and self.data.get("is_live", False)
+```
+
+3. Override `get_live_modes()` if needed:
+```python
+def get_live_modes(self) -> list:
+    return ["my_plugin_live_mode"]
+```
+
+## Troubleshooting
+
+### Plugin Not Loading
+
+- Check `manifest.json` syntax (must be valid JSON)
+- Verify `entry_point` file exists
+- Ensure `class_name` matches class name in manager.py
+- Check for import errors in logs
+
+### Configuration Errors
+
+- Validate config against `config_schema.json`
+- Check required fields are present
+- Verify data types match schema
+
+### Display Issues
+
+- Check display dimensions: `display_manager.width`, `display_manager.height`
+- Verify coordinates are within bounds
+- Ensure `update_display()` is called
+- Test with emulator first
+
+## Next Steps
+
+- Review existing plugins for patterns:
+  - `plugins/hockey-scoreboard/` - Sports scoreboard example
+  - `plugins/ledmatrix-music/` - Real-time data example
+  - `plugins/ledmatrix-stocks/` - Data display example
+
+- Read full documentation:
+  - `.cursor/plugins_guide.md` - Comprehensive guide
+  - `docs/PLUGIN_ARCHITECTURE_SPEC.md` - Architecture details
+  - `.cursorrules` - Development rules
+
+- Check plugin system code:
+  - `src/plugin_system/base_plugin.py` - Base class
+  - `src/plugin_system/plugin_manager.py` - Plugin manager
+

.cursor/plugin_templates/README.md.template

@@ -0,0 +1,156 @@
+# Plugin Name
+
+Brief description of what this plugin does.
+
+## Features
+
+- Feature 1
+- Feature 2
+- Feature 3
+
+## Installation
+
+1. Link the plugin to your LEDMatrix installation:
+
+```bash
+cd /path/to/LEDMatrix
+./scripts/dev/dev_plugin_setup.sh link-github PLUGIN_ID
+```
+
+Or for local development:
+
+```bash
+./scripts/dev/dev_plugin_setup.sh link PLUGIN_ID /path/to/plugin/repo
+```
+
+2. Install dependencies:
+
+```bash
+pip install -r plugins/PLUGIN_ID/requirements.txt
+```
+
+3. Configure the plugin in `config/config.json`:
+
+```json
+{
+  "PLUGIN_ID": {
+    "enabled": true,
+    "display_duration": 15
+  }
+}
+```
+
+**Note:** API keys and other sensitive credentials must be stored in `config/config_secrets.json`, not in `config/config.json`.
+
+4. Store API keys in `config/config_secrets.json`:
+
+```json
+{
+  "PLUGIN_ID": {
+    "api_key": "your-secret-api-key"
+  }
+}
+```
+
+## Configuration
+
+### Required Settings
+
+- `enabled` (boolean): Enable or disable the plugin
+- `api_key` (string): API key for external service (if required)
+
+### Optional Settings
+
+- `display_duration` (number): How long to display this plugin (default: 15 seconds)
+- `refresh_interval` (integer): How often to refresh data in seconds (default: 60)
+- `live_priority` (boolean): Enable live priority takeover (default: false)
+
+## Display Modes
+
+This plugin provides the following display modes:
+
+- `PLUGIN_ID`: Main display mode
+
+## API Requirements
+
+This plugin requires:
+
+- **API Name**: Description of API requirements
+  - URL: https://api.example.com
+  - Rate Limit: X requests per minute
+  - Authentication: API key required
+
+## Development
+
+### Running Tests
+
+```bash
+cd plugins/PLUGIN_ID
+python test_PLUGIN_ID.py
+```
+
+### Testing with Emulator
+
+```bash
+cd /path/to/LEDMatrix
+python run.py --emulator
+```
+
+### Debugging
+
+Enable debug logging in `config/config.json`:
+
+```json
+{
+  "logging": {
+    "level": "DEBUG"
+  }
+}
+```
+
+Check logs:
+
+```bash
+# On Raspberry Pi (if running as service)
+journalctl -u ledmatrix -f
+
+# Direct execution
+python run.py
+```
+
+## Troubleshooting
+
+### Plugin Not Loading
+
+1. Check that `manifest.json` exists and is valid
+2. Verify `entry_point` file exists
+3. Check that `class_name` matches the class in manager.py
+4. Review logs for import errors
+
+### Configuration Errors
+
+1. Validate config against `config_schema.json`
+2. Check required fields are present
+3. Verify data types match schema
+
+### API Errors
+
+1. Verify API key is correct
+2. Check API rate limits
+3. Review network connectivity
+4. Check API service status
+
+## License
+
+[License information]
+
+## Author
+
+Your Name
+
+## Links
+
+- GitHub: https://github.com/username/ledmatrix-PLUGIN_ID
+- Documentation: [Link to docs]
+- Issues: https://github.com/username/ledmatrix-PLUGIN_ID/issues
+

.cursor/plugin_templates/config_schema.json.template

@@ -0,0 +1,44 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "Plugin Configuration Schema",
+  "description": "Configuration schema for Plugin Name",
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "default": true,
+      "description": "Enable or disable this plugin"
+    },
+    "display_duration": {
+      "type": "number",
+      "default": 15,
+      "minimum": 1,
+      "maximum": 300,
+      "description": "How long to display this plugin in seconds"
+    },
+    "live_priority": {
+      "type": "boolean",
+      "default": false,
+      "description": "Enable live priority takeover when plugin has live content"
+    },
+    "refresh_interval": {
+      "type": "integer",
+      "default": 60,
+      "minimum": 1,
+      "description": "How often to refresh data in seconds"
+    },
+    "api_key": {
+      "type": "string",
+      "description": "API key for external service (store in config_secrets.json)",
+      "default": ""
+    },
+    "custom_setting": {
+      "type": "string",
+      "description": "Example custom setting - replace with your plugin's settings",
+      "default": "default_value"
+    }
+  },
+  "required": ["enabled"],
+  "additionalProperties": false
+}
+

.cursor/plugin_templates/manager.py.template

@@ -0,0 +1,226 @@
+"""
+Plugin Name
+
+Brief description of what this plugin does.
+
+API Version: 1.0.0
+"""
+
+from src.plugin_system.base_plugin import BasePlugin
+from PIL import Image
+from typing import Dict, Any, Optional
+import logging
+import time
+
+
+class PluginClassName(BasePlugin):
+    """
+    Plugin class that inherits from BasePlugin.
+    
+    This plugin demonstrates the basic structure and common patterns
+    for LEDMatrix plugins.
+    """
+    
+    def __init__(
+        self,
+        plugin_id: str,
+        config: Dict[str, Any],
+        display_manager,
+        cache_manager,
+        plugin_manager,
+    ):
+        """Initialize the plugin."""
+        super().__init__(plugin_id, config, display_manager, cache_manager, plugin_manager)
+        
+        # Initialize plugin-specific data
+        self.data = None
+        self.last_update_time = None
+        
+        # Load configuration values
+        self.api_key = config.get("api_key", "")
+        self.refresh_interval = config.get("refresh_interval", 60)
+        
+        self.logger.info(f"Plugin {plugin_id} initialized")
+    
+    def update(self) -> None:
+        """
+        Fetch/update data for this plugin.
+        
+        This method is called periodically based on update_interval
+        specified in the manifest. Use cache_manager to avoid
+        excessive API calls.
+        """
+        cache_key = f"{self.plugin_id}_data"
+        
+        # Check cache first
+        cached = self.cache_manager.get(cache_key, max_age=self.refresh_interval)
+        if cached:
+            self.data = cached
+            self.logger.debug("Using cached data")
+            return
+        
+        try:
+            # Fetch new data
+            self.data = self._fetch_data()
+            
+            # Cache the data
+            self.cache_manager.set(cache_key, self.data, ttl=self.refresh_interval)
+            self.last_update_time = time.time()
+            
+            self.logger.info("Data updated successfully")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to update data: {e}")
+            # Use cached data if available, even if expired
+            # Use a very large max_age (1 year) to effectively bypass expiration for fallback
+            expired_cached = self.cache_manager.get(cache_key, max_age=31536000)
+            if expired_cached:
+                self.data = expired_cached
+                self.logger.warning("Using expired cache due to update failure")
+    
+    def display(self, force_clear: bool = False) -> None:
+        """
+        Render this plugin's display.
+        
+        Args:
+            force_clear: If True, clear display before rendering
+        """
+        if force_clear:
+            self.display_manager.clear()
+        
+        # Check if we have data to display
+        if not self.data:
+            self._display_error("No data available")
+            return
+        
+        try:
+            # Render plugin content
+            self._render_content()
+            
+            # Update the display
+            self.display_manager.update_display()
+            
+        except Exception as e:
+            self.logger.error(f"Display error: {e}")
+            self._display_error("Display error")
+    
+    def _fetch_data(self) -> Dict[str, Any]:
+        """
+        Fetch data from external source.
+        
+        Returns:
+            Dictionary containing fetched data
+        """
+        # TODO: Implement data fetching logic
+        # Example:
+        # import requests
+        # response = requests.get("https://api.example.com/data", 
+        #                        headers={"Authorization": f"Bearer {self.api_key}"})
+        # return response.json()
+        
+        # Placeholder
+        return {
+            "message": "Hello, World!",
+            "timestamp": time.time()
+        }
+    
+    def _render_content(self) -> None:
+        """Render the plugin content on the display."""
+        # Get display dimensions
+        width = self.display_manager.width
+        height = self.display_manager.height
+        
+        # Example: Draw text
+        text = self.data.get("message", "No data")
+        x = 5
+        y = height // 2
+        
+        self.display_manager.draw_text(
+            text,
+            x=x,
+            y=y,
+            color=(255, 255, 255)  # White
+        )
+        
+        # Example: Draw image
+        # if hasattr(self, 'logo_image'):
+        #     self.display_manager.draw_image(
+        #         self.logo_image,
+        #         x=0,
+        #         y=0
+        #     )
+    
+    def _display_error(self, message: str) -> None:
+        """Display an error message."""
+        self.display_manager.clear()
+        width = self.display_manager.width
+        height = self.display_manager.height
+        
+        self.display_manager.draw_text(
+            message,
+            x=5,
+            y=height // 2,
+            color=(255, 0, 0)  # Red
+        )
+        self.display_manager.update_display()
+    
+    def validate_config(self) -> bool:
+        """
+        Validate plugin configuration.
+        
+        Returns:
+            True if config is valid, False otherwise
+        """
+        # Call parent validation first
+        if not super().validate_config():
+            return False
+        
+        # Add custom validation
+        # Example: Check for required API key
+        # if self.config.get("require_api_key", True):
+        #     if not self.api_key:
+        #         self.logger.error("API key is required but not provided")
+        #         return False
+        
+        return True
+    
+    def has_live_content(self) -> bool:
+        """
+        Check if plugin has live content to display.
+        
+        Override this method to enable live priority features.
+        
+        Returns:
+            True if plugin has live content, False otherwise
+        """
+        # Example: Check if there's live data
+        # return self.data and self.data.get("is_live", False)
+        return False
+    
+    def get_info(self) -> Dict[str, Any]:
+        """
+        Return plugin info for display in web UI.
+        
+        Returns:
+            Dictionary with plugin information
+        """
+        info = super().get_info()
+        
+        # Add plugin-specific info
+        info.update({
+            "data_available": self.data is not None,
+            "last_update": self.last_update_time,
+            # Add more info as needed
+        })
+        
+        return info
+    
+    def cleanup(self) -> None:
+        """Cleanup resources when plugin is unloaded."""
+        # Clean up any resources (threads, connections, etc.)
+        # Example:
+        # if hasattr(self, 'api_client'):
+        #     self.api_client.close()
+        
+        super().cleanup()
+

.cursor/plugin_templates/manifest.json.template

@@ -0,0 +1,55 @@
+{
+  "id": "PLUGIN_ID",
+  "name": "Plugin Name",
+  "version": "1.0.0",
+  "author": "Your Name",
+  "description": "Brief description of what this plugin does",
+  "homepage": "https://github.com/username/ledmatrix-PLUGIN_ID",
+  "entry_point": "manager.py",
+  "class_name": "PluginClassName",
+  "category": "custom",
+  "tags": ["custom", "example"],
+  "icon": "fas fa-icon-name",
+  "compatible_versions": [">=2.0.0"],
+  "min_ledmatrix_version": "2.0.0",
+  "max_ledmatrix_version": "3.0.0",
+  "requires": {
+    "python": ">=3.9",
+    "display_size": {
+      "min_width": 64,
+      "min_height": 32
+    }
+  },
+  "config_schema": "config_schema.json",
+  "assets": {
+    "logos": "Optional: Description of asset requirements"
+  },
+  "update_interval": 60,
+  "default_duration": 15,
+  "display_modes": [
+    "PLUGIN_ID"
+  ],
+  "api_requirements": [
+    {
+      "name": "API Name",
+      "required": false,
+      "description": "Description of API requirements",
+      "url": "https://api.example.com",
+      "rate_limit": "Rate limit information"
+    }
+  ],
+  "download_url_template": "https://github.com/username/ledmatrix-PLUGIN_ID/archive/refs/tags/v{version}.zip",
+  "versions": [
+    {
+      "released": "2025-01-01",
+      "version": "1.0.0",
+      "ledmatrix_min_version": "2.0.0"
+    }
+  ],
+  "last_updated": "2025-01-01",
+  "stars": 0,
+  "downloads": 0,
+  "verified": false,
+  "screenshot": ""
+}
+

.cursor/plugin_templates/requirements.txt.template

@@ -0,0 +1,13 @@
+# Plugin Dependencies
+# Add your plugin's Python dependencies here
+
+# Example dependencies (uncomment and modify as needed):
+# requests>=2.28.0
+# pillow>=9.0.0
+# python-dateutil>=2.8.0
+
+# Note: Core LEDMatrix dependencies are already available:
+# - PIL/Pillow (for image handling)
+# - Core plugin system classes
+# - Display manager, cache manager, config manager
+

.cursor/plugin_templates/test_manager.py.template

@@ -0,0 +1,136 @@
+"""
+Test file for Plugin Name plugin.
+
+This file provides example unit tests for your plugin.
+Run tests with: python -m pytest test_manager.py
+Or: python test_manager.py
+"""
+
+import unittest
+import sys
+from pathlib import Path
+
+# Add project root to path
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from src.plugin_system.testing import PluginTestCase
+from manager import PluginClassName
+
+
+class TestPluginClassName(PluginTestCase):
+    """Test cases for PluginClassName plugin."""
+    
+    def setUp(self):
+        """Set up test fixtures."""
+        super().setUp()
+        
+        # Update plugin_id to match the plugin being tested
+        self.plugin_id = 'PLUGIN_ID'
+        
+        # Create plugin instance
+        self.plugin = self.create_plugin_instance(
+            PluginClassName,
+            plugin_id='PLUGIN_ID',
+            config=self.get_mock_config()
+        )
+    
+    def test_plugin_initialization(self):
+        """Test that plugin initializes correctly."""
+        self.assert_plugin_initialized(self.plugin)
+        self.assertTrue(self.plugin.enabled)
+    
+    def test_config_validation(self):
+        """Test configuration validation."""
+        # Valid config should pass
+        self.assertTrue(self.plugin.validate_config())
+        
+        # Test with invalid config if applicable
+        # invalid_config = self.get_mock_config(enabled='not-a-boolean')
+        # invalid_plugin = self.create_plugin_instance(
+        #     PluginClassName,
+        #     config=invalid_config
+        # )
+        # self.assertFalse(invalid_plugin.validate_config())
+    
+    def test_update_method(self):
+        """Test the update() method."""
+        # Reset mocks
+        self.cache_manager.reset()
+        
+        # Call update
+        self.plugin.update()
+        
+        # Assertions
+        # Example: Check that cache was used
+        # self.assert_cache_get('PLUGIN_ID_data')
+        
+        # Example: Check that data was fetched and cached
+        # self.assert_cache_set('PLUGIN_ID_data')
+    
+    def test_display_method(self):
+        """Test the display() method."""
+        # Ensure plugin has data (call update first if needed)
+        # self.plugin.update()
+        
+        # Call display
+        self.plugin.display(force_clear=True)
+        
+        # Assertions
+        self.assert_display_cleared()
+        self.assert_display_updated()
+        
+        # Example: Check that text was drawn
+        # self.assert_text_drawn("Expected Text")
+        
+        # Example: Check that image was drawn
+        # self.assert_image_drawn()
+    
+    def test_display_without_data(self):
+        """Test display() behavior when no data is available."""
+        # Clear any cached data
+        self.cache_manager.reset()
+        
+        # Call display
+        self.plugin.display()
+        
+        # Should handle gracefully (no exceptions)
+        # May show error message or fallback content
+        self.assert_display_updated()
+    
+    def test_get_display_duration(self):
+        """Test display duration configuration."""
+        duration = self.plugin.get_display_duration()
+        self.assertIsInstance(duration, (int, float))
+        self.assertGreater(duration, 0)
+        
+        # Test with custom duration
+        custom_config = self.get_mock_config(display_duration=30.0)
+        custom_plugin = self.create_plugin_instance(
+            PluginClassName,
+            config=custom_config
+        )
+        self.assertEqual(custom_plugin.get_display_duration(), 30.0)
+    
+    def test_enable_disable(self):
+        """Test plugin enable/disable functionality."""
+        self.assertTrue(self.plugin.enabled)
+        
+        self.plugin.on_disable()
+        self.assertFalse(self.plugin.enabled)
+        
+        self.plugin.on_enable()
+        self.assertTrue(self.plugin.enabled)
+    
+    def test_config_change(self):
+        """Test configuration change handling."""
+        new_config = self.get_mock_config(display_duration=20.0)
+        self.plugin.on_config_change(new_config)
+        
+        self.assertEqual(self.plugin.config.get('display_duration'), 20.0)
+
+
+if __name__ == '__main__':
+    unittest.main()
+

.cursor/plugins_guide.md

@@ -0,0 +1,751 @@
+# LEDMatrix Plugin Development Guide
+
+This guide provides comprehensive instructions for creating, running, and loading plugins in the LEDMatrix project.
+
+## Table of Contents
+
+1. [Plugin System Overview](#plugin-system-overview)
+2. [Creating a New Plugin](#creating-a-new-plugin)
+3. [Running Plugins](#running-plugins)
+4. [Loading Plugins](#loading-plugins)
+5. [Plugin Development Workflow](#plugin-development-workflow)
+6. [Testing Plugins](#testing-plugins)
+7. [Troubleshooting](#troubleshooting)
+
+---
+
+## Plugin System Overview
+
+The LEDMatrix project uses a plugin-based architecture where all display functionality (except core calendar) is implemented as plugins. Plugins are dynamically loaded from the `plugins/` directory and integrated into the display rotation.
+
+### Plugin Architecture
+
+```
+LEDMatrix Core
+├── Plugin Manager (discovers, loads, manages plugins)
+├── Display Manager (handles LED matrix rendering)
+├── Cache Manager (data persistence)
+├── Config Manager (configuration management)
+└── Plugins/ (plugin directory)
+    ├── plugin-1/
+    ├── plugin-2/
+    └── ...
+```
+
+### Plugin Lifecycle
+
+1. **Discovery**: PluginManager scans `plugins/` for directories with `manifest.json`
+2. **Loading**: Plugin module is imported and class is instantiated
+3. **Configuration**: Plugin config is loaded from `config/config.json`
+4. **Validation**: `validate_config()` is called to verify configuration
+5. **Registration**: Plugin is added to available display modes
+6. **Execution**: `update()` is called periodically, `display()` is called during rotation
+
+---
+
+## Creating a New Plugin
+
+### Method 1: Using dev_plugin_setup.sh (Recommended)
+
+This method is best for plugins stored in separate Git repositories.
+
+#### From GitHub Repository
+
+```bash
+# Link a plugin from GitHub (auto-detects URL)
+./scripts/dev/dev_plugin_setup.sh link-github <plugin-name>
+
+# Example: Link hockey-scoreboard plugin
+./scripts/dev/dev_plugin_setup.sh link-github hockey-scoreboard
+
+# With custom URL
+./scripts/dev/dev_plugin_setup.sh link-github <plugin-name> https://github.com/user/repo.git
+```
+
+The script will:
+- Clone the repository to `~/.ledmatrix-dev-plugins/` (or configured directory)
+- Create a symlink in `plugins/<plugin-name>/` pointing to the cloned repo
+- Validate the plugin structure
+
+#### From Local Repository
+
+```bash
+# Link a local plugin repository
+./scripts/dev/dev_plugin_setup.sh link <plugin-name> <path-to-repo>
+
+# Example: Link a local plugin
+./scripts/dev/dev_plugin_setup.sh link my-plugin ../ledmatrix-my-plugin
+```
+
+### Method 2: Manual Plugin Creation
+
+1. **Create Plugin Directory**
+
+```bash
+mkdir -p plugins/my-plugin
+cd plugins/my-plugin
+```
+
+2. **Create manifest.json**
+
+```json
+{
+  "id": "my-plugin",
+  "name": "My Plugin",
+  "version": "1.0.0",
+  "author": "Your Name",
+  "description": "Description of what this plugin does",
+  "entry_point": "manager.py",
+  "class_name": "MyPlugin",
+  "category": "custom",
+  "tags": ["custom", "example"],
+  "display_modes": ["my_plugin"],
+  "update_interval": 60,
+  "default_duration": 15,
+  "requires": {
+    "python": ">=3.9"
+  },
+  "config_schema": "config_schema.json"
+}
+```
+
+3. **Create manager.py**
+
+```python
+from src.plugin_system.base_plugin import BasePlugin
+from PIL import Image
+import logging
+
+class MyPlugin(BasePlugin):
+    """My custom plugin implementation."""
+    
+    def update(self):
+        """Fetch/update data for this plugin."""
+        # Fetch data from API, files, etc.
+        # Use self.cache_manager for caching
+        cache_key = f"{self.plugin_id}_data"
+        cached = self.cache_manager.get(cache_key, max_age=3600)
+        if cached:
+            self.data = cached
+            return
+        
+        # Fetch new data
+        self.data = self._fetch_data()
+        self.cache_manager.set(cache_key, self.data)
+    
+    def display(self, force_clear=False):
+        """Render this plugin's display."""
+        if force_clear:
+            self.display_manager.clear()
+        
+        # Render content using display_manager
+        self.display_manager.draw_text(
+            "Hello, World!",
+            x=10, y=15,
+            color=(255, 255, 255)
+        )
+        
+        self.display_manager.update_display()
+    
+    def _fetch_data(self):
+        """Fetch data from external source."""
+        # Implement your data fetching logic
+        return {"message": "Hello, World!"}
+    
+    def validate_config(self):
+        """Validate plugin configuration."""
+        # Check required config fields
+        if not super().validate_config():
+            return False
+        
+        # Add custom validation
+        required_fields = ['api_key']  # Example
+        for field in required_fields:
+            if field not in self.config:
+                self.logger.error(f"Missing required field: {field}")
+                return False
+        
+        return True
+```
+
+4. **Create config_schema.json**
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "default": true,
+      "description": "Enable or disable this plugin"
+    },
+    "display_duration": {
+      "type": "number",
+      "default": 15,
+      "minimum": 1,
+      "description": "How long to display this plugin (seconds)"
+    },
+    "api_key": {
+      "type": "string",
+      "description": "API key for external service"
+    }
+  },
+  "required": ["enabled"]
+}
+```
+
+5. **Create requirements.txt** (if needed)
+
+```
+requests>=2.28.0
+pillow>=9.0.0
+```
+
+6. **Create README.md**
+
+Document your plugin's functionality, configuration options, and usage.
+
+---
+
+## Running Plugins
+
+### Development Mode (Emulator)
+
+Run the LEDMatrix system with emulator for plugin testing:
+
+```bash
+# Using run.py
+python run.py --emulator
+
+# Using emulator script
+./run_emulator.sh
+```
+
+The emulator will:
+- Load all enabled plugins
+- Display plugin content in a window (simulating LED matrix)
+- Show logs for plugin loading and execution
+- Allow testing without Raspberry Pi hardware
+
+### Production Mode (Raspberry Pi)
+
+Run on actual Raspberry Pi hardware:
+
+```bash
+# Direct execution
+python run.py
+
+# As systemd service
+sudo systemctl start ledmatrix
+sudo systemctl status ledmatrix
+sudo journalctl -u ledmatrix -f  # View logs
+```
+
+### Plugin-Specific Testing
+
+Test individual plugin loading:
+
+```python
+# test_my_plugin.py
+from src.plugin_system.plugin_manager import PluginManager
+from src.config_manager import ConfigManager
+from src.display_manager import DisplayManager
+from src.cache_manager import CacheManager
+
+# Initialize managers
+config_manager = ConfigManager()
+config = config_manager.load_config()
+display_manager = DisplayManager(config)
+cache_manager = CacheManager()
+
+# Initialize plugin manager
+plugin_manager = PluginManager(
+    plugins_dir="plugins",
+    config_manager=config_manager,
+    display_manager=display_manager,
+    cache_manager=cache_manager
+)
+
+# Discover and load plugin
+plugins = plugin_manager.discover_plugins()
+print(f"Discovered plugins: {plugins}")
+
+if "my-plugin" in plugins:
+    if plugin_manager.load_plugin("my-plugin"):
+        plugin = plugin_manager.get_plugin("my-plugin")
+        plugin.update()
+        plugin.display()
+        print("Plugin loaded and displayed successfully!")
+    else:
+        print("Failed to load plugin")
+```
+
+---
+
+## Loading Plugins
+
+### Enabling Plugins
+
+Plugins are enabled/disabled in `config/config.json`:
+
+```json
+{
+  "my-plugin": {
+    "enabled": true,
+    "display_duration": 15,
+    "api_key": "your-api-key-here"
+  }
+}
+```
+
+### Plugin Configuration Structure
+
+Each plugin has its own section in `config/config.json`:
+
+```json
+{
+  "<plugin-id>": {
+    "enabled": true,                    // Enable/disable plugin
+    "display_duration": 15,             // Display duration in seconds
+    "live_priority": false,             // Enable live priority takeover
+    "high_performance_transitions": false, // Use 120 FPS transitions
+    "transition": {                     // Transition configuration
+      "type": "redraw",                 // Transition type
+      "speed": 2,                       // Transition speed
+      "enabled": true                   // Enable transitions
+    },
+    // ... plugin-specific configuration
+  }
+}
+```
+
+### Secrets Management
+
+Store sensitive data (API keys, tokens) in `config/config_secrets.json`
+under the same plugin id you use in `config/config.json`:
+
+```json
+{
+  "my-plugin": {
+    "api_key": "secret-api-key-here"
+  }
+}
+```
+
+At load time, the config manager deep-merges `config_secrets.json` into
+the main config (verified at `src/config_manager.py:162-172`). So in
+your plugin's code:
+
+```python
+class MyPlugin(BasePlugin):
+    def __init__(self, plugin_id, config, display_manager, cache_manager, plugin_manager):
+        super().__init__(plugin_id, config, display_manager, cache_manager, plugin_manager)
+        self.api_key = config.get("api_key")  # already merged from secrets
+```
+
+There is no separate `config_secrets` reference field — just put the
+secret value under the same plugin namespace and read it from the
+merged config.
+
+### Plugin Discovery
+
+Plugins are automatically discovered when:
+- Directory exists in `plugins/`
+- Directory contains `manifest.json`
+- Manifest has required fields (`id`, `entry_point`, `class_name`)
+
+Check discovered plugins:
+
+```bash
+# Using dev_plugin_setup.sh
+./scripts/dev/dev_plugin_setup.sh list
+
+# Output shows:
+# ✓ plugin-name (symlink)
+#   → /path/to/repo
+#   ✓ Git repo is clean (branch: main)
+```
+
+### Plugin Status
+
+Check plugin status and git information:
+
+```bash
+./scripts/dev/dev_plugin_setup.sh status
+
+# Output shows:
+# ✓ plugin-name
+#   Path: /path/to/repo
+#   Branch: main
+#   Remote: https://github.com/user/repo.git
+#   Status: Clean and up to date
+```
+
+---
+
+## Plugin Development Workflow
+
+### 1. Initial Setup
+
+```bash
+# Create or clone plugin repository
+git clone https://github.com/user/ledmatrix-my-plugin.git
+cd ledmatrix-my-plugin
+
+# Link to LEDMatrix project
+cd /path/to/LEDMatrix
+./scripts/dev/dev_plugin_setup.sh link my-plugin ../ledmatrix-my-plugin
+```
+
+### 2. Development Cycle
+
+1. **Edit plugin code** in linked repository
+2. **Test with the dev preview server**:
+   `python3 scripts/dev_server.py` (then open `http://localhost:5001`).
+   Or run the full display in emulator mode with
+   `python3 run.py --emulator` (or equivalently
+   `EMULATOR=true python3 run.py`). The `-e`/`--emulator` CLI flag is
+   defined in `run.py:19-20` and sets the same `EMULATOR` environment
+   variable internally.
+3. **Check logs** for errors or warnings
+4. **Update configuration** in `config/config.json` if needed
+5. **Iterate** until plugin works correctly
+
+### 3. Testing on Hardware
+
+```bash
+# Deploy to Raspberry Pi
+rsync -avz plugins/my-plugin/ ledpi@your-pi-ip:/path/to/LEDMatrix/plugins/my-plugin/
+
+# Or if using git, pull on Pi
+ssh ledpi@your-pi-ip "cd /path/to/LEDMatrix/plugins/my-plugin && git pull"
+
+# Restart service
+ssh ledpi@your-pi-ip "sudo systemctl restart ledmatrix"
+```
+
+### 4. Updating Plugins
+
+```bash
+# Update single plugin from git
+./scripts/dev/dev_plugin_setup.sh update my-plugin
+
+# Update all linked plugins
+./scripts/dev/dev_plugin_setup.sh update
+```
+
+### 5. Unlinking Plugins
+
+```bash
+# Remove symlink (preserves repository)
+./scripts/dev/dev_plugin_setup.sh unlink my-plugin
+```
+
+---
+
+## Testing Plugins
+
+### Unit Testing
+
+Create test files in plugin directory:
+
+```python
+# plugins/my-plugin/test_my_plugin.py
+import unittest
+from unittest.mock import Mock, MagicMock
+from manager import MyPlugin
+
+class TestMyPlugin(unittest.TestCase):
+    def setUp(self):
+        self.config = {"enabled": True}
+        self.display_manager = Mock()
+        self.cache_manager = Mock()
+        self.plugin_manager = Mock()
+        
+        self.plugin = MyPlugin(
+            plugin_id="my-plugin",
+            config=self.config,
+            display_manager=self.display_manager,
+            cache_manager=self.cache_manager,
+            plugin_manager=self.plugin_manager
+        )
+    
+    def test_plugin_initialization(self):
+        self.assertEqual(self.plugin.plugin_id, "my-plugin")
+        self.assertTrue(self.plugin.enabled)
+    
+    def test_config_validation(self):
+        self.assertTrue(self.plugin.validate_config())
+    
+    def test_update(self):
+        self.cache_manager.get.return_value = None
+        self.plugin.update()
+        # Assert data was fetched and cached
+    
+    def test_display(self):
+        self.plugin.display()
+        self.display_manager.draw_text.assert_called()
+        self.display_manager.update_display.assert_called()
+
+if __name__ == '__main__':
+    unittest.main()
+```
+
+Run tests:
+
+```bash
+cd plugins/my-plugin
+python -m pytest test_my_plugin.py
+# or
+python test_my_plugin.py
+```
+
+### Integration Testing
+
+Test plugin with actual managers:
+
+```python
+# test_plugin_integration.py
+from src.plugin_system.plugin_manager import PluginManager
+from src.config_manager import ConfigManager
+from src.display_manager import DisplayManager
+from src.cache_manager import CacheManager
+
+def test_plugin_loading():
+    config_manager = ConfigManager()
+    config = config_manager.load_config()
+    display_manager = DisplayManager(config)
+    cache_manager = CacheManager()
+    
+    plugin_manager = PluginManager(
+        plugins_dir="plugins",
+        config_manager=config_manager,
+        display_manager=display_manager,
+        cache_manager=cache_manager
+    )
+    
+    plugins = plugin_manager.discover_plugins()
+    assert "my-plugin" in plugins
+    
+    assert plugin_manager.load_plugin("my-plugin")
+    plugin = plugin_manager.get_plugin("my-plugin")
+    assert plugin is not None
+    assert plugin.enabled
+    
+    plugin.update()
+    plugin.display()
+```
+
+### Emulator Testing
+
+Test plugin rendering visually:
+
+```bash
+# Run with emulator
+python run.py --emulator
+
+# Plugin should appear in display rotation
+# Check logs for plugin loading and execution
+```
+
+### Hardware Testing
+
+1. Deploy plugin to Raspberry Pi
+2. Enable in `config/config.json`
+3. Restart LEDMatrix service
+4. Observe LED matrix display
+5. Check logs: `journalctl -u ledmatrix -f`
+
+---
+
+## Troubleshooting
+
+### Plugin Not Loading
+
+**Symptoms**: Plugin doesn't appear in available modes, no logs about plugin
+
+**Solutions**:
+1. Check plugin directory exists: `ls plugins/my-plugin/`
+2. Verify `manifest.json` exists and is valid JSON
+3. Check manifest has required fields: `id`, `entry_point`, `class_name`
+4. Verify entry_point file exists: `ls plugins/my-plugin/manager.py`
+5. Check class name matches: `grep "class.*Plugin" plugins/my-plugin/manager.py`
+6. Review logs for import errors
+
+### Plugin Loading but Not Displaying
+
+**Symptoms**: Plugin loads successfully but doesn't appear in rotation
+
+**Solutions**:
+1. Check plugin is enabled: `config/config.json` has `"enabled": true`
+2. Verify display_modes in manifest match config
+3. Check plugin is in rotation schedule
+4. Review `display()` method for errors
+5. Check logs for runtime errors
+
+### Configuration Errors
+
+**Symptoms**: Plugin fails to load, validation errors in logs
+
+**Solutions**:
+1. Validate config against `config_schema.json`
+2. Check required fields are present
+3. Verify data types match schema
+4. Check for typos in config keys
+5. Review `validate_config()` method
+
+### Import Errors
+
+**Symptoms**: ModuleNotFoundError or ImportError in logs
+
+**Solutions**:
+1. Install plugin dependencies: `pip install -r plugins/my-plugin/requirements.txt`
+2. Check Python path includes plugin directory
+3. Verify relative imports are correct
+4. Check for circular import issues
+5. Ensure all dependencies are in requirements.txt
+
+### Display Issues
+
+**Symptoms**: Plugin renders incorrectly or not at all
+
+**Solutions**:
+1. Check display dimensions: `display_manager.width`, `display_manager.height`
+2. Verify coordinates are within display bounds
+3. Check color values are valid (0-255)
+4. Ensure `update_display()` is called after rendering
+5. Test with emulator first to debug rendering
+
+### Performance Issues
+
+**Symptoms**: Slow display updates, high CPU usage
+
+**Solutions**:
+1. Use `cache_manager` to avoid excessive API calls
+2. Implement background data fetching
+3. Optimize rendering code
+4. Consider using `high_performance_transitions`
+5. Profile plugin code to identify bottlenecks
+
+### Git/Symlink Issues
+
+**Symptoms**: Plugin changes not appearing, broken symlinks
+
+**Solutions**:
+1. Check symlink: `ls -la plugins/my-plugin`
+2. Verify target exists: `readlink -f plugins/my-plugin`
+3. Update plugin: `./scripts/dev/dev_plugin_setup.sh update my-plugin`
+4. Re-link plugin if needed: `./scripts/dev/dev_plugin_setup.sh unlink my-plugin && ./scripts/dev/dev_plugin_setup.sh link my-plugin <path>`
+5. Check git status: `cd plugins/my-plugin && git status`
+
+---
+
+## Best Practices
+
+### Code Organization
+
+- Keep plugin code in `plugins/<plugin-id>/` directory
+- Use descriptive class and method names
+- Follow existing plugin patterns
+- Place shared utilities in `src/common/` if reusable
+
+### Configuration
+
+- Always use `config_schema.json` for validation
+- Store secrets in `config_secrets.json`
+- Provide sensible defaults
+- Document all configuration options in README
+
+### Error Handling
+
+- Use plugin logger for all logging
+- Handle API failures gracefully
+- Provide fallback displays when data unavailable
+- Cache data to avoid excessive requests
+
+### Performance
+
+- Cache API responses appropriately
+- Use background data fetching for long operations
+- Optimize rendering for Pi's limited resources
+- Test performance on actual hardware
+
+### Testing
+
+- Write unit tests for core logic
+- Test with emulator before hardware
+- Test on Raspberry Pi before deploying
+- Test with other plugins enabled
+
+### Documentation
+
+- Document plugin functionality in README
+- Include configuration examples
+- Document API requirements and rate limits
+- Provide usage examples
+
+---
+
+## Resources
+
+- **Plugin System Documentation**: `docs/PLUGIN_ARCHITECTURE_SPEC.md`
+- **Base Plugin Class**: `src/plugin_system/base_plugin.py`
+- **Plugin Manager**: `src/plugin_system/plugin_manager.py`
+- **Example Plugins**: 
+  - `plugins/hockey-scoreboard/` - Sports scoreboard example
+  - `plugins/football-scoreboard/` - Complex multi-league example
+  - `plugins/ledmatrix-music/` - Real-time data example
+- **Development Setup**: `dev_plugin_setup.sh`
+- **Example Config**: `dev_plugins.json.example`
+
+---
+
+## Quick Reference
+
+### Common Commands
+
+```bash
+# Link plugin from GitHub
+./scripts/dev/dev_plugin_setup.sh link-github <name>
+
+# Link local plugin
+./scripts/dev/dev_plugin_setup.sh link <name> <path>
+
+# List all plugins
+./scripts/dev/dev_plugin_setup.sh list
+
+# Check plugin status
+./scripts/dev/dev_plugin_setup.sh status
+
+# Update plugin(s)
+./scripts/dev/dev_plugin_setup.sh update [name]
+
+# Unlink plugin
+./scripts/dev/dev_plugin_setup.sh unlink <name>
+
+# Run with emulator
+python run.py --emulator
+
+# Run on Pi
+python run.py
+```
+
+### Plugin File Structure
+
+```
+plugins/my-plugin/
+├── manifest.json          # Required: Plugin metadata
+├── manager.py             # Required: Plugin class
+├── config_schema.json     # Required: Config validation
+├── requirements.txt       # Optional: Dependencies
+├── README.md              # Optional: Documentation
+└── ...                    # Plugin-specific files
+```
+
+### Required Manifest Fields
+
+- `id`: Plugin identifier
+- `entry_point`: Python file (usually "manager.py")
+- `class_name`: Plugin class name
+- `display_modes`: Array of mode names
+

.cursor/rules/coding-standards.mdc

@@ -0,0 +1,38 @@
+---
+globs: *.py
+---
+
+# Python Coding Standards
+
+## Code Quality Principles
+- **Simplicity First**: Prefer clear, readable code over clever optimizations
+- **Explicit over Implicit**: Make intentions clear through naming and structure
+- **Fail Fast**: Validate inputs and handle errors early
+- **Documentation**: Use docstrings for classes and complex functions
+
+## Naming Conventions
+- **Classes**: PascalCase (e.g., `NHLRecentManager`)
+- **Functions/Variables**: snake_case (e.g., `fetch_game_data`)
+- **Constants**: UPPER_SNAKE_CASE (e.g., `ESPN_NHL_SCOREBOARD_URL`)
+- **Private methods**: Leading underscore (e.g., `_fetch_data`)
+
+## Error Handling
+- **Logging**: Use structured logging with context (e.g., `[NHL Recent]`)
+- **Exceptions**: Catch specific exceptions, not bare `except:`
+- **User-friendly messages**: Explain what went wrong and potential solutions
+- **Graceful degradation**: Continue operation when non-critical features fail
+
+## Manager Pattern
+All sports managers should follow this structure:
+```python
+class BaseManager:
+    def __init__(self, config, display_manager, cache_manager)
+    def update(self)  # Fetch and process data
+    def display(self, force_clear=False)  # Render to display
+```
+
+## Configuration Management
+- **Type hints**: Use for function parameters and return values
+- **Configuration validation**: Check required fields on initialization
+- **Default values**: Provide sensible defaults in code, not config
+- **Environment awareness**: Handle different deployment contexts

.cursor/rules/configuration-management.mdc

@@ -0,0 +1,42 @@
+---
+globs: config/*.json,src/*.py
+---
+
+# Configuration Management
+
+## Configuration Structure
+- **Main config**: [config/config.json](mdc:config/config.json) - Primary configuration
+- **Secrets**: [config/config_secrets.json](mdc:config/config_secrets.json) - API keys and sensitive data
+- **Templates**: [config/config.template.json](mdc:config/config.template.json) - Default values
+
+## Configuration Principles
+- **Validation**: Check required fields and data types on startup
+- **Defaults**: Provide sensible defaults in code, not just config
+- **Environment awareness**: Handle development vs production differences
+- **Security**: Never commit secrets to version control
+
+## Manager Configuration Pattern
+```python
+def __init__(self, config, display_manager, cache_manager):
+    self.mode_config = config.get("sport_scoreboard", {})
+    self.favorite_teams = self.mode_config.get("favorite_teams", [])
+    self.show_favorite_only = self.mode_config.get("show_favorite_teams_only", False)
+```
+
+## Required Configuration Sections
+- **Display settings**: Update intervals, display durations
+- **API settings**: Timeouts, retry logic, rate limiting
+- **Background service**: Threading, caching, priority settings
+- **Team preferences**: Favorite teams, filtering options
+
+## Configuration Validation
+- **Type checking**: Ensure numeric values are numbers, lists are lists
+- **Range validation**: Check that intervals are reasonable
+- **Dependency checking**: Verify required services are available
+- **Fallback values**: Provide defaults when config is missing or invalid
+
+## Best Practices
+- **Documentation**: Comment complex configuration options
+- **Examples**: Provide working examples in templates
+- **Migration**: Handle configuration changes between versions
+- **Testing**: Validate configuration in test environments

.cursor/rules/error-handling-logging.mdc

@@ -0,0 +1,50 @@
+---
+globs: src/*.py
+---
+
+# Error Handling and Logging
+
+## Logging Standards
+- **Structured prefixes**: Use consistent tags like `[NHL Recent]`, `[NFL Live]`
+- **Context information**: Include relevant details (team names, game status, dates)
+- **Appropriate levels**: 
+  - `info`: Normal operations and status updates
+  - `debug`: Detailed information for troubleshooting
+  - `warning`: Non-critical issues that should be noted
+  - `error`: Problems that need attention
+
+## Error Handling Patterns
+```python
+try:
+    data = self._fetch_data()
+    if not data or 'events' not in data:
+        self.logger.warning("[Manager] No events found in API response")
+        return
+except requests.exceptions.RequestException as e:
+    self.logger.error(f"[Manager] API error: {e}")
+    return None
+```
+
+## User-Friendly Messages
+- **Explain the situation**: "No games available during off-season"
+- **Provide context**: "NHL season typically runs October-June"
+- **Suggest solutions**: "Check back when season starts"
+- **Distinguish issues**: API problems vs no data vs filtering results
+
+## Graceful Degradation
+- **Fallback content**: Show alternative games when favorites unavailable
+- **Cached data**: Use cached data when API fails
+- **Service continuity**: Continue operation when non-critical features fail
+- **Clear communication**: Explain what's happening to users
+
+## Debugging Support
+- **Comprehensive logging**: Log API responses, filtering results, display updates
+- **State tracking**: Log current state and transitions
+- **Performance monitoring**: Track timing and resource usage
+- **Error context**: Include stack traces for debugging
+
+## Off-Season Awareness
+- **Seasonal messaging**: Different messages for different times of year
+- **Helpful context**: Explain why no games are available
+- **Future planning**: Mention when season starts
+- **Realistic expectations**: Set appropriate expectations during off-season

.cursor/rules/git-workflow.mdc

@@ -0,0 +1,51 @@
+---
+alwaysApply: true
+---
+
+# Git Workflow and Branching
+
+## Branch Naming Conventions
+- **Features**: `feature/description-of-feature` (e.g., `feature/weather-forecast-improvements`)
+- **Bug fixes**: `fix/description-of-bug` (e.g., `fix/nhl-manager-improvements`)
+- **Hotfixes**: `hotfix/critical-issue-description`
+- **Refactoring**: `refactor/description-of-refactor`
+
+## Commit Message Format
+```
+type(scope): description
+
+[optional body]
+
+[optional footer]
+```
+
+**Types**: feat, fix, docs, style, refactor, test, chore
+**Examples**:
+- `feat(nhl): Add enhanced logging for data visibility`
+- `fix(display): Resolve rendering performance issue`
+- `docs(api): Update ESPN API integration guide`
+
+## Pull Request Guidelines
+- **Self-review**: Review your own PR before requesting review
+- **Testing**: Test thoroughly on Raspberry Pi hardware
+- **Documentation**: Update relevant documentation if needed
+- **Clean history**: Squash commits if necessary for clean history
+
+## Code Review Checklist
+- **Code Quality**: Proper error handling, logging, type hints
+- **Architecture**: Follows project patterns, doesn't break existing functionality
+- **Performance**: No negative impact on display performance
+- **Testing**: Works on Raspberry Pi hardware
+- **Documentation**: Comments added for complex logic
+
+## Merge Strategies
+- **Squash and Merge**: Preferred for feature branches and bug fixes
+- **Merge Commit**: For complex features with multiple logical commits
+- **Rebase and Merge**: For simple, single-commit changes
+
+## Best Practices
+- **Keep branches small and focused**
+- **Commit frequently with meaningful messages**
+- **Update branch regularly with main**
+- **Test changes incrementally**
+- **Delete feature branches after merge**

.cursor/rules/github-branches-rule.mdc

@@ -0,0 +1,213 @@
+---
+description: GitHub branching and pull request best practices for LEDMatrix project
+globs: ["**/*.py", "**/*.md", "**/*.json", "**/*.sh"]
+alwaysApply: true
+---
+
+# GitHub Branching and Pull Request Guidelines
+
+## Branch Naming Conventions
+
+### Feature Branches
+- **Format**: `feature/description-of-feature`
+- **Examples**: 
+  - `feature/weather-forecast-improvements`
+  - `feature/stock-api-integration`
+  - `feature/nba-live-scores`
+
+### Bug Fix Branches
+- **Format**: `fix/description-of-bug`
+- **Examples**:
+  - `fix/leaderboard-scrolling-performance`
+  - `fix/weather-api-timeout`
+  - `fix/display-rendering-issue`
+
+### Hotfix Branches
+- **Format**: `hotfix/critical-issue-description`
+- **Examples**:
+  - `hotfix/display-crash-fix`
+  - `hotfix/api-rate-limit-fix`
+
+### Refactoring Branches
+- **Format**: `refactor/description-of-refactor`
+- **Examples**:
+  - `refactor/sports-manager-architecture`
+  - `refactor/cache-management-system`
+
+## Branch Management Rules
+
+### Main Branch Protection
+- **`main`** branch is protected and requires PR reviews
+- Never commit directly to `main`
+- All changes must go through pull requests
+
+### Branch Lifecycle
+1. **Create** branch from `main` when starting work
+2. **Keep** branch up-to-date with `main` regularly
+3. **Test** thoroughly before creating PR
+4. **Delete** branch after successful merge
+
+### Branch Updates
+```bash
+# Before starting new work
+git checkout main
+git pull origin main
+
+# Create new branch
+git checkout -b feature/your-feature-name
+
+# Keep branch updated during development
+git checkout main
+git pull origin main
+git checkout feature/your-feature-name
+git merge main
+```
+
+## Pull Request Guidelines
+
+### PR Title Format
+- **Feature**: `feat: Add weather forecast improvements`
+- **Fix**: `fix: Resolve leaderboard scrolling performance issue`
+- **Refactor**: `refactor: Improve sports manager architecture`
+- **Docs**: `docs: Update API integration guide`
+- **Test**: `test: Add unit tests for weather manager`
+
+### PR Description Template
+```markdown
+## Description
+Brief description of changes and motivation.
+
+## Type of Change
+- [ ] Bug fix (non-breaking change)
+- [ ] New feature (non-breaking change)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] Documentation update
+- [ ] Performance improvement
+- [ ] Refactoring
+
+## Testing
+- [ ] Tested on Raspberry Pi hardware
+- [ ] Verified display rendering works correctly
+- [ ] Checked API integration functionality
+- [ ] Tested error handling scenarios
+
+## Screenshots/Videos
+(If applicable, add screenshots or videos of the changes)
+
+## Checklist
+- [ ] Code follows project style guidelines
+- [ ] Self-review completed
+- [ ] Comments added for complex logic
+- [ ] No hardcoded values or API keys
+- [ ] Error handling implemented
+- [ ] Logging added where appropriate
+```
+
+### PR Review Requirements
+
+#### For Reviewers
+- **Code Quality**: Check for proper error handling, logging, and type hints
+- **Architecture**: Ensure changes follow project patterns and don't break existing functionality
+- **Performance**: Verify changes don't negatively impact display performance
+- **Testing**: Confirm changes work on Raspberry Pi hardware
+- **Documentation**: Check if documentation needs updates
+
+#### For Authors
+- **Self-Review**: Review your own PR before requesting review
+- **Testing**: Test thoroughly on Pi hardware before submitting
+- **Documentation**: Update relevant documentation if needed
+- **Clean History**: Squash commits if necessary for clean history
+
+## Commit Message Guidelines
+
+### Format
+```
+type(scope): description
+
+[optional body]
+
+[optional footer]
+```
+
+### Types
+- **feat**: New feature
+- **fix**: Bug fix
+- **docs**: Documentation changes
+- **style**: Code style changes (formatting, etc.)
+- **refactor**: Code refactoring
+- **test**: Adding or updating tests
+- **chore**: Maintenance tasks
+
+### Examples
+```
+feat(weather): Add hourly forecast display
+fix(nba): Resolve live score update issue
+docs(api): Update ESPN API integration guide
+refactor(sports): Improve base class architecture
+```
+
+## Merge Strategies
+
+### Squash and Merge (Preferred)
+- Use for feature branches and bug fixes
+- Creates clean, linear history
+- Combines all commits into single commit
+
+### Merge Commit
+- Use for complex features with multiple logical commits
+- Preserves commit history
+- Use when commit messages are meaningful
+
+### Rebase and Merge
+- Use sparingly for simple, single-commit changes
+- Creates linear history without merge commits
+
+## Release Management
+
+### Version Tags
+- Use semantic versioning: `v1.2.3`
+- Tag releases on `main` branch
+- Create release notes with technical details
+
+### Release Branches
+- **Format**: `release/v1.2.3`
+- Use for release preparation
+- Include version bumps and final testing
+
+## Emergency Procedures
+
+### Hotfix Process
+1. Create `hotfix/` branch from `main`
+2. Make minimal fix
+3. Test thoroughly
+4. Create PR with expedited review
+5. Merge to `main` and tag release
+6. Cherry-pick to other branches if needed
+
+### Rollback Process
+1. Identify last known good commit
+2. Create revert PR if possible
+3. Use `git revert` for clean rollback
+4. Tag rollback release
+5. Document issue and resolution
+
+## Best Practices
+
+### Before Creating PR
+- [ ] Run all tests locally
+- [ ] Test on Raspberry Pi hardware
+- [ ] Check for linting errors
+- [ ] Update documentation if needed
+- [ ] Ensure commit messages are clear
+
+### During Development
+- [ ] Keep branches small and focused
+- [ ] Commit frequently with meaningful messages
+- [ ] Update branch regularly with main
+- [ ] Test changes incrementally
+
+### After PR Approval
+- [ ] Delete feature branch after merge
+- [ ] Update local main branch
+- [ ] Verify changes work in production
+- [ ] Update any related documentation

.cursor/rules/project-structure.mdc

@@ -0,0 +1,23 @@
+---
+alwaysApply: true
+---
+
+# LEDMatrix Project Structure
+
+## Core Architecture
+- **Main entry point**: [run.py](mdc:run.py) - Primary application launcher
+- **Configuration**: [config/config.json](mdc:config/config.json) - Main configuration file
+- **Display management**: [src/display_controller.py](mdc:src/display_controller.py) - Core display logic
+- **Web interface**: [web_interface_v2.py](mdc:web_interface_v2.py) - Modern web UI
+
+## Source Code Organization
+- **Managers**: [src/](mdc:src/) - All sports/weather/stock managers
+- **Assets**: [assets/](mdc:assets/) - Logos, fonts, and static resources
+- **Tests**: [test/](mdc:test/) - Unit and integration tests
+- **Documentation**: [LEDMatrix.wiki/](mdc:LEDMatrix.wiki/) - Comprehensive guides
+
+## Key Design Principles
+- **Single Responsibility**: Each manager handles one sport/domain
+- **Consistent Patterns**: All managers follow similar structure
+- **Configuration-Driven**: Behavior controlled via [config/config.json](mdc:config/config.json)
+- **Raspberry Pi Focus**: Optimized for Pi hardware, not Windows development

.cursor/rules/raspberry-pi-development.mdc

@@ -0,0 +1,41 @@
+---
+alwaysApply: true
+---
+
+# Raspberry Pi Development Guidelines
+
+## Hardware Constraints
+- **Pi-only execution**: Code must run on Raspberry Pi, not Windows development machine
+- **LED matrix library**: Uses [rpi-rgb-led-matrix-master/](mdc:rpi-rgb-led-matrix-master/) for hardware control
+- **Memory limitations**: Optimize for Pi's limited RAM
+- **Performance**: Consider Pi's CPU capabilities in design
+
+## Development Workflow
+- **Local development**: Write and test code on Windows
+- **Pi deployment**: Deploy and test on actual Pi hardware
+- **SSH access**: Use SSH for Pi-based testing and debugging
+- **Service management**: Use systemd services for production deployment
+
+## Testing Strategy
+- **Unit tests**: Test logic without hardware dependencies
+- **Integration tests**: Test with mock display managers
+- **Hardware tests**: Validate on actual Pi with LED matrix
+- **Performance tests**: Monitor memory and CPU usage
+
+## Deployment Considerations
+- **Service files**: [ledmatrix.service](mdc:ledmatrix.service), [ledmatrix-web.service](mdc:ledmatrix-web.service)
+- **Installation scripts**: [first_time_install.sh](mdc:first_time_install.sh), [install_service.sh](mdc:install_service.sh)
+- **Dependencies**: [requirements.txt](mdc:requirements.txt) for Pi environment
+- **Permissions**: Handle file permissions for Pi user
+
+## Performance Optimization
+- **Caching**: Use [src/cache_manager.py](mdc:src/cache_manager.py) for data persistence
+- **Background services**: Non-blocking data fetching
+- **Memory management**: Clean up resources regularly
+- **Display optimization**: Minimize unnecessary redraws
+
+## Debugging on Pi
+- **Logging**: Comprehensive logging for remote debugging
+- **Error reporting**: Clear error messages for troubleshooting
+- **Status monitoring**: Health checks and status reporting
+- **Remote access**: Web interface for configuration and monitoring

.cursor/rules/sports-managers.mdc

@@ -0,0 +1,42 @@
+---
+globs: src/*_managers.py
+---
+
+# Sports Manager Development
+
+## Manager Architecture
+All sports managers inherit from base classes and follow consistent patterns:
+- **Base classes**: [src/nhl_managers.py](mdc:src/nhl_managers.py), [src/nfl_managers.py](mdc:src/nfl_managers.py)
+- **Common functionality**: Data fetching, caching, display rendering
+- **Configuration-driven**: Behavior controlled via config sections
+
+## Required Methods
+```python
+def __init__(self, config, display_manager, cache_manager)
+def update(self)  # Fetch fresh data
+def display(self, force_clear=False)  # Render current data
+```
+
+## Data Flow Pattern
+1. **Fetch**: Get data from API (with caching)
+2. **Process**: Extract relevant game information
+3. **Filter**: Apply favorite team preferences
+4. **Display**: Render to LED matrix
+
+## Logging Standards
+- **Structured prefixes**: `[NHL Recent]`, `[NFL Live]`, etc.
+- **Context information**: Include team names, game status, dates
+- **Debug levels**: Use appropriate log levels (info, debug, warning, error)
+- **User-friendly messages**: Explain what's happening and why
+
+## Error Handling
+- **API failures**: Log and continue with cached data if available
+- **No data scenarios**: Distinguish between API issues vs no games available
+- **Off-season awareness**: Provide helpful context during non-active periods
+- **Fallback behavior**: Show alternative content when preferred content unavailable
+
+## Configuration Integration
+- **Required settings**: Validate on initialization
+- **Optional settings**: Provide sensible defaults
+- **Background service**: Use for non-blocking data fetching
+- **Caching strategy**: Implement intelligent cache management

.cursor/rules/testing-standards.mdc

@@ -0,0 +1,51 @@
+---
+globs: test/*.py,src/*.py
+---
+
+# Testing Standards
+
+## Test Organization
+- **Test directory**: [test/](mdc:test/) - All test files
+- **Unit tests**: Test individual components in isolation
+- **Integration tests**: Test component interactions
+- **Hardware tests**: Validate on Raspberry Pi with actual LED matrix
+
+## Testing Principles
+- **Test behavior, not implementation**: Focus on what the code does, not how
+- **Mock external dependencies**: Use mocks for APIs, display managers, cache
+- **Test edge cases**: Empty data, API failures, configuration errors
+- **Pi-specific testing**: Validate hardware integration
+
+## Test Structure
+```python
+def test_manager_initialization():
+    """Test that manager initializes with valid config"""
+    config = {"sport_scoreboard": {"enabled": True}}
+    manager = ManagerClass(config, mock_display, mock_cache)
+    assert manager.enabled == True
+
+def test_api_failure_handling():
+    """Test graceful handling of API failures"""
+    # Test that system continues when API fails
+    # Verify fallback to cached data
+    # Check appropriate error logging
+```
+
+## Mock Patterns
+- **Display Manager**: Mock for testing without hardware
+- **Cache Manager**: Mock for testing data persistence
+- **API responses**: Mock for consistent test data
+- **Configuration**: Use test-specific configs
+
+## Test Categories
+- **Unit tests**: Individual manager methods
+- **Integration tests**: Manager interactions with services
+- **Configuration tests**: Validate config loading and validation
+- **Error handling tests**: API failures, invalid data, edge cases
+
+## Testing Best Practices
+- **Descriptive names**: Test names should explain what they test
+- **Single responsibility**: Each test should verify one thing
+- **Independent tests**: Tests should not depend on each other
+- **Clean setup/teardown**: Reset state between tests
+- **Pi compatibility**: Ensure tests work in Pi environment

.cursorignore

@@ -0,0 +1 @@
+# Add directories or file patterns to ignore during indexing (e.g. foo/ or *.csv)

.cursorrules

@@ -0,0 +1,364 @@
+# LEDMatrix Plugin Development Rules
+
+## Plugin System Overview
+
+The LEDMatrix project uses a plugin-based architecture. All display
+functionality (except core calendar) is implemented as plugins that are
+dynamically loaded from the directory configured by
+`plugin_system.plugins_directory` in `config.json` — the default is
+`plugin-repos/` (per `config/config.template.json:130`).
+
+> **Fallback note (scoped):** `PluginManager.discover_plugins()`
+> (`src/plugin_system/plugin_manager.py:154`) only scans the
+> configured directory — there is no fallback to `plugins/` in the
+> main discovery path. A fallback to `plugins/` does exist in two
+> narrower places:
+> - `store_manager.py:1700-1718` — store operations (install/update/
+>   uninstall) check `plugins/` if the plugin isn't found in the
+>   configured directory, so plugin-store flows work even when your
+>   dev symlinks live in `plugins/`.
+> - `schema_manager.py:70-80` — `get_schema_path()` probes both
+>   `plugins/` and `plugin-repos/` for `config_schema.json` so the
+>   web UI form generation finds the schema regardless of where the
+>   plugin lives.
+>
+> The dev workflow in `scripts/dev/dev_plugin_setup.sh` creates
+> symlinks under `plugins/`, which is why the store and schema
+> fallbacks exist. For day-to-day development, set
+> `plugin_system.plugins_directory` to `plugins` so the main
+> discovery path picks up your symlinks.
+
+## Plugin Structure
+
+### Required Files
+- **manifest.json**: Plugin metadata, entry point, class name, dependencies
+- **manager.py**: Main plugin class (must inherit from `BasePlugin`)
+- **config_schema.json**: JSON schema for plugin configuration validation
+- **requirements.txt**: Python dependencies (if any)
+- **README.md**: Plugin documentation
+
+### Plugin Class Requirements
+- Must inherit from `src.plugin_system.base_plugin.BasePlugin`
+- Must implement `update()` method for data fetching
+- Must implement `display()` method for rendering
+- Should implement `validate_config()` for configuration validation
+- Optional: Override `has_live_content()` for live priority features
+
+## Plugin Development Workflow
+
+### 1. Creating a New Plugin
+
+**Option A: Use dev_plugin_setup.sh (Recommended)**
+```bash
+# Link from GitHub
+./scripts/dev/dev_plugin_setup.sh link-github <plugin-name>
+
+# Link local repository
+./scripts/dev/dev_plugin_setup.sh link <plugin-name> <path-to-repo>
+```
+
+**Option B: Manual Setup**
+1. Create directory in `plugin-repos/<plugin-id>/` (or `plugins/<plugin-id>/`
+   if you're using the dev fallback location)
+2. Add `manifest.json` with required fields
+3. Create `manager.py` with plugin class
+4. Add `config_schema.json` for configuration
+5. Enable plugin in `config/config.json` under `"<plugin-id>": {"enabled": true}`
+
+### 2. Plugin Configuration
+
+Plugins are configured in `config/config.json`:
+```json
+{
+  "<plugin-id>": {
+    "enabled": true,
+    "display_duration": 15,
+    "live_priority": false,
+    "high_performance_transitions": false,
+    "transition": {
+      "type": "redraw",
+      "speed": 2,
+      "enabled": true
+    },
+    // ... plugin-specific config
+  }
+}
+```
+
+### 3. Testing Plugins
+
+**On Development Machine:**
+- Run the dev preview server: `python3 scripts/dev_server.py` (then
+  open `http://localhost:5001`) — renders plugins in the browser
+  without running the full display loop
+- Or run the full display in emulator mode:
+  `python3 run.py --emulator` (or equivalently
+  `EMULATOR=true python3 run.py`, or `./scripts/dev/run_emulator.sh`).
+  The `-e`/`--emulator` CLI flag is defined in `run.py:19-20`.
+- Test plugin loading: Check logs for plugin discovery and loading
+- Validate configuration: Ensure config matches `config_schema.json`
+
+**On Raspberry Pi:**
+- Deploy and test on actual hardware
+- Monitor logs: `journalctl -u ledmatrix -f` (if running as service)
+- Check plugin status in web interface
+
+### 4. Plugin Development Best Practices
+
+**Code Organization:**
+- Keep plugin code in `plugin-repos/<plugin-id>/` (or its dev-time
+  symlink in `plugins/<plugin-id>/`)
+- Use shared assets from `assets/` directory when possible
+- Follow existing plugin patterns — canonical sources live in the
+  [`ledmatrix-plugins`](https://github.com/ChuckBuilds/ledmatrix-plugins)
+  repo (`plugins/hockey-scoreboard/`, `plugins/football-scoreboard/`,
+  `plugins/clock-simple/`, etc.)
+- Place shared utilities in `src/common/` if reusable across plugins
+
+**Configuration Management:**
+- Use `config_schema.json` for validation
+- Store secrets in `config/config_secrets.json` under the same plugin
+  id namespace as the main config — they're deep-merged into the main
+  config at load time (`src/config_manager.py:162-172`), so plugin
+  code reads them directly from `config.get(...)` like any other key
+- There is no separate `config_secrets` reference field
+- Validate all required fields in `validate_config()`
+
+**Error Handling:**
+- Use plugin's logger: `self.logger.info/error/warning()`
+- Handle API failures gracefully
+- Cache data to avoid excessive API calls
+- Provide fallback displays when data unavailable
+
+**Performance:**
+- Use `cache_manager` for API response caching
+- Implement background data fetching if needed
+- Use `high_performance_transitions` for smoother animations
+- Optimize rendering for Pi's limited resources
+
+**Display Rendering:**
+- Use `display_manager` for all drawing operations
+- Support different display sizes (check `display_manager.width/height`)
+- Use `apply_transition()` for smooth transitions between displays
+- Clear display before rendering: `display_manager.clear()`
+- Always call `display_manager.update_display()` after rendering
+
+## Plugin API Reference
+
+### BasePlugin Class
+Located in: `src/plugin_system/base_plugin.py`
+
+**Required Methods:**
+- `update()`: Fetch/update data (called based on `update_interval` in manifest)
+- `display(force_clear=False)`: Render plugin content
+
+**Optional Methods:**
+- `validate_config()`: Validate plugin configuration
+- `has_live_content()`: Return True if plugin has live/urgent content
+- `get_live_modes()`: Return list of modes for live priority
+- `cleanup()`: Clean up resources on unload
+- `on_config_change(new_config)`: Handle config updates
+- `on_enable()`: Called when plugin enabled
+- `on_disable()`: Called when plugin disabled
+
+**Available Properties:**
+- `self.plugin_id`: Plugin identifier
+- `self.config`: Plugin configuration dict
+- `self.display_manager`: Display manager instance
+- `self.cache_manager`: Cache manager instance
+- `self.plugin_manager`: Plugin manager reference
+- `self.logger`: Plugin-specific logger
+- `self.enabled`: Boolean enabled status
+- `self.transition_manager`: Transition system (if available)
+
+### Display Manager
+Located in: `src/display_manager.py`
+
+**Key Methods:**
+- `clear()`: Clear the display
+- `draw_text(text, x, y, color, font, small_font, centered)`: Draw text
+- `update_display()`: Push the buffer to the physical display
+- `draw_weather_icon(condition, x, y, size)`: Draw a weather icon
+- `width`, `height`: Display dimensions
+
+**Image rendering**: there is no `draw_image()` helper. Paste directly
+onto the underlying PIL Image:
+```python
+self.display_manager.image.paste(pil_image, (x, y))
+self.display_manager.update_display()
+```
+For transparency, paste with a mask: `image.paste(rgba, (x, y), rgba)`.
+
+### Cache Manager
+Located in: `src/cache_manager.py`
+
+**Key Methods:**
+- `get(key, max_age=300)`: Get cached value (returns None if missing/stale)
+- `set(key, value, ttl=None)`: Cache a value
+- `delete(key)` / `clear_cache(key=None)`: Remove a single cache entry,
+  or (for `clear_cache` with no argument) every cached entry. `delete`
+  is an alias for `clear_cache(key)`.
+- `get_cached_data_with_strategy(key, data_type)`: Cache get with
+  data-type-aware TTL strategy
+- `get_background_cached_data(key, sport_key)`: Cache get for the
+  background-fetch service path
+
+## Plugin Manifest Schema
+
+Required fields in `manifest.json`:
+- `id`: Unique plugin identifier (matches directory name)
+- `name`: Human-readable plugin name
+- `version`: Semantic version (e.g., "1.0.0")
+- `entry_point`: Python file (usually "manager.py")
+- `class_name`: Plugin class name (must match class in entry_point)
+- `display_modes`: Array of mode names this plugin provides
+
+Common optional fields:
+- `description`: Plugin description
+- `author`: Plugin author
+- `homepage`: Plugin homepage URL
+- `category`: Plugin category (e.g., "sports", "weather")
+- `tags`: Array of tags
+- `update_interval`: Seconds between update() calls (default: 60)
+- `default_duration`: Default display duration (default: 15)
+- `requires`: Python version, display size requirements
+- `config_schema`: Path to config schema file
+- `api_requirements`: API dependencies and rate limits
+
+## Plugin Loading Process
+
+1. **Discovery**: PluginManager scans `plugins/` directory for directories containing `manifest.json`
+2. **Validation**: Validates manifest structure and required fields
+3. **Loading**: Imports plugin module and instantiates plugin class
+4. **Configuration**: Loads plugin config from `config/config.json`
+5. **Validation**: Calls `validate_config()` on plugin instance
+6. **Registration**: Adds plugin to available modes and stores instance
+7. **Enablement**: Calls `on_enable()` if plugin is enabled
+
+## Common Plugin Patterns
+
+### Sports Scoreboard Plugin
+- Use `background_data_service.py` pattern for API fetching
+- Implement live/recent/upcoming game modes
+- Use `scoreboard_renderer.py` for consistent rendering
+- Support team filtering and game filtering
+- Use shared sports logos from `assets/sports/`
+
+### Data Display Plugin
+- Fetch data in `update()` method
+- Cache API responses using `cache_manager`
+- Render in `display()` method
+- Handle API errors gracefully
+- Provide configuration for refresh intervals
+
+### Real-time Content Plugin
+- Implement `has_live_content()` for live priority
+- Use `get_live_modes()` to specify which modes are live
+- Set `live_priority: true` in config to enable live takeover
+- Update data frequently when live content exists
+
+## Debugging Plugins
+
+**Check Plugin Loading:**
+- Review logs for plugin discovery messages
+- Verify manifest.json syntax is valid JSON
+- Check that class_name matches actual class name
+- Ensure entry_point file exists and is importable
+
+**Check Plugin Execution:**
+- Add logging statements in `update()` and `display()`
+- Use `self.logger` for plugin-specific logging
+- Check cache_manager for cached data
+- Verify display_manager is rendering correctly
+
+**Common Issues:**
+- Import errors: Check Python path and dependencies
+- Config errors: Validate against config_schema.json
+- Display issues: Check display dimensions and coordinate calculations
+- Performance: Monitor CPU/memory usage on Pi
+
+## Plugin Testing
+
+**Unit Tests:**
+- Test plugin class instantiation
+- Test `update()` data fetching logic
+- Test `display()` rendering logic
+- Test `validate_config()` with various configs
+- Mock `display_manager` and `cache_manager` for testing
+
+**Integration Tests:**
+- Test plugin loading via PluginManager
+- Test plugin with actual config
+- Test plugin with emulator display
+- Test plugin with cache_manager
+
+**Hardware Tests:**
+- Test on Raspberry Pi with LED matrix
+- Verify display rendering on actual hardware
+- Test performance under load
+- Test with other plugins enabled
+
+## File Organization
+
+```
+plugins/
+  <plugin-id>/
+    manifest.json          # Plugin metadata
+    manager.py             # Main plugin class
+    config_schema.json     # Config validation schema
+    requirements.txt       # Python dependencies
+    README.md             # Plugin documentation
+    # Plugin-specific files
+    data_manager.py
+    renderer.py
+    etc.
+```
+
+## Git Workflow for Plugins
+
+**Plugin Development:**
+- Plugins are typically separate repositories
+- Use `dev_plugin_setup.sh` to link plugins for development
+- Symlinks are used to connect plugin repos to `plugins/` directory
+- Plugin repos follow naming: `ledmatrix-<plugin-name>`
+
+**Branching:**
+- Develop plugins in feature branches
+- Follow project branching conventions
+- Test plugins before merging to main
+
+**Automatic Version Bumping:**
+- **Automatic Version Management**: Version bumping is handled automatically via the pre-push git hook - no manual version bumping is required for normal development workflows
+- **GitHub as Source of Truth**: Plugin store always fetches latest versions from GitHub (releases/tags/manifest/commit)
+- **Pre-Push Hook**: Automatically bumps patch version and creates git tags when pushing code changes
+  - The hook is self-contained (no external dependencies) and works on any dev machine
+  - Installation: Copy the hook from LEDMatrix repo to your plugin repo:
+    ```bash
+    # From your plugin repository directory
+    cp /path/to/LEDMatrix/scripts/git-hooks/pre-push-plugin-version .git/hooks/pre-push
+    chmod +x .git/hooks/pre-push
+    ```
+  - Or use the installer script from the main LEDMatrix repo (one-time setup)
+  - The hook automatically:
+    1. Bumps the patch version (x.y.Z) in manifest.json when code changes are detected
+    2. Creates a git tag (v{version}) for the new version
+    3. Stages manifest.json for commit
+  - Skip auto-tagging: Set `SKIP_TAG=1` environment variable before pushing
+- **Manual Version Bumping (Edge Cases Only)**: Manual version bumps are only needed in rare circumstances:
+  - CI/CD pipelines that bypass git hooks
+  - Forked repositories without the pre-push hook installed
+  - Major/minor version bumps (hook only handles patch versions)
+  - When skipping auto-tagging but still needing a version bump
+  - For manual bumps, use the standalone script: `scripts/bump_plugin_version.py`
+- **Registry**: The plugin registry (plugins.json) stores only metadata (name, description, repo URL) - no versions
+- **Version Priority**: Plugin store checks versions in this order: GitHub Releases → GitHub Tags → Manifest from branch → Git commit hash
+
+## Resources
+
+- Plugin System Docs: `docs/PLUGIN_ARCHITECTURE_SPEC.md`
+- Plugin Examples: `plugins/hockey-scoreboard/`, `plugins/football-scoreboard/`
+- Base Plugin: `src/plugin_system/base_plugin.py`
+- Plugin Manager: `src/plugin_system/plugin_manager.py`
+- Development Setup: `dev_plugin_setup.sh`
+- Example Config: `dev_plugins.json.example`
+

.gitattributes

@@ -1,15 +1,2 @@
 # Auto detect text files and perform LF normalization
 * text=auto
-
-# Files the Pi executes must stay LF even in a Windows checkout with
-# core.autocrlf=true: a CRLF shebang line fails with "bad interpreter",
-# and systemd rejects CRLF unit files.
-*.sh text eol=lf
-*.service text eol=lf
-
-# Generated by scripts/build_css.py; collapsed in diffs, not hand-edited.
-web_interface/static/v3/tailwind.css linguist-generated=true
-web_interface/static/v3/plugin-frame.css linguist-generated=true
-
-# Installed as an executable (its shebang runs it) by install_service.sh.
-scripts/install/ledmatrix_refresh_units.py text eol=lf

.github/workflows/claude-code-review.yml

@@ -1,40 +0,0 @@
-name: Claude Code Review
-
-on:
-  pull_request:
-    types: [opened, synchronize, ready_for_review, reopened]
-
-jobs:
-  claude-review:
-    # Pull requests from forks get no repository secrets, so without this
-    # guard every outside contributor's PR showed this check red for a reason
-    # they can't fix. Skipped checks don't block merging.
-    if: github.event.pull_request.head.repo.full_name == github.repository
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      pull-requests: read
-      issues: read
-      id-token: write
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          fetch-depth: 1
-
-      - name: Run Claude Code Review
-        id: claude-review
-        uses: anthropics/claude-code-action@756cc22e19660d20e8cc9496b4f242475a7f7790 # v1
-        with:
-          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
-          # Review PRs opened by the Claude GitHub App. Without this the action
-          # aborts before reading the diff ("Workflow initiated by non-human
-          # actor"), so every such PR shows this check red. Named rather than
-          # '*': the allow-list is matched against the triggering actor, so
-          # this admits claude[bot] alone and no other app.
-          allowed_bots: 'claude'
-          plugin_marketplaces: 'https://github.com/anthropics/claude-code.git'
-          plugins: 'code-review@claude-code-plugins'
-          prompt: '/code-review:code-review ${{ github.repository }}/pull/${{ github.event.pull_request.number }}'
-

.github/workflows/claude.yml

@@ -1,42 +0,0 @@
-name: Claude Code
-
-on:
-  issue_comment:
-    types: [created]
-  pull_request_review_comment:
-    types: [created]
-  issues:
-    types: [opened, assigned]
-  pull_request_review:
-    types: [submitted]
-
-jobs:
-  claude:
-    if: |
-      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
-      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
-      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
-      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      pull-requests: read
-      issues: read
-      id-token: write
-      actions: read # Required for Claude to read CI results on PRs
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          fetch-depth: 1
-
-      - name: Run Claude Code
-        id: claude
-        uses: anthropics/claude-code-action@756cc22e19660d20e8cc9496b4f242475a7f7790 # v1
-        with:
-          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
-
-          # This is an optional setting that allows Claude to read CI results on PRs
-          additional_permissions: |
-            actions: read
-

.github/workflows/release-version-check.yml

@@ -1,40 +0,0 @@
-name: Release version check
-
-# A release tag, the CHANGELOG, and src.__version__ must agree. They have not
-# always: v3.1.0 was tagged while src/__init__.py still said "1.0.0", which
-# silently exempted every device installed from that release from plugin
-# compatibility warnings. See docs/SPORTS_UNIFICATION.md (phase B4).
-on:
-  push:
-    tags: ["v*"]
-  release:
-    types: [published]
-  # Pre-flight: run this against the tag you are about to create.
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: "Tag to check (e.g. v3.2.0)"
-        required: true
-        type: string
-
-permissions:
-  contents: read
-
-jobs:
-  version-matches-tag:
-    name: Tag matches src.__version__
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          persist-credentials: false
-
-      - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b # v5.3.0
-        with:
-          python-version: "3.13"
-
-      # No dependencies: the script reads src/__init__.py and CHANGELOG.md only.
-      - name: Assert the tag, CHANGELOG and src.__version__ agree
-        run: python scripts/check_release_version.py "${TAG}"
-        env:
-          TAG: ${{ inputs.tag || github.ref_name }}

.github/workflows/test.yml

@@ -4,30 +4,11 @@ on:
   pull_request:
   push:
     branches: [main]
-  # Manual runs against any branch — useful when a PR's automatic run
-  # needs a re-run or didn't get created.
-  workflow_dispatch:
-
-# The jobs only check out the repo and run the tests.
-permissions:
-  contents: read
 
 jobs:
   plugin-safety:
-    name: Plugin safety harness + unit tests (Python ${{ matrix.python-version }})
+    name: Plugin safety harness + unit tests
     runs-on: ubuntu-latest
-    # The two Pythons the installer supports: Raspberry Pi OS Bookworm ships
-    # 3.11 and Trixie 3.13.
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ["3.11", "3.13"]
-    env:
-      # The bundled fixture plugin gives the harness at least one real plugin
-      # to render, and REQUIRE_PLUGINS turns "discovered zero plugins" into a
-      # hard failure instead of a silent all-skip green run.
-      LEDMATRIX_PLUGINS_DIR: test/fixtures/plugins
-      LEDMATRIX_REQUIRE_PLUGINS: "1"
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
@@ -35,174 +16,18 @@ jobs:
 
       - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b # v5.3.0
         with:
-          python-version: ${{ matrix.python-version }}
+          python-version: "3.12"
           cache: pip
 
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          pip install -r requirements.txt -r web_interface/requirements.txt -r requirements-test.txt
+          pip install -r requirements.txt -r requirements-test.txt
           pip install RGBMatrixEmulator
 
-      - name: Run plugin safety harness
+      - name: Run harness + visual rendering tests
         run: |
-          pytest --no-cov test/plugins/
-
-  unit-tests:
-    name: Core unit tests (Python ${{ matrix.python-version }})
-    runs-on: ubuntu-latest
-    # Bookworm's Python (3.11) and Trixie's (3.13); see plugin-safety.
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ["3.11", "3.13"]
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          persist-credentials: false
-
-      - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b # v5.3.0
-        with:
-          python-version: ${{ matrix.python-version }}
-          cache: pip
-
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install -r requirements.txt -r web_interface/requirements.txt -r requirements-test.txt
-          pip install RGBMatrixEmulator
-
-      # Run the ENTIRE test tree (except test/plugins, which the
-      # plugin-safety job owns). New test files are enrolled automatically;
-      # excluding anything requires a visible, commented --ignore here.
-      # Coverage is measured and enforced only in this step — pytest.ini
-      # deliberately carries no coverage flags so local runs stay fast.
-      - name: Run core unit suites
-        run: |
-          pytest -m "not hardware" test/ \
-            --ignore=test/plugins \
-            --cov=src --cov=web_interface \
-            --cov-report=term \
-            --cov-fail-under=52
-
-  js-tests:
-    name: Web UI JS tests
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          persist-credentials: false
-
-      - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b # v5.3.0
-        with:
-          python-version: "3.13"
-          cache: pip
-
-      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
-        with:
-          node-version: "22"
-
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install -r requirements.txt -r web_interface/requirements.txt
-          npm install --no-audit --no-fund --prefix test/js
-
-      # The DOM suites test the real server-rendered pages and API, so they
-      # need the web interface running. REQUIRE_DOM turns "couldn't reach it"
-      # into a failure instead of a silent skip.
-      - name: Start the web interface
-        run: |
-          EMULATOR=true python -c "from web_interface.app import app; app.run(host='127.0.0.1', port=5000, threaded=True)" > web.log 2>&1 &
-          for i in $(seq 60); do curl -sf -o /dev/null http://127.0.0.1:5000/ && exit 0; sleep 1; done
-          cat web.log
-          exit 1
-
-      - name: Run JS suites
-        env:
-          BASE: http://127.0.0.1:5000
-          REQUIRE_DOM: "1"
-        run: node test/js/run_all.js
-
-  css-build:
-    name: Tailwind CSS is up to date
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          persist-credentials: false
-
-      - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b # v5.3.0
-        with:
-          python-version: "3.13"
-
-      # Downloads the pinned standalone Tailwind CLI (SHA-256 checked; no
-      # Node), rebuilds static/v3/tailwind.css and plugin-frame.css from the
-      # templates and JS, and fails if the committed files differ. Fix a
-      # failure by running `python3 scripts/build_css.py` and committing.
-      - name: Check the committed CSS matches a fresh build
-        run: python scripts/build_css.py --check
-
-  type-check:
-    name: Type check (mypy ratchet)
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          persist-credentials: false
-
-      - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b # v5.3.0
-        with:
-          python-version: "3.13"
-          cache: pip
-
-      # The runtime requirements are installed so mypy sees the real types of
-      # PIL, requests, psutil and friends -- missing, they'd be Any and the
-      # result would differ from a developer's machine. mypy and the stubs are
-      # pinned so a new release can't turn this red without a code change.
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install -r requirements.txt -r web_interface/requirements.txt
-          pip install mypy==1.20.2 types-requests==2.33.0.20260906 types-pytz==2026.4.0.20260926
-
-      # mypy on exactly the modules in mypy-clean.txt; fails on any error in
-      # them, or if a listed file is missing. See CONTRIBUTING.md.
-      - name: Run mypy on the ratchet list
-        run: python scripts/check_types.py
-
-  sports-drift-report:
-    name: Sports drift report (report only)
-    runs-on: ubuntu-latest
-    # A progress measure for docs/SPORTS_UNIFICATION.md, never a gate: the
-    # monorepo's own check_sports_drift.py is the gate. The step summary shows
-    # how many bodies each scoreboard method family still has.
-    continue-on-error: true
-    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          persist-credentials: false
-
-      - name: Check out ledmatrix-plugins (main)
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
-        with:
-          repository: ChuckBuilds/ledmatrix-plugins
-          path: ledmatrix-plugins
-          persist-credentials: false
-
-      - uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b # v5.3.0
-        with:
-          python-version: "3.13"
-
-      # Stdlib only; exits 0 whatever it finds.
-      - name: Report method-family drift across the nine scoreboards
-        run: |
-          python scripts/sports_drift_report.py --plugins ledmatrix-plugins \
-            --markdown --json sports-drift.json >> "$GITHUB_STEP_SUMMARY"
-          python scripts/sports_drift_report.py --plugins ledmatrix-plugins
-
-      - name: Upload the full report
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: sports-drift-report
-          path: sports-drift.json
+          pytest --no-cov \
+            test/plugins/test_harness.py \
+            test/plugins/test_visual_rendering.py \
+            test/plugins/test_plugin_matrix.py

.gitignore

@@ -3,13 +3,12 @@ __pycache__/
 *.py[cod]
 *$py.class
 
-# Secrets and per-device state. Everything the software writes into config/
-# is local to one device -- config.json, config_secrets.json, wifi_config.json,
-# ytm_auth.json (a login session), saved_repositories.json, font_overrides.json,
-# and the temp files atomic writes leave behind when interrupted -- so only
-# the templates are tracked. Listing files one by one missed several.
-config/*
-!config/*.template.json
+# Secrets
+config/config_secrets.json
+config/config.json
+config/config.json.backup
+config/wifi_config.json
+config/uninstalled_plugins.json
 credentials.json
 token.pickle
 
@@ -37,12 +36,11 @@ htmlcov/
 # Cache directory (root level only, not src/cache which is source code)
 /cache/
 
-# Development plugins directory: symlinks into a ledmatrix-plugins checkout
-# See docs/PLUGIN_DEVELOPMENT_GUIDE.md and docs/MULTI_ROOT_WORKSPACE_SETUP.md
+# Development plugins directory
+# Plugins are managed as separate repositories via multi-root workspace
+# See docs/MULTI_ROOT_WORKSPACE_SETUP.md for details
 plugins/*
 !plugins/.gitkeep
-# Local settings for scripts/dev/dev_plugin_setup.sh (template: dev_plugins.json.example)
-/dev_plugins.json
 
 # Binary files and backups
 bin/pixlet/
@@ -50,40 +48,3 @@ config/backups/
 
 # Starlark apps runtime storage (installed .star files and cached renders)
 /starlark-apps/
-
-# JS test deps (test/js)
-node_modules/
-package-lock.json
-
-# Team logos fetched at runtime.
-#
-# src/logo_downloader.py and LogoHelper write into assets/sports/<league>_logos/
-# whenever a plugin meets a team whose logo is not on disk. Those directories are
-# also tracked -- 209 NCAA logos and 153 soccer ones ship with the repo -- so
-# every rig accumulated untracked files it was never meant to commit and
-# `git status` was permanently dirty. That noise is not harmless: it trains
-# everyone to ignore the one signal that says a checkout is not what you think
-# it is, which is how a stale tree sat unnoticed on a rig until a restart
-# surfaced four dead sports plugins.
-#
-# Ignoring a directory does not untrack what is already in it, so the logos that
-# ship keep shipping. Only new downloads are hidden.
-#
-# Adding a logo on purpose is rare and deliberate -- the last time was #415, four
-# named NCAA logos a plugin needed, and there has been no other in a year. Do it
-# with an explicit override:
-#     git add -f assets/sports/ncaa_logos/DUKE.png
-assets/sports/*_logos/
-assets/stocks/ticker_icons/
-assets/stocks/crypto_icons/
-
-# Plugin operation state written at runtime.
-#
-# web_interface/app.py writes data/plugin_state.json and data/operation_history.json
-# (older releases also data/plugin_operations.json) as the web interface runs, into
-# a directory that ships tracked (data/.gitkeep). Unignored, every rig that ever
-# opened the web UI -- and every test run that constructs the app -- would leave
-# untracked files behind and a permanently dirty `git status`. Same reasoning as
-# the logo rule above: a checkout that is always dirty is a checkout nobody reads.
-data/*
-!data/.gitkeep

.pre-commit-config.yaml

@@ -37,22 +37,14 @@ repos:
         types: [python]
         pass_filenames: false
 
-  # The mypy ratchet -- the same check as CI's "Type check (mypy ratchet)"
-  # job: mypy on exactly the modules listed in mypy-clean.txt. Run it with
-  #   pre-commit run mypy --hook-stage manual
-  # A local hook rather than mirrors-mypy so mypy sees the packages installed
-  # from requirements.txt, as CI does; an isolated hook env without them types
-  # PIL, requests and friends as Any and reports different errors. Needs
-  # mypy==1.20.2 (the version CI pins) in the environment you commit from.
-  - repo: local
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.8.0
     hooks:
       - id: mypy
-        name: mypy (ratchet, mypy-clean.txt)
-        entry: python scripts/check_types.py
-        language: system
+        additional_dependencies: [types-requests, types-pytz]
+        args: [--ignore-missing-imports, --no-error-summary]
         pass_filenames: false
-        always_run: true
-        stages: [manual]
+        files: ^src/
 
   - repo: https://github.com/PyCQA/bandit
     rev: 1.8.3

CLAUDE.md

@@ -6,55 +6,32 @@
 - `config/config.json` — User plugin configuration (persists across plugin reinstalls)
 - `plugin-repos/` — **Default** plugin install directory used by the
   Plugin Store, set by `plugin_system.plugins_directory` in
-  `config.json` (default per `config/config.template.json`).
+  `config.json` (default per `config/config.template.json:130`).
   Not gitignored.
 - `plugins/` — Legacy/dev plugin location. Gitignored (`plugins/*`).
   Used by `scripts/dev/dev_plugin_setup.sh` for symlinks. The plugin
-  loader does NOT fall back to it — `PluginManager.discover_plugins()`
-  (`src/plugin_system/plugin_manager.py`) scans only the configured
-  directory. Fallbacks exist in two narrower places: store operations
-  (`PluginStoreManager._find_plugin_path()` in `store_manager.py`, which
-  searches `store_search_dirs()` from `plugin_dirs.py`) and schema lookup
-  (`SchemaManager.get_schema_path()` in `schema_manager.py`, which probes
-  `plugins/` *before* `plugin-repos/`).
-- `src/plugin_system/plugin_dirs.py` — the one resolver for "which directory
-  holds plugin X" (manifest `id` first, then `<id>` / `ledmatrix-<id>`)
+  loader falls back to it when something isn't found in `plugin-repos/`
+  (`src/plugin_system/schema_manager.py:77`).
 
 ## Plugin System
 - Plugins inherit from `BasePlugin` in `src/plugin_system/base_plugin.py`
 - Required abstract methods: `update()`, `display(force_clear=False)`
-- Each plugin needs: `manifest.json`, `config_schema.json`, and the entry point (`manager.py` by default); `requirements.txt` if it has dependencies. Required manifest fields: `docs/PLUGIN_API_REFERENCE.md#manifest-required-fields`
+- Each plugin needs: `manifest.json`, `config_schema.json`, `manager.py`, `requirements.txt`
 - Plugin instantiation args: `plugin_id, config, display_manager, cache_manager, plugin_manager`
 - Config schemas use JSON Schema Draft-7
-- Display dimensions: always read dynamically from `self.display_manager.width/height` — not `display_manager.matrix.width/height`, because `matrix` is `None` when hardware init fails (the properties fall back to the canvas size)
-- Secrets: namespaced by plugin id in `config/config_secrets.json`, declared
-  via `"x-secret": true` in the plugin's config schema, and deep-merged into
-  the plugin's config dict at load time — plugins read them with plain
-  `config.get(...)`, never a separate accessor
-
-## Dev Workflow
-- Link a plugin for development: `./scripts/dev/dev_plugin_setup.sh link-github <name>` clones the `ledmatrix-plugins` monorepo into `~/.ledmatrix-dev-plugins/` and links its `plugins/<name>` under the manifest id (add a repo URL for a plugin with its own repo; or `link <name> <path>`); symlinks land in `plugins/` — set `plugin_system.plugins_directory` to `plugins` so discovery picks them up. Fork/location overrides: `dev_plugins.json` (from `dev_plugins.json.example`)
-- Browser preview without the display loop: `python3 scripts/dev_server.py` → http://localhost:5001
-- Full display in emulator mode: `python3 run.py -e` (or `EMULATOR=true python3 run.py`)
-- Validate one plugin headlessly: `python3 scripts/check_plugin.py --plugin <id>`
-- Soak a rig for frame timing (on the Pi, service running): `python3 scripts/frame_soak.py --preview` — late-frame rate across every scroller; see `docs/SCROLL_PERFORMANCE.md`
+- Display dimensions: always read dynamically from `self.display_manager.matrix.width/height`
 
 ## Plugin Store Architecture
 - Official plugins live in the `ledmatrix-plugins` monorepo (not individual repos)
 - Plugin repo naming convention: `ledmatrix-<plugin-id>` (e.g., `ledmatrix-football-scoreboard`)
 - `plugins.json` registry at `https://raw.githubusercontent.com/ChuckBuilds/ledmatrix-plugins/main/plugins.json`
-- Store manager (`PluginStoreManager` in `src/plugin_system/store_manager.py`) handles install/update/uninstall
-- Monorepo plugins are installed without a `.git` directory: GitHub Trees API + raw downloads, falling back to ZIP extraction
+- Store manager (`src/plugin_system/store_manager.py`) handles install/update/uninstall
+- Monorepo plugins are installed via ZIP extraction (no `.git` directory)
 - Update detection for monorepo plugins uses version comparison (manifest version vs registry latest_version)
-- Optional registry entry fields (`store_registry.py`): `ledmatrix_min_version` refuses an incompatible install/update before the download (the post-download manifest gate stays as the fallback); `aliases` are the entry's other ids (manifest id `ledmatrix-weather` for `weather`), used with the `plugin_path` name by update/uninstall/reinstall to find the install — only this registry proof counts, never a bare `ledmatrix-<id>` folder (owner decision, #686; such a folder is only logged); `commit` is informational. An older plugins.json has none of them
 - Plugin configs stored in `config/config.json`, NOT in plugin directories — safe across reinstalls
 - Third-party plugins can use their own repo URL with empty `plugin_path`
 
 ## Common Pitfalls
-- paho-mqtt 2.x requires a `CallbackAPIVersion` argument: `VERSION1` for code written against v1 callback signatures (the MQTT bridge uses `VERSION2`)
+- paho-mqtt 2.x needs `callback_api_version=mqtt.CallbackAPIVersion.VERSION1` for v1 compat
 - BasePlugin uses `get_logger()` from `src.logging_config`, not standard `logging.getLogger()`
-- `DisplayManager` has no `draw_image()` — paste onto the PIL image directly:
-  `self.display_manager.image.paste(img, (x, y))` then `update_display()`
-  (use a mask for transparency: `image.paste(rgba, (x, y), rgba)`)
 - When modifying a plugin in the monorepo, you MUST bump `version` in its `manifest.json` and run `python update_registry.py` — otherwise users won't receive the update
-- `src/pi5_matrix_support.py` hardcodes what the pinned `rpi-rgb-led-matrix-master` can drive on a Raspberry Pi 5 (`Rp1PioConfigSupported()` in `lib/rp1/rp1_pio_backend.cc`). Re-check it whenever the submodule is bumped: a stale rule blocks Pi 5 settings the new library supports, and a missing one lets the display service crash-loop. `src/matrix_support.py` holds the same kind of rules for every board (rows, chain length, mapping names, parallel per mapping) and needs the same re-check

CODE_OF_CONDUCT.md

@@ -63,7 +63,7 @@ ChuckBuilds, and any other forums hosted by or affiliated with the project.
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
 reported to the community leaders responsible for enforcement on the
-[LEDMatrix Discord](https://discord.gg/RdrC37rEag) (DM a moderator or
+[LEDMatrix Discord](https://discord.gg/uW36dVAtcT) (DM a moderator or
 ChuckBuilds directly) or by opening a private GitHub Security Advisory if
 the issue involves account safety. All complaints will be reviewed and
 investigated promptly and fairly.

CONTRIBUTING.md

@@ -9,7 +9,7 @@ improvements, and code changes.
 - **Bugs / feature requests**: open an issue using one of the templates
   in [`.github/ISSUE_TEMPLATE/`](.github/ISSUE_TEMPLATE/).
 - **Real-time discussion**: the
-  [LEDMatrix Discord](https://discord.gg/RdrC37rEag).
+  [LEDMatrix Discord](https://discord.gg/uW36dVAtcT).
 - **Plugin development**:
   [`docs/PLUGIN_DEVELOPMENT_GUIDE.md`](docs/PLUGIN_DEVELOPMENT_GUIDE.md)
   and the [`ledmatrix-plugins`](https://github.com/ChuckBuilds/ledmatrix-plugins)
@@ -40,7 +40,7 @@ improvements, and code changes.
 ## Running the tests
 
 ```bash
-pip install -r requirements.txt -r requirements-test.txt
+pip install -r requirements.txt
 pytest
 ```
 
@@ -57,25 +57,9 @@ integration tests.
    `docs/<short-description>`.
 3. **Keep PRs focused.** One conceptual change per PR. If you find
    adjacent bugs while working, fix them in a separate PR.
-4. **Follow the existing code style.** The pre-commit hooks run
-   `flake8` (E9, F63, F7, F82 plus bugbear `B` checks), `bandit`,
-   and `gitleaks` — install the CLI with
-   `python -m pip install pre-commit`, then run
-   `pre-commit install` so they run on every commit. Type checking
-   is a ratchet while the existing mypy errors in `src/` are paid
-   down: `mypy-clean.txt` lists the modules that type-check clean, and
-   CI runs `python scripts/check_types.py` (also the manual hook
-   `pre-commit run mypy --hook-stage manual`) to keep every listed
-   module clean. When you make another module clean, add it to the
-   list (sorted); don't take one off to get CI green. Keep type fixes
-   annotation-only where you can -- widen a hint rather than delete a
-   defensive runtime check mypy calls unreachable. HTML/JS in
-   `web_interface/` follows the patterns already in `templates/v3/`
-   and `static/v3/`. If you change a template or a static JS file,
-   run `python3 scripts/build_css.py` and commit the regenerated
-   `static/v3/tailwind.css` with it -- CI fails when the committed CSS
-   is out of date. It needs no Node; see
-   [`web_interface/README.md`](web_interface/README.md#styling-tailwind-css).
+4. **Follow the existing code style.** Python code uses standard
+   `black`/`ruff` conventions; HTML/JS in `web_interface/` follows the
+   patterns already in `templates/v3/` and `static/v3/`.
 5. **Update documentation** alongside code changes. If you add a
    config key, document it in the relevant `*.md` file (or, for
    plugins, in `config_schema.json` so the form is auto-generated).

PRODUCT.md

@@ -1,74 +0,0 @@
-# Product
-
-<!-- impeccable:product-schema 1 -->
-
-## Platform
-
-web
-
-## Users
-
-Designed novice-first, with power tools kept within reach.
-
-- **Primary: hobbyist builders.** People who assembled an LED matrix panel on a Raspberry Pi, often by following the install video, and are frequently new to Linux and the Pi. They set the display up once (panel size, timezone, WiFi), install and enable a few plugins, then come back occasionally to tweak what the panel shows. They usually reach the control panel from a phone or laptop on their home network, sometimes as an installed home-screen app.
-- **Secondary: tinkerers and plugin developers.** Comfortable with SSH, `config.json`, and GitHub. They lean on the Config Editor, Logs, Cache, Operation History, Tools, GitHub-repo installs, and per-plugin config while building or debugging. Their tools must stay reachable without sitting in the novice's path.
-
-## Product Purpose
-
-LEDMatrix turns a Raspberry Pi and an RGB LED matrix panel into an information-rich display (clock, weather, calendar, sports scores, stocks, music, and more) through a plugin platform. The web control panel ("LED Matrix Control") is where the display gets configured, extended, and kept healthy.
-
-Success means a builder gets from a freshly flashed Pi to a working, personalized display without needing a terminal, and can keep it running (updates, recovery, troubleshooting) the same way.
-
-## Positioning
-
-Four strengths define LEDMatrix, and future work must protect all of them:
-
-1. **Plugin ecosystem.** The core ships only `starlark-apps` and `web-ui-info`; everything else comes from the built-in Plugin Store (the official `ledmatrix-plugins` monorepo), third-party GitHub repos, or Starlark (Tidbyt-style) apps. Each installed plugin gets its own configuration tab, generated from its schema.
-2. **Runs on tiny Pis.** The UI is served by the same device that drives the matrix, on boards as small as the Pi Zero 2 W (512 MB), Pi 3/3B+, and the 1 GB Pi 4.
-3. **Recovers without SSH.** WiFi access-point fallback with a captive setup page, backup & restore, in-UI updates, live logs, diagnostics, service control, and plugin health let users fix problems from the browser.
-4. **Open and community-led.** GPL-3.0, a Discord community, and contributions welcome. The maintainer (ChuckBuilds) builds in public and openly relies on AI development tools.
-
-## Operating Context
-
-- **Access.** Served on the local network at `http://<pi-ip>:5000` by the `ledmatrix-web` service. It is installable as a PWA (`web_interface/static/v3/manifest.json`, short name "LEDMatrix").
-- **First run.** When the Pi has no network it creates its own WiFi access point, so the captive setup page (`templates/v3/captive_setup.html`) may be the very first screen a user sees, on a phone, with no internet connection.
-- **Navigation.**
-  - System tabs: Overview, General, WiFi, Schedule, Display, Rotation, Config Editor, Backup & Restore, Fonts, Logs, Cache, Operation History, Tools.
-  - A second row holds Plugin Manager (with the Plugin Store), Starlark Apps, and one tab per installed plugin.
-- **Live data.** The Overview shows system stats (CPU, memory, temperature, power/throttling) and a live display preview, streamed over SSE.
-- **Getting Started checklist.** The Overview's first-run checklist runs: set panel size → set timezone → install a plugin → enable it → configure it.
-- **Development.** `python3 scripts/dev_server.py` gives a browser preview without the display loop; `python3 run.py -e` runs the full display in emulator mode.
-
-## Capabilities and Constraints
-
-- **Hard constraint: plugin UI compatibility.** Third-party plugins rely on JSON Schema (Draft-7) generated config forms, the widget registry (`static/v3/js/widgets/`), `x-secret` fields, and plugin web-UI actions. UI changes must keep these working.
-- **Config storage.** Plugin configuration lives in `config/config.json` and secrets in `config/config_secrets.json`, never in plugin directories, so configs survive reinstalls.
-- **Stack.** An existing Flask + HTMX + Alpine.js app with Jinja templates (`web_interface/templates/v3/`) and static JS/CSS (`web_interface/static/v3/`), with self-hosted vendor assets.
-- **Terminology.** Plugin, Plugin Store, Starlark app, rotation, display duration, Vegas Scroll Mode, on-demand, AP mode.
-- **Open decisions** (offered during init, not adopted as constraints):
-  - Whether the UI must work fully offline, with no CDN fallbacks at runtime.
-  - Whether a Node/CSS build step is acceptable for contributors.
-  - Whether a formal accessibility standard (e.g. WCAG 2.2 AA) is a requirement.
-
-## Brand Commitments
-
-- **Names.** The product is "LEDMatrix" and the web UI is titled "LED Matrix Control". The maintainer brand is ChuckBuilds.
-- **Voice.** Friendly, honest, and learning-in-public, as in the README.
-- **App icons.** They live in `web_interface/static/v3/icons/`.
-
-No other visual identity has been made binding.
-
-## Evidence on Hand
-
-- **Photos.** Real photographs of running displays are linked in `README.md` (clock, weather, calendar, NHL/MLB/NFL/NCAA, stocks, music).
-- **Video.** YouTube install and walkthrough videos from ChuckBuilds.
-- **Docs.** Extensive documentation in `docs/`, e.g. `WEB_INTERFACE_GUIDE.md`, `GETTING_STARTED.md`, `WIFI_NETWORK_SETUP.md`, `LOW_MEMORY_BOARDS.md`, `PLUGIN_STORE_GUIDE.md`.
-- **Absences.** There are no testimonials, user counts, or benchmark figures. Do not fabricate them.
-
-## Product Principles
-
-1. **Novice path first, power one click away.** Default views serve the first-time builder, while advanced tools stay discoverable for tinkerers.
-2. **Never strand the user at a terminal.** Every setup, recovery, and troubleshooting task has a browser path, including from the AP-mode captive page.
-3. **Respect the Pi.** Every feature is paid for in memory and CPU on a Pi Zero 2 W that is also driving the display.
-4. **The ecosystem is the product.** Plugins, including third-party ones, must feel first-class and keep working across core UI changes.
-5. **Honest and welcoming.** Plain language, truthful status, and no overstated claims, in keeping with an open, community-built project.

README.md

@@ -33,7 +33,7 @@ I'm trying to be open to constructive criticism and support, as long as it's a r
 - Show support on Youtube: https://www.youtube.com/@ChuckBuilds
 - Check out the write-up on my website: https://www.chuck-builds.com/led-matrix/
 - Stay in touch on Instagram: https://www.instagram.com/ChuckBuilds/
-- Want to chat? Reach out on the LEDMatrix Discord: [https://discord.gg/RdrC37rEag](https://discord.gg/RdrC37rEag)
+- Want to chat? Reach out on the LEDMatrix Discord: [https://discord.com/invite/uW36dVAtcT](https://discord.gg/dfFwsasa6W)
 - Feeling Generous? Consider sponsoring this project or sending a donation (these AI credits aren't cheap!)          
 
 -----------------------------------------------------------------------------------
@@ -50,15 +50,7 @@ I'm trying to be open to constructive criticism and support, as long as it's a r
 
 <details>
 <summary>Core Features</summary>
-LEDMatrix is a plugin platform: the displays below are plugins installed
-from the built-in Plugin Store (web interface → Plugins), where each can be
-individually enabled, ordered, and configured — display durations, teams,
-stocks, weather, timezones, and more. The core repo ships with just two
-bundled plugins (`starlark-apps` and `web-ui-info`); the official plugins
-live in the [ledmatrix-plugins](https://github.com/ChuckBuilds/ledmatrix-plugins)
-monorepo and install with one click, and third-party plugins can be
-installed from their own GitHub repositories. Displays available in the
-store include:
+The following plugins are available inside of the LEDMatrix project. These modular, rotating Displays that can be individually enabled or disabled per the user's needs with some configuration around display durations, teams, stocks, weather, timezones, and more. Displays include:
 
 ### Time and Weather
 - Real-time clock display (2x 64x32 Displays 4mm Pixel Pitch)
@@ -140,36 +132,29 @@ The system supports live, recent, and upcoming game information for multiple spo
 | This project can be finnicky! RGB LED Matrix displays are not built the same or to a high-quality standard. We have seen many displays arrive dead or partially working in our discord. Please purchase from a reputable vendor. |
 
 ### Raspberry Pi
-- **Raspberry Pi 3B, 4, or 5** (a Pi Zero 2 W also works, with the limits described under the 1GB/low-memory bullet below; the original Pi Zero / Zero W doesn't have enough processing power for this project)
+- Raspberry Pi Zero's don't have enough processing power for this project.
+- **Raspberry Pi 3B, 4, or 5**
   [Amazon Affiliate Link – Raspberry Pi 4 4GB RAM](https://amzn.to/4dJixuX)
   [Amazon Affiliate Link – Raspberry Pi 4 8GB RAM](https://amzn.to/4qbqY7F)
   - **Pi 5 users**: the installer automatically detects Pi 5 and builds the `rpi-rgb-led-matrix` library with RP1 support. If you previously installed on a Pi 4 and migrated the SD card, or if you see `mmap` errors in the logs, force a fresh library build:
     ```bash
     sudo RPI_RGB_FORCE_REBUILD=1 ./first_time_install.sh
     ```
-  - Pi 5 config: leave `rp1_rio` at `0` (PIO mode, default) and start `gpio_slowdown` at `1`, raising it a step at a time if the image flickers or shows garbage (see `gpio_slowdown` under Display Settings).
-  - **1GB models (Pi 3B / 3B+), the 512MB Pi Zero 2 W and other low-memory boards**: supported, but the `rpi-rgb-led-matrix` C++ build needs more memory than the Pi has. The installer detects this automatically, compiles with fewer parallel jobs, and adds a temporary swapfile for the build which it removes afterwards. Expect that step to take 15-25 minutes instead of 2-5, and leave at least **3GB free** on the SD card. If you manage swap yourself, opt out with `--skip-swap`. To pin the compiler down further, use `--build-jobs 1`. Once running, keep an eye on memory: see [docs/LOW_MEMORY_BOARDS.md](docs/LOW_MEMORY_BOARDS.md).
+  - Pi 5 config: leave `rp1_rio` at `0` (PIO mode, default) and set `gpio_slowdown` to `1` or `2`.
 
 
-### Operating system
-- **Raspberry Pi OS Lite, Trixie (Debian 13) or Bookworm (Debian 12)**, 64-bit recommended. Trixie is the current release and the one to pick for a new SD card; an existing Bookworm install works as it is, no upgrade needed. The installer checks this first and stops with directions on anything else (Bullseye and older, the desktop edition, other distributions).
-- **Python**: whatever the OS ships, 3.13 on Trixie and 3.11 on Bookworm. Don't install a different Python; the installer and the services use the system `python3`.
-- **Networking**: NetworkManager, the default on both. Choosing a WiFi network from the web page and the `LEDMatrix-Setup` hotspot need it; if you switched to dhcpcd in `raspi-config`, switch back (Advanced Options → Network Config → NetworkManager).
-
 ### RGB Matrix Bonnet / HAT
 - [Adafruit RGB Matrix Bonnet/HAT](https://www.adafruit.com/product/3211) – supports one “chain” of horizontally connected displays  
-- [Adafruit Triple LED Matrix Bonnet](https://www.adafruit.com/product/6358) – supports up to 3 vertical “chains” of horizontally connected displays *(use `regular` as hardware mapping)*  
+- [Adafruit Triple LED Matrix Bonnet](https://www.adafruit.com/product/6358) – supports up to 3 vertical “chains” of horizontally connected displays *(use `regular-pi1` as hardware mapping)*  
 - [Electrodragon RGB HAT](https://www.electrodragon.com/product/rgb-matrix-panel-drive-board-raspberry-pi/) – supports up to 3 vertical “chains”  
 - [Seengreat Matrix Adapter Board](https://amzn.to/3KsnT3j) – single-chain LED Matrix *(use `regular` as hardware mapping)*  
 
 ### LED Matrix Panels  
 (2x in a horizontal chain is recommended)
 - [Adafruit 64×32](https://www.adafruit.com/product/2278) – designed for 128×32 but works with dynamic scaling on many displays (pixel pitch is user preference)
-**Warning: Lately the Waveshare Panels have had different variations - only some are compatible with this project. I hope to identify what is different to fix it but so far there is a decent chance you get a mis-matched set of panels if you don't buy them all at once! **
 - [Waveshare 64×32](https://amzn.to/3Kw55jK) - Does not require E addressable pad
-- [Waveshare 96×48](https://amzn.to/4bydNcv) – higher resolution, requires soldering the **E addressable pad** on the [Adafruit RGB Bonnet](https://www.adafruit.com/product/3211) to “8” **OR** toggling the DIP switch on the Adafruit Triple LED Matrix Bonnet *(no soldering required!)*
-- There are some Panels on Aliexpress that have worked fine for me, shop around! I think Adafruit is probably the "safest" but they do have some limitation on resolution and layout.
-  > Amazon Affiliate Links – ChuckBuilds receives a small commission on purchases  
+- [Waveshare 96×48](https://amzn.to/4bydNcv) – higher resolution, requires soldering the **E addressable pad** on the [Adafruit RGB Bonnet](https://www.adafruit.com/product/3211) to “8” **OR** toggling the DIP switch on the Adafruit Triple LED Matrix Bonnet *(no soldering required!)*  
+  > Amazon Affiliate Link – ChuckBuilds receives a small commission on purchases  
 
 ### Power Supply
 - [5V 4A DC Power Supply](https://www.adafruit.com/product/658) (good for 2 -3 displays, depending on brightness and pixel density, you'll need higher amperage for more)
@@ -177,7 +162,7 @@ The system supports live, recent, and upcoming game information for multiple spo
 
 ## Optional but recommended mod for Adafruit RGB Matrix Bonnet
 - By soldering a jumper between pins 4 and 18, you can run a specialized command for polling the matrix display. This provides better brightness, less flicker, and better color.
-- The default config uses `hardware_mapping` `adafruit-hat`. If you do the mod, change it to `adafruit-hat-pwm` (Display settings in the web interface, or `config.json`)
+- If you do the mod, we will use the default config with led-gpio-mapping=adafruit-hat-pwm, otherwise just adjust your mapping in config.json to adafruit-hat
 - More information available: https://github.com/hzeller/rpi-rgb-led-matrix/tree/master?tab=readme-ov-file
 ![DSC00079](https://github.com/user-attachments/assets/4282d07d-dfa2-4546-8422-ff1f3a9c0703)
 
@@ -254,7 +239,7 @@ These are not required and you can probably rig up something basic with stuff yo
 
 <img width="512" height="361" alt="Step 2 Other " src="https://github.com/user-attachments/assets/166a22e8-8067-48df-9f80-50c91f573356" />
 
-5. Then choose Raspbian OS (64-bit) Lite (Trixie). Bookworm Lite (listed as Legacy) also works; see [Operating system](#operating-system) below
+5. Then choose Raspbian OS (64-bit) Lite (Trixie)
 
 <img width="512" height="361" alt="Step 4 Trixie Lite 64" src="https://github.com/user-attachments/assets/3b8590ce-b810-4dfe-9253-26e0d4f8ed1e" />
 
@@ -329,13 +314,12 @@ curl -fsSL https://raw.githubusercontent.com/ChuckBuilds/LEDMatrix/main/scripts/
 ```
 
 This one-shot installer will automatically:
-- Check system prerequisites (network, disk space, memory, sudo access)
+- Check system prerequisites (network, disk space, sudo access)
 - Install required system packages (git, python3, build tools, etc.)
 - Clone or update the LEDMatrix repository
 - Run the complete first-time installation script
-- Print the web interface address, then **reboot the Pi automatically** (your SSH session will disconnect; give it a few minutes to come back)
 
-The installation process typically takes 10-30 minutes depending on your internet connection and Pi model. Pi 3B/3B+ and other 1GB boards land at the top of that range, because the C++ library is compiled serially to stay within available memory. All errors are reported explicitly with actionable fixes.
+The installation process typically takes 10-30 minutes depending on your internet connection and Pi model. All errors are reported explicitly with actionable fixes.
 
 **Note:** The script is safe to run multiple times and will handle existing installations gracefully.
 
@@ -352,10 +336,10 @@ If you prefer to install manually or the one-shot installer doesn't work for you
 ssh ledpi@ledpi
 ```
 
-2. Update repositories, upgrade Raspberry Pi OS, and install git (`first_time_install.sh` installs the build dependencies itself: `python3-pip`, `python-dev-is-python3`, `build-essential`, `cmake`, `ninja-build` and the rest):
+2. Update repositories, upgrade Raspberry Pi OS, and install prerequisites:
 ```bash
 sudo apt update && sudo apt upgrade -y
-sudo apt install -y git
+sudo apt install -y git python3-pip cython3 build-essential python3-dev python3-pillow scons
 ```
 
 3. Clone this repository:
@@ -372,12 +356,6 @@ sudo bash ./first_time_install.sh
 
 This single script installs services, dependencies, configures permissions and sudoers, and validates the setup.
 
-It finishes by asking whether to reboot. If you run it non-interactively — piped, over a script, or with `-y` — there is no one to ask, so **it reboots immediately without prompting**. Pass `--no-reboot-prompt` to install without rebooting:
-
-```bash
-sudo bash ./first_time_install.sh -y --no-reboot-prompt
-```
-
 </details>
 
 </details>
@@ -393,10 +371,6 @@ sudo bash ./first_time_install.sh -y --no-reboot-prompt
 
 ### Initial Setup
 
-For a complete list of every key in `config.json` and
-`config_secrets.json`, see
-[docs/CONFIG_REFERENCE.md](docs/CONFIG_REFERENCE.md).
-
 For most settings I recommend using the web interface:
 Edit the project via the web interface at http://[IP ADDRESS or HOSTNAME]:5000 or http://ledpi:5000 .
 
@@ -405,7 +379,7 @@ If you need to manually edit your config file, you can follow the steps below:
 <summary>Manual Config.json editing </summary>
 
   1. **First-time setup**:
-     The previous `first_time_install.sh` script should've already copied the template to create your config.json:
+     The previous "First_time_install.sh" script should've already copied the template to create your config.json:
 
   2. **Edit your configuration**: 
    ```bash
@@ -442,7 +416,7 @@ I recommend using the web-ui "Quick Actions" to control the Display.
 ## Plugins
 
 <details>
-LEDMatrix uses a plugin-based architecture where all display functionality is implemented as plugins. All managers that were previously built into the core system are now available as plugins through the Plugin Store.
+LEDMatrix uses a plugin-based architecture where all display functionality (except the core calendar) is implemented as plugins. All managers that were previously built into the core system are now available as plugins through the Plugin Store.
 
 ### Plugin Store
 See the [Plugin Store documentation](https://github.com/ChuckBuilds/ledmatrix-plugins) for detailed installation instructions.
@@ -464,9 +438,9 @@ You can also install plugins directly from GitHub repositories:
 
 See the [Plugin Store documentation](https://github.com/ChuckBuilds/ledmatrix-plugins) for detailed installation instructions.
 
-For plugin development, the `plugins/hello-world/` plugin in the [ledmatrix-plugins](https://github.com/ChuckBuilds/ledmatrix-plugins) repository is a starter template.
+For plugin development, check out the [Hello World Plugin](https://github.com/ChuckBuilds/ledmatrix-hello-world) repository as a starter template.
 
-**Built-in Managers Deprecated**: The built-in managers (hockey, football, stocks, etc.) are now deprecated and have been moved to the plugin system. **You must install replacement plugins from the Plugin Store** in the web interface instead. The plugin system provides the same functionality with better maintainability and extensibility.
+2. **Built-in Managers Deprecated**: The built-in managers (hockey, football, stocks, etc.) are now deprecated and have been moved to the plugin system. **You must install replacement plugins from the Plugin Store** in the web interface instead. The plugin system provides the same functionality with better maintainability and extensibility.
 </details>
 
 ## Detailed Information
@@ -481,10 +455,6 @@ If you are copying my exact setup, you can likely leave the defaults alone. Howe
 
 The display settings are located in `config/config.json` under the `"display"` key and are organized into three main sections: `hardware`, `runtime`, and `display_durations`.
 
-The defaults below are the values in `config/config.template.json`. They are what applies when you haven't set a key: on every load, LEDMatrix adds any key your `config.json` lacks from the template, so `DisplayManager`'s own fallbacks are never reached on a normal install.
-
-The web UI and the config API refuse values the rgbmatrix library can't start with. If one is written into `config.json` by hand anyway, the display logs which setting it is (`Failed to initialize RGB Matrix` in `sudo journalctl -u ledmatrix`), runs in fallback mode, and the Display tab shows the message.
-
 ### Hardware Configuration (`display.hardware`)
 
 These settings control the physical hardware configuration and how the matrix is driven.
@@ -494,18 +464,15 @@ These settings control the physical hardware configuration and how the matrix is
 - **`rows`** (integer, default: 32)
   - Number of LED rows (vertical pixels) in each panel
   - Common values: 16, 32, 48, 64
-  - An even number from 8 to 64, the most the rgbmatrix library drives per panel
   - Must match your physical panel configuration
 
 - **`cols`** (integer, default: 64)
   - Number of LED columns (horizontal pixels) in each panel
   - Common values: 32, 64, 96, 128
-  - At least 16, with no upper limit
   - Must match your physical panel configuration
 
 - **`chain_length`** (integer, default: 2)
   - Number of LED panels chained together horizontally
-  - 1 to 255 (the library's Python binding stores it in one byte); longer chains lower the refresh rate
   - If you have 2 panels side-by-side, set to 2
   - If you have 4 panels in a row, set to 4
   - Total display width = `cols × chain_length`
@@ -514,70 +481,68 @@ These settings control the physical hardware configuration and how the matrix is
   - Number of parallel chains (panels stacked vertically)
   - Use 1 for a single row of panels
   - Use 2 if you have panels stacked in two rows
-  - 1–3, and no more than your `hardware_mapping` has outputs: `regular` and `classic` have 3 (e.g. the Adafruit Triple LED Matrix Bonnet); `adafruit-hat`, `adafruit-hat-pwm`, `regular-pi1` and `classic-pi1` have 1. The library stops the display service outright on a mismatch, so it is refused
   - Total display height = `rows × parallel`
 
 #### Brightness and Visual Settings
 
-- **`brightness`** (integer, 1-100, default: 90)
+- **`brightness`** (integer, 0-100, default: 90)
   - Display brightness level
-  - Lower values (1-50) are dimmer, higher values (50-100) are brighter
+  - Lower values (0-50) are dimmer, higher values (50-100) are brighter
   - Recommended: 70-90 for indoor use, 90-100 for bright environments
   - Very high brightness may cause distortion or require more power
 
 #### Hardware Mapping
 
-- **`hardware_mapping`** (string, default: "adafruit-hat")
+- **`hardware_mapping`** (string, default: "adafruit-hat-pwm")
   - Specifies which GPIO pin mapping to use for your hardware
   - **`"adafruit-hat-pwm"`**: Use this for Adafruit RGB Matrix Bonnet/HAT WITH the jumper mod (PWM enabled). This is the recommended setting for Adafruit hardware with the PWM jumper soldered.
   - **`"adafruit-hat"`**: Use this for Adafruit RGB Matrix Bonnet/HAT WITHOUT the jumper mod (no PWM). Remove `-pwm` from the value if you did not solder the jumper.
-  - **`"regular"`**: Standard GPIO pin mapping for direct GPIO connections (Generic). Also the right choice for the Adafruit Triple LED Matrix Bonnet
+  - **`"regular"`**: Standard GPIO pin mapping for direct GPIO connections (Generic)
   - **`"regular-pi1"`**: Standard GPIO pin mapping for Raspberry Pi 1 (older hardware or non-standard hat mapping)
-  - **`"classic"`** / **`"classic-pi1"`**: the library's original pin-outs, for old adapter boards wired to them. Not used by current HATs
-  - Any other name is refused. `compute-module` is only compiled in when the library is built with `ENABLE_WIDE_GPIO_COMPUTE_MODULE`, which the installer doesn't do. On a Raspberry Pi 5, `classic-pi1` isn't supported
   - Choose the option that matches your specific hardware setup, if aren't sure try them all.
-  - Hardware pulsing (see `disable_hardware_pulsing`) needs the panel's OE line on GPIO 18, which `adafruit-hat-pwm` and `regular` provide and `adafruit-hat` does not
 
 #### PWM (Pulse Width Modulation) Settings
 
 These settings affect color fidelity and smoothness of color transitions:
 
-- **`pwm_bits`** (integer, 1-11, default: 9)
-  - Color depth per channel: how many brightness levels each LED gets
-  - Higher values (9-11) = more color levels, smoother gradients, lower refresh rate
-  - Lower values (7-8) = the subtlest shades are dropped for a higher refresh rate; `1` gives 8 colors
-  - Recommended: 9-10
+- **`pwm_bits`** (integer, default: 9)
+  - Number of bits used for PWM (affects color depth)
+  - Higher values (9-11) = more color levels, smoother gradients
+  - Lower values (7-8) = fewer color levels, but may improve stability on some hardware
+  - Range: 1-11, recommended: 9-10
 
-- **`pwm_dither_bits`** (integer, 0-2, default: 1)
-  - Time-dithers the lowest color bits: their brightness comes from showing them on only some frames
-  - Raises the refresh rate; the cost is that dark shades can shimmer slightly
-  - `0` = steadiest dim colors, `2` = fastest
-  - The rgbmatrix library accepts only 0-2; a higher value stops the display starting
+- **`pwm_dither_bits`** (integer, default: 1)
+  - Additional dithering bits for smoother color transitions
+  - Helps reduce color banding in gradients
+  - Higher values (1-2) = smoother gradients but may impact performance
+  - Range: 0-2, recommended: 1
 
-- **`pwm_lsb_nanoseconds`** (integer, 50-3000, default: 130)
-  - On-time of the least significant color bit; each higher bit doubles it
-  - Lower values = higher refresh rate, but can cost color accuracy or add ghosting on some panels
-  - Higher values = less ghosting (faint trails behind bright text on black), lower refresh rate
+- **`pwm_lsb_nanoseconds`** (integer, default: 130)
+  - Least significant bit timing in nanoseconds
+  - Controls the base timing for PWM signals
+  - Lower values = faster PWM, higher values = slower PWM
   - Typical range: 100-300 nanoseconds
+  - May need adjustment if you see flickering or color issues
 
 #### Advanced Hardware Settings
 
-- **`scan_mode`** (integer, 0-1, default: 0)
-  - Order the rows are refreshed in: `0` = progressive, `1` = interlaced
-  - Interlaced can look a little smoother when the refresh rate is very low, but usually shows a comb effect on anything moving
-  - Leave at `0` unless you are tuning a slow setup
+- **`scan_mode`** (integer, default: 0)
+  - Panel scan mode (how rows are addressed)
+  - Common values: 0 (progressive), 1 (interlaced)
+  - Most panels use 0, but some require 1
+  - Check your panel datasheet if colors appear incorrect
 
 - **`limit_refresh_rate_hz`** (integer, default: 100)
-  - Caps the panel refresh rate in Hz; `0` = no cap
-  - A steady cap reduces flicker caused by other activity on the Pi, and in camera recordings
-  - Scroll speeds are worked out against this value (against 100 Hz when it is `0`), so a cap the panel can actually hold keeps scrolling even
-  - Recommended: 80-120. `sudo python3 scripts/scroll_speeds.py --measure` reports the rate your panel really achieves
+  - Maximum refresh rate in Hz (frames per second)
+  - Caps the refresh rate for better stability
+  - Lower values (60-80) = more stable, less CPU usage
+  - Higher values (100-120) = smoother animations, more CPU usage
+  - Recommended: 80-100 for most setups
 
 - **`disable_hardware_pulsing`** (boolean, default: false)
-  - `false` = the Pi's hardware PWM times each brightness pulse; `true` = software timing
-  - Leave `false` where possible. Software timing is less exact, so a row, or the whole panel, can briefly flash brighter
-  - Hardware pulsing needs the panel's OE line on GPIO 18 (`adafruit-hat-pwm`, `regular`, the Adafruit Triple LED Matrix Bonnet). With `adafruit-hat` the library uses software timing anyway
-  - It also needs the Pi's onboard sound driver (`snd_bcm2835`) disabled, which `first_time_install.sh` does. Set `true` only if you need the Pi's own audio
+  - Disables hardware pulsing (usually leave as false)
+  - Set to `true` only if you experience timing issues
+  - Most users should leave this as `false`
 
 - **`inverse_colors`** (boolean, default: false)
   - Inverts all colors (red becomes cyan, etc.)
@@ -585,9 +550,9 @@ These settings affect color fidelity and smoothness of color transitions:
   - Set to `true` only if colors appear inverted
 
 - **`show_refresh_rate`** (boolean, default: false)
-  - Prints the live refresh rate to the console; nothing is drawn on the panel
-  - Readable when you stop the service and run `sudo python3 run.py` in a terminal; under the service the output is buffered
-  - `sudo python3 scripts/scroll_speeds.py --measure` is an easier way to see the real refresh rate
+  - Displays the current refresh rate on the matrix (for debugging)
+  - Set to `true` to see FPS on the display
+  - Useful for troubleshooting performance issues
 
 #### Advanced Panel Configuration (Advanced Users Only)
 
@@ -597,7 +562,6 @@ These settings are typically only needed for non-standard panels or custom confi
   - Color channel order for your LED panel
   - Common values: "RGB", "RBG", "GRB", "GBR", "BRG", "BGR"
   - Most panels use "RGB", but some use "GRB" or other orders
-  - If red shows as blue, try "BGR" (the Waveshare 96x48 V2 needs it)
   - Check your panel datasheet if colors appear wrong
 
 - **`pixel_mapper_config`** (string, default: "")
@@ -607,76 +571,40 @@ These settings are typically only needed for non-standard panels or custom confi
   - Leave empty unless you need custom mapping
   - See rpi-rgb-led-matrix documentation for full options
 
-- **`orientation`** (string, default: "normal")
-  - Rotates the rendered image to match how the panel is physically mounted
-  - Set to `"180"` (or use the "Upside Down" option in the web UI's Display
-    settings) if the panel is mounted upside down — useful for optimizing
-    where the Raspberry Pi and wiring sit relative to the mounting location
-  - `"90"` and `"270"` are for a panel mounted on its side; they swap the
-    display's width and height
-  - Applied independently of `pixel_mapper_config` (appended as a trailing
-    `Rotate:<degrees>` mapper), so custom mapper configs keep working alongside it
-
 - **`row_address_type`** (integer, default: 0)
   - How rows are addressed on the panel
   - Most panels use 0 (direct addressing)
-  - 1 = AB-addressed, 2 = direct row select, 3 = ABC-addressed,
-    4 = ABC shift + DE direct (SM5266), 5 = SM5368 / B707 row shift register
-  - ABC panels (no E line, e.g. many 128x64 FM6124 panels) use 3
-  - Panels with SM5368 row drivers use 5 with `led_rgb_sequence` `"BGR"` —
-    e.g. the Waveshare 96x48 V2 (back silkscreen `24S-A1`; the V1, `24S-A2.1`,
-    uses the defaults). This is what Waveshare's `96X48_1_24_SM5368` panel
-    type sets in their library fork.
-  - SM5368 row drivers are timing-sensitive: if rows jump up and down or the
-    bottom row shows a copy of other rows, raise `gpio_slowdown`. On a Pi 4
-    with an Adafruit Triple LED Matrix Bonnet, 4 left rows jumping; 6–8 gave a
-    stable image.
-  - On a Raspberry Pi 5 the rgbmatrix library currently supports only 0 and 2
-    (and `parallel` 1-3). Anything else would crash the display service, so on
-    a Pi 5 the web UI offers only 0 and 2, the config API refuses the others,
-    and if one is set in `config.json` anyway the display logs why and runs in
-    fallback mode
+  - Some panels require 1 (AB addressing) or 2 (ABC addressing)
   - Check your panel datasheet if display appears corrupted
 
-- **`multiplexing`** (integer, 0-22, default: 0)
-  - How pixels are wired on outdoor/specialty panels (P10, P8, P4 and P3 outdoor modules and similar) whose LEDs aren't laid out in straight rows
-  - `0` = direct (standard indoor panels)
-  - `1` Stripe, `2` Checkered, `3` Spiral, `4` ZStripe, `5` ZnMirrorZStripe,
-    `6` Coreman, `7` Kaler2Scan, `8` ZStripeUneven, `9` P10-128x4-Z,
-    `10` QiangLiQ8, `11` InversedZStripe, `12`–`14` P10Outdoor1R1G1B v1–v3,
-    `15` P10CoremanMapper, `16` P8Outdoor1R1G1B, `17` FlippedStripe,
-    `18` P10-32x16-HalfScan, `19` P10-32x16-QuarterScan, `20` P3Outdoor-64x64,
-    `21` DoubleZMultiplex, `22` P4Outdoor-80x40
-  - If the image is scrambled in a repeating pattern, try the value named after your panel first
-
-- **`panel_type`** (string, default: `""`)
-  - Sends a start-up initialization sequence to driver chips that need one
-  - `""` = Standard (no initialization) — right for most panels, including FM6124 / FM6124D / FM6124DJ
-  - `"FM6126A"` or `"FM6127"` for panels with those chips; try `"FM6126A"` if the panel stays dark or lights only the first pixel on Standard
+- **`multiplexing`** (integer, default: 0)
+  - Panel multiplexing type
+  - 0 = no multiplexing (standard panels)
+  - Higher values for panels with different multiplexing schemes
+  - Check your panel datasheet for the correct value
 
 ### Runtime Configuration (`display.runtime`)
 
 These settings control runtime behavior and GPIO timing:
 
 - **`gpio_slowdown`** (integer, default: 3)
-  - GPIO timing slowdown factor (0-10): slows GPIO writes so the panel electronics keep up. Higher is more reliable but lowers the refresh rate
-  - **Critical setting**: depends on your Raspberry Pi model and your panel
-  - **Raspberry Pi Zero/1**: 0-1
-  - **Raspberry Pi 2/3**: 1-3
-  - **Raspberry Pi 4**: 2-4 (the config template ships 3)
-  - **Raspberry Pi 5**: 1–3 in PIO mode (`rp1_rio: 0`, the default). Start at `1` (the library treats `0` as `1` there) and raise it a step at a time if the image flickers or shows garbage — chained panels are the likeliest to need it
-  - Panels on `row_address_type` 5 (SM5368 row drivers) can need 6-8 on a Pi 4
-  - Too low: garbage, flicker or rows jumping. Too high: a lower refresh rate
+  - GPIO timing slowdown factor
+  - **Critical setting**: Must match your Raspberry Pi model for stability
+  - **Raspberry Pi 3**: Use 3
+  - **Raspberry Pi 4**: Use 4
+  - **Raspberry Pi 5**: Use 1–2 in PIO mode (`rp1_rio: 0`, the default); start with `1` and increase if you see flickering
+  - **Raspberry Pi Zero/1**: Use 1-2
+  - Incorrect values can cause display corruption, flickering, or system instability
   - If you experience issues, try adjusting this value up or down by 1
 
-- **`rp1_rio`** (integer, 0 or 1, default: 0) — Raspberry Pi 5 only
-  - Which driver the Pi 5's RP1 chip uses: `0` = PIO (default, less CPU), `1` = RIO (registered I/O, can reach a higher refresh rate)
-  - In RIO mode the effect of `gpio_slowdown` is inverted: higher values may be faster
-  - Ignored on a Pi 0-4, and applied only if the installed rgbmatrix library supports it
-
 ### Display Durations (`display.display_durations`)
 
-Controls how long each installed plugin stays visible in seconds before switching to the next one, keyed by plugin id.
+Controls how long each display module stays visible in seconds before switching to the next one.
+
+- **`calendar`** (integer, default: 30)
+  - Duration in seconds for the calendar display
+  - Increase for more time to read dates/events
+  - Decrease to cycle through other displays faster
 
 - **Plugin-specific durations**
   - Each plugin can have its own duration setting
@@ -695,10 +623,9 @@ Controls how long each installed plugin stays visible in seconds before switchin
 ### Display Format Settings
 
 - **`use_short_date_format`** (boolean, default: true)
-  - Currently has no effect. The web UI still saves it, but no core code
-    reads it. Scoreboard plugins that offer a short date format read the
-    setting from their own plugin config instead. See
-    [CONFIG_REFERENCE.md](docs/CONFIG_REFERENCE.md#display--other-keys).
+  - Use short date format (e.g., "Jan 15") instead of long format (e.g., "January 15th")
+  - Set to `false` for longer, more readable dates
+  - Set to `true` to save space and show more information
 
 ### Dynamic Duration Settings (`display.dynamic_duration`)
 
@@ -707,7 +634,7 @@ Controls how long each installed plugin stays visible in seconds before switchin
   - Some plugins can automatically adjust their display time based on content
   - This setting limits how long they can extend (prevents one display from dominating)
   - Example: If set to 60, a plugin can extend up to 60 seconds even if it requests longer
-  - Leave unset to use the default cap (180 seconds; the web UI accepts 30-1800)
+  - Leave unset to use the default cap (typically 90 seconds)
 
 ### Example Configuration
 
@@ -754,14 +681,6 @@ Controls how long each installed plugin stays visible in seconds before switchin
 - Verify `hardware_mapping` matches your HAT/connection type
 - Try adjusting `gpio_slowdown`
 - Ensure your display doesn't need the E-Addressable line
-- If it went blank right after a settings change, the Display tab shows a "simulation mode" banner, and `sudo journalctl -u ledmatrix` shows `Failed to initialize RGB Matrix` followed by the reason. When LEDMatrix refused the settings (for example more than 64 `rows`, `parallel` 2 on an `adafruit-hat` mapping, a misspelled `hardware_mapping`, or on a Raspberry Pi 5 a `row_address_type` other than 0 or 2), the message names each one: change them, save, and restart the display service. Otherwise the library itself failed, and its own message just before names the problem
-- A repeating scramble points at `row_address_type` or `multiplexing`; a panel that stays dark, at `panel_type`
-
-**Rows jump up and down, or the bottom row repeats other rows:**
-- Raise `gpio_slowdown` a step at a time (SM5368 panels on `row_address_type` 5 can need 6-8 on a Pi 4)
-
-**A row or the whole panel briefly flashes brighter:**
-- Set `disable_hardware_pulsing` to `false` (needs the OE line on GPIO 18; see `hardware_mapping`)
 
 **Colors are wrong or inverted:**
 - Check `led_rgb_sequence` (try "GRB" if "RGB" doesn't work)
@@ -786,21 +705,15 @@ Controls how long each installed plugin stays visible in seconds before switchin
 <details>
 <summary>Manual SSH Commands (for reference)</summary>
 
-The web interface's quick actions (Start/Stop/Restart Display) call
-`sudo systemctl start|stop|restart ledmatrix.service` — see
-`execute_system_action()` in
-[`web_interface/blueprints/api_v3/system.py`](web_interface/blueprints/api_v3/system.py).
-The service runs [`run.py`](run.py) as root.
+The quick actions essentially just execute the following commands on the Pi.
 
-To run the display in the foreground instead (for debugging), stop the service
-first, then from the project root (e.g. `/home/ledpi/LEDMatrix`):
+From the project root directory (ex: /home/ledpi/LEDMatrix):
 
 ```bash
-sudo systemctl stop ledmatrix.service
-sudo python3 run.py          # add -d for debug logging
+sudo python3 display_controller.py
 ```
 
-This only runs as long as your SSH session stays open.
+This will start the display cycle but only stays active as long as your ssh session is active.
 
 ### Convenience Scripts
 
@@ -842,11 +755,9 @@ sudo ./scripts/install/install_service.sh
 
 The script will:
 - Detect your user account and home directory
-- Install `ledmatrix.service` (display, runs as root), `ledmatrix-web.service`
-  (web interface, runs as your user) and the `ledmatrix-update-verify` units,
-  with the correct paths
-- Enable them to start on boot
-- Start them immediately
+- Install the service file with the correct paths
+- Enable the service to start on boot
+- Start the service immediately
 
 ### Managing the Service
 
@@ -953,7 +864,7 @@ sudo systemctl enable ledmatrix-web.service
 - **On-Demand Controls**: Start specific displays (weather, stocks, sports) on demand
 - **Service Management**: Start/stop the main display service
 - **System Controls**: Restart, update code, and manage the system
-- **System Stats**: CPU, memory and temperature on the Overview tab
+- **API Metrics**: Monitor API usage and system performance
 - **Logs**: View system logs in real-time
 
 ### Troubleshooting Web Interface
@@ -970,10 +881,9 @@ sudo systemctl enable ledmatrix-web.service
 3. Check if another service is using port 5000
 
 **Service Fails to Start:**
-1. Check Python dependencies are installed. The installer puts them in the
-   system Python with `pip install --break-system-packages` (there is no
-   virtual environment), so `python3 -c "import flask"` should succeed.
-2. Check file permissions and ownership
+1. Check Python dependencies are installed
+2. Verify the virtual environment is set up correctly
+3. Check file permissions and ownership
 
 </details>
 

SECURITY.md

@@ -16,7 +16,7 @@ Use one of these channels, in order of preference:
    maintainer.
    - Direct link: <https://github.com/ChuckBuilds/LEDMatrix/security/advisories/new>
 2. **Discord DM**. Send a direct message to a moderator on the
-   [LEDMatrix Discord](https://discord.gg/RdrC37rEag). Don't post in
+   [LEDMatrix Discord](https://discord.gg/uW36dVAtcT). Don't post in
    public channels.
 
 Please include:
@@ -61,31 +61,8 @@ Out of scope (please report upstream):
 LEDMatrix is designed for trusted local networks. Several limitations
 are intentional rather than vulnerabilities:
 
-- **Web UI authentication is optional and off by default.** Out of the
-  box the web interface assumes the network it's running on is trusted.
-  Setting a password under **General > Security** makes every page and
-  API route require a login or an API token (`Authorization: Bearer`),
-  with wrong passwords rate-limited per address
-  (`web_interface/auth.py`). Deliberately left open even then: requests
-  from the Pi itself (loopback without proxy headers; a reverse proxy on
-  the Pi must add `X-Forwarded-For`, or every request it relays counts as
-  local), the Wi-Fi setup flow while the Pi is in access-point mode,
-  static files, and a status-only `/api/v3/health`. The password is a
-  werkzeug hash and tokens are stored as SHA-256, in
-  `config/config_secrets.json`, which no API returns. There is no TLS:
-  over plain HTTP the password and tokens cross the LAN in the clear, so
-  still don't expose port 5000 to the internet; put a TLS reverse proxy
-  or a VPN in front for remote access. Anyone with shell access to the Pi
-  can turn login off (`scripts/reset_web_password.py`), which is the
-  documented recovery path.
-  "Trusted network" does not mean "trusted websites", though: any page
-  a LAN user opens could make their browser POST to the Pi. So the
-  interface refuses a `POST`/`PUT`/`PATCH`/`DELETE` whose `Origin` (or
-  `Referer`) header names another site (`web_interface/origin_guard.py`),
-  and `/api/v3/system/action` only accepts JSON or HTMX requests. Tools
-  that send neither header (curl, Home Assistant, the MQTT bridge) are
-  unaffected. Not covered: DNS rebinding, and anyone who can reach the
-  port directly.
+- **No web UI authentication.** The web interface assumes the network
+  it's running on is trusted. Don't expose port 5000 to the internet.
 - **Plugins run unsandboxed.** Installed plugins execute in the same
   Python process as the display loop with full file-system and
   network access. Review plugin code (especially third-party plugins

assets/README.md

@@ -1,22 +0,0 @@
-# assets/
-
-Static assets bundled with LEDMatrix. **Do not delete these directories** —
-several look unused from core code alone but are resolved at runtime by
-installed store plugins.
-
-| Directory | Used by |
-|---|---|
-| `fonts/` | Core (`FontManager`, `DisplayManager`) and most plugins |
-| `sports/` | Core logo tooling (`src/logo_downloader.py`) and the sports scoreboard plugins; team logos are downloaded here on demand |
-| `stocks/` | `ledmatrix-stocks` plugin (`crypto_icons/`, `ticker_icons/`) |
-| `weather/` | `ledmatrix-weather` plugin (weather icons) |
-| `news_logos/` | `news` plugin |
-| `broadcast_logos/` | `news` and `odds-ticker` plugins |
-| `static_images/` | Legacy examples referenced in the `static-image` plugin's docs; the plugin itself stores uploads under `assets/plugins/<plugin-id>/uploads/` |
-| `plugins/` | Per-plugin uploaded files (`assets/plugins/<plugin-id>/uploads/`), served by the web interface |
-
-Plugins resolve these paths relative to the LEDMatrix install directory, so
-the directories are part of the de-facto plugin API even where no file in
-this repo references them. New plugins should bundle their own assets or
-use the per-plugin upload directory instead of adding top-level
-directories here.

bandit.yaml

@@ -1,29 +0,0 @@
-# bandit.yaml — LEDMatrix bandit configuration
-# https://bandit.readthedocs.io/en/latest/config.html
-#
-# Skips are justified by the specific codebase context documented below.
-# Do not remove skips without updating the justification comment.
-
-skips:
-  # B104: Binding to all interfaces (0.0.0.0)
-  # Intentional — the Flask server binds 0.0.0.0 for LAN access on a Raspberry Pi.
-  # This is not internet-facing and is documented in web_interface/app.py.
-  - B104
-
-  # B603: subprocess call without shell=True
-  # All subprocess.run() calls in this codebase use list arguments (confirmed by
-  # grep — zero uses of shell=True in src/ or web_interface/). List args prevent
-  # shell injection. See src/common/permission_utils.py for the primary usage.
-  - B603
-
-  # B607: Starting a process with a partial executable path
-  # The subprocess calls invoke system utilities (systemctl, sudo, git) by name.
-  # These are fixed-list invocations, not user-controlled, and rely on PATH.
-  - B607
-
-exclude_dirs:
-  - tests
-  - test
-  - venv
-  - .venv
-  - rpi-rgb-led-matrix-master

config/config.template.json

@@ -1,9 +1,5 @@
 {
     "web_display_autostart": true,
-    "auto_update": {
-        "enabled": false,
-        "channel": "stable"
-    },
     "schedule": {
         "enabled": false,
         "mode": "per-day",
@@ -92,7 +88,6 @@
         }
     },
     "timezone": "America/New_York",
-    "target_fps": 100,
     "location": {
         "city": "Tampa",
         "state": "Florida",
@@ -114,12 +109,7 @@
             "inverse_colors": false,
             "show_refresh_rate": false,
             "led_rgb_sequence": "RGB",
-            "limit_refresh_rate_hz": 100,
-            "pixel_mapper_config": "",
-            "orientation": "normal",
-            "row_address_type": 0,
-            "multiplexing": 0,
-            "panel_type": ""
+            "limit_refresh_rate_hz": 100
         },
         "runtime": {
             "gpio_slowdown": 3,
@@ -131,39 +121,15 @@
             "axis": "horizontal"
         },
         "display_durations": {},
-        "plugin_rotation_order": [],
         "use_short_date_format": true,
         "vegas_scroll": {
-            "live_in_ticker": true,
-            "live_weight": 3,
-            "favorite_live_weight": 5,
             "enabled": false,
             "scroll_speed": 50,
             "separator_width": 32,
             "plugin_order": [],
             "excluded_plugins": [],
             "target_fps": 125,
-            "buffer_ahead": 2,
-            "intra_plugin_gap": 8,
-            "render_width_pct": 100,
-            "min_content_separation": 24,
-            "min_cut_gap": 6,
-            "continuous_scroll": true,
-            "smooth_scroll": true,
-            "extend_threshold_screens": 2.0,
-            "auto_trim": true,
-            "trim_threshold": 10,
-            "content_padding": 8,
-            "min_plugin_width": 8,
-            "lead_in_width": 0,
-            "plugins_per_cycle": 6,
-            "max_plugin_width_ratio": 0.0,
-            "overflow_mode": "rotate",
-            "dynamic_duration_enabled": true,
-            "min_cycle_duration": 60,
-            "max_cycle_duration": 240,
-            "frame_based_scrolling": true,
-            "scroll_delay": 0.02
+            "buffer_ahead": 2
         }
     },
     "sync": {
@@ -172,17 +138,9 @@
         "follower_position": "left"
     },
     "plugin_system": {
-        "plugins_directory": "plugin-repos"
-    },
-    "fetch_service": {
-        "enabled": true,
-        "max_wait_seconds": 2,
-        "rate_limits": {
-            "*.espn.com": {
-                "per_second": 20,
-                "burst": 200
-            }
-        }
+        "plugins_directory": "plugin-repos",
+        "auto_discover": true,
+        "auto_load_enabled": true
     },
     "web-ui-info": {
         "enabled": true,

config/config_secrets.template.json

@@ -1,5 +1,9 @@
 {
+    "youtube": {
+        "api_key": "YOUR_YOUTUBE_API_KEY",
+        "channel_id": "YOUR_YOUTUBE_CHANNEL_ID"
+    },
     "github": {
         "api_token": "YOUR_GITHUB_PERSONAL_ACCESS_TOKEN"
     }
-}
+}

dev_plugins.json.example

@@ -1,6 +0,0 @@
-{
-  "dev_plugins_dir": "~/.ledmatrix-dev-plugins",
-  "github_user": "ChuckBuilds",
-  "plugins_repo": "ledmatrix-plugins",
-  "plugins_branch": "main"
-}

display_controller.py

@@ -1,20 +1,12 @@
 #!/usr/bin/env python3
-"""Legacy entry point: runs ``run.py``, which is the one to use.
-
-``python3 run.py`` (``-e`` for the emulator, ``-d`` for debug logging) is how
-the display service and the docs start LEDMatrix. This file used to import
-``src.display_controller.main`` directly, which skipped what run.py sets up
-first -- ``sys.dont_write_bytecode`` (root-owned ``__pycache__`` in plugin
-directories blocks the web service from updating them), the ``-e``/``-d``
-flags, and the logging configuration. It now runs run.py exactly as
-``python3 run.py`` would, with the same arguments.
-"""
 
 import os
-import runpy
+import sys
+
+# Add the project root directory to Python path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from src.display_controller import main
 
 if __name__ == "__main__":
-    runpy.run_path(
-        os.path.join(os.path.dirname(os.path.abspath(__file__)), "run.py"),
-        run_name="__main__",
-    )
+    main() 

docs/ADAPTIVE_LAYOUT.md

@@ -1,234 +0,0 @@
-# Adaptive Layout & Font Scaling
-
-`src/adaptive_layout.py` lets a plugin render legibly on **any** panel size
-(64x32, 128x32, 96x48, 128x64, 256x64, ...) without hand-tuned per-display
-layouts. It is **opt-in**: nothing changes for plugins that don't use it.
-
-It generalizes three patterns proven in the plugin ecosystem:
-
-| Pattern | Origin | Core API |
-|---|---|---|
-| Geometry scale factor vs. a design size | f1-scoreboard | `ctx.px(base)` / `ctx.scale` |
-| Breakpoint tiers | masters-tournament | `ctx.tier` / `ctx.by_tier({...})` |
-| "Largest crisp font that fits" ladder | baseball-scoreboard | `ctx.fit_text(...)` and friends |
-
-## Quick start
-
-Every `BasePlugin` has a lazy `self.layout` (a `LayoutContext` for the
-current logical display size, rebuilt automatically if the size changes)
-and a one-liner `self.draw_fit(...)`:
-
-```python
-def display(self, force_clear=False):
-    from src.adaptive_layout import LADDER_ARCADE
-
-    b = self.layout.bounds.inset(1)          # Region(0,0,W,H) minus 1px margin
-    rows = b.split_v(3, 1, 1, gap=1)          # 3/5 for time, 1/5 each for the rest
-
-    self.draw_fit(self.time_str, rows[0], ladder=LADDER_ARCADE)
-    self.draw_fit(self.weekday, rows[1])      # default LADDER_GRID
-    self.draw_fit(self.date_str, rows[2])
-    self.display_manager.update_display()
-```
-
-On 128x64 the time renders at press_start 24px; on 64x32 it steps down to
-8px. The rows partition the height, so bands can never overlap — no more
-`y = height - 7` magic numbers.
-
-## Region — rect algebra
-
-`Region(x, y, w, h)` is a frozen dataclass. All carving clamps to
-non-negative dimensions, so degenerate panels behave.
-
-- Carving: `inset(dx, dy)`, `top_band(h)`, `bottom_band(h)`,
-  `middle(top_h, bottom_h)`, `left_col(w)`, `right_col(w)`,
-  `split_h(*weights, gap=0)`, `split_v(*weights, gap=0)`
-- Placement: `align_xy(w, h, align, valign)`, `center_xy(w, h)`,
-  `contains(w, h)`, `.center`, `.right`, `.bottom`
-
-Scoreboard-style layout:
-
-```python
-b = self.layout.bounds
-status = b.top_band(self.layout.px(7))
-detail = b.bottom_band(self.layout.px(7))
-score_area = b.middle(status.h, detail.h)
-away_slot, home_slot = b.left_col(b.h), b.right_col(b.h)
-```
-
-## Font ladders — discrete, never fractional
-
-Pixel fonts (BDF, PressStart2P) only look right at native/integer sizes, so
-fonts are never scaled continuously. A `FontLadder` is an ordered tuple of
-`FontStep(family, size_px)` rungs, largest first; fitting walks down until
-the measured text fits.
-
-- `LADDER_GRID` (default): X11 BDFs at native sizes — 10x20 → 9x18 → 9x15 →
-  8x13 → 7x13 → 6x13 → 6x12 → 6x10 → 6x9 → 5x8 → 5x7 → 4x6 → tom-thumb.
-  Body text, labels, multi-row content.
-- `LADDER_ARCADE`: PressStart2P at 32/24/16/8 (integer multiples of its 8px
-  grid). Headline text: clocks, scores.
-
-Custom ladders are just tuples — e.g. to add your plugin's registered font
-on top: `(FontStep("myplugin::digits", 16),) + LADDER_GRID`.
-
-## LayoutContext
-
-Built per (width, height); exposes facts and fit queries:
-
-- `bounds`, `width`, `height`, `aspect`
-- `tier` by height (`xs`≤16, `sm`≤32, `md`≤48, `lg`≤64, `xl`) and
-  `width_tier` (`narrow`≤64, `normal`≤128, `wide`≤256, `ultrawide`)
-- `is_wide_short` — aspect ≥ 2.5 and height ≤ 32 (the classic 128x32 shape)
-- `scale` — `min(w/design_w, h/design_h)` vs. your manifest's
-  `display.design_size` (default 128x32). **Geometry only** — gaps, icon
-  and logo sizes via `px(base, minimum, maximum)`; fonts use ladders.
-- `by_tier({"sm": 10, "lg": 18})` — value for the nearest defined tier
-  at-or-below the panel's tier.
-- `fit_text(text, box, ladder, ellipsis=True)` → `FitResult` — largest rung
-  that fits; ellipsizes as a last resort. Cached per (text, box, ladder).
-- `fit_text_proportional(text, box, base_size_px, ladder, ellipsis=True, scale=None)` —
-  rung closest to (not exceeding) `base_size_px * scale`, still capped to
-  what fits the box. Use this instead of `fit_text` when several
-  independently-fitted elements need to stay visually harmonious as the
-  panel grows — `fit_text` maximizes *each one* within its own region,
-  which can make one element (e.g. a score with a generous box) balloon
-  out of proportion to a neighbor that scales by geometry (e.g. logos
-  sized via `px()`), even though each individual pick is "correct" in
-  isolation. `base_size_px` is normally the element's existing classic/
-  fixed font size. `scale` defaults to `self.scale` (the conservative
-  min-of-both-axes factor `px()` uses); pass an axis-specific value when
-  the surrounding composition already scales that way — e.g. a scoreboard
-  whose logo slots track height alone (`min(height, width // 2)`) should
-  size its text by `height / design_height` too, or the text reads as
-  under-scaled next to bigger logos on a panel that only grew taller.
-- `fit_lines(lines, box, ladder, spacing)` — every line fits the width and
-  the stack fits the height (measures the actual strings).
-- `font_for_rows(rows, box_h, ladder)` — largest rung whose line height
-  fits `rows` rows.
-
-`FitResult` carries the ready-to-use `font` (drops straight into
-`display_manager.draw_text(font=...)`), the possibly-ellipsized `text`,
-ink `width`/`height`, `baseline`, `y_offset`, `line_height`, and `fits`.
-
-## Adaptive images
-
-`src/adaptive_images.py` is the image counterpart to `fit_text`, exposed as
-`self.layout.fit_image(...)` (cached per panel size) and the one-liner
-`self.draw_image(...)`:
-
-```python
-# Team logo: trim its transparent padding, fill the slot height (the
-# football/hockey pattern), cached across frames by a stable key
-self.draw_image(logo, regs.away_slot, mode="fill_height",
-                crop_to_ink=True, cache_key=f"logo:{abbr}")
-
-# Album art: cover-crop a square, faces kept by the top anchor
-self.draw_image(art, row.art, mode="cover", anchor="top")
-
-# Pixel flags / sprite icons: NEAREST keeps hard edges
-from src.adaptive_images import RESAMPLE_NEAREST
-self.draw_image(flag, box, resample=RESAMPLE_NEAREST)
-```
-
-Modes: `contain` (letterbox, default), `cover` (crop-to-fill),
-`fill_height` (logo-style), `stretch`. Unlike PIL's `thumbnail()`
-(downscale-only — why imagery stays tiny on big panels) fitting **upscales
-by default**; pass `upscale=False` for the legacy behavior. Results are
-cached per (image, box size, options) with a bounded LRU — always pass a
-stable `cache_key` (e.g. `"logo:KC"`) for images you reload. The module
-also exports the Pillow-compat `RESAMPLE_LANCZOS`/`RESAMPLE_NEAREST`
-constants so plugins can drop their local shims.
-
-## Composite layouts
-
-Pre-carved Region arrangements for the layouts plugins keep rebuilding:
-
-```python
-from src.adaptive_layout import scoreboard_regions, media_row
-
-regs = scoreboard_regions(self.layout.bounds, ctx=self.layout)
-# regs.away_slot / home_slot   — logo slots (logo_slot = min(H, W // 2),
-#                                 capped so a center reserve always exists —
-#                                 see below)
-# regs.status_band             — top band (replaces the magic y = 1)
-# regs.score_area              — center gap, plus a controlled bleed into
-#                                 each logo slot (replaces y = H//2 - 3)
-# regs.detail_band             — bottom band (replaces y = H - 7)
-# regs.bottom_left / bottom_right — record/timeout corners
-
-row = media_row(self.layout.bounds, ctx=self.layout)   # art left, text right
-```
-
-Both work on the full panel or on a scroll-mode card Region. They return
-Regions and never draw — compose them with `draw_fit`/`draw_image`.
-
-**`scoreboard_regions`'s center reserve.** The raw `logo_slot = min(H, W//2)`
-formula has a blind spot: at exactly 2:1 aspect ratio (width = 2×height —
-two, four, or more square modules stacked into a taller panel, e.g.
-96x48, 128x64, 256x128) the two logo slots mathematically claim the
-*entire* width, leaving zero pixels for a center column no matter how
-big the panel gets. Wide panels (the 128x32 design baseline, 192x48,
-256x32) never hit this, since height is already the tighter constraint
-there. Two parameters fix it without any plugin-side code:
-`min_center_fraction`/`min_center_design_px` guarantee a real minimum
-center reserve at any aspect ratio, and `score_bleed_fraction` lets the
-score's *fit box* extend a controlled amount into each logo slot — the
-same way a real broadcast scoreboard's numbers cross slightly into the
-team marks flanking them — so a short score string never has to truncate
-even on the tightest aspect ratios. All three have sane defaults; override
-them per call if a plugin's card proportions genuinely differ.
-
-## Preserving user customization
-
-Adaptive layout supplies *defaults*; explicit user configuration wins:
-
-- **User-set fonts win.** If the plugin's config has an explicit
-  `font`/`font_size` for an element, load it as before and skip the ladder —
-  fit only when the user hasn't overridden (see the football-scoreboard
-  `_resolve_element_fit` pattern).
-- **Offsets apply on top.** `customization.layout.<element>.{x_offset,y_offset}`
-  style knobs translate the *computed* region as a final step:
-  `region.offset(user_dx, user_dy)`. `draw_image(..., offset=(dx, dy))`
-  does the same for images.
-- **Colors pass through.** `draw_fit`/`draw_fitted_text` take explicit
-  `color=` params; adaptive mode never repaints semantic or user-chosen
-  colors.
-
-## Manifest declaration
-
-Declare the size your layout was authored against so `ctx.scale` means
-something:
-
-```json
-"display": { "design_size": { "width": 128, "height": 32 } }
-```
-
-Also available under `requires.display_size`: `min_width`, `min_height`,
-`max_width`, `max_height`.
-
-## Performance notes (Pi)
-
-Fit queries are cached, so cost is O(unique strings). For per-second text
-(clocks, live scores), fit on a **shape placeholder** and reuse the font:
-
-```python
-fit = self.layout.fit_text("00:00", box, ladder=LADDER_ARCADE)  # cached once
-self.display_manager.draw_text(current_time, font=fit.font, ...)
-```
-
-## Testing across sizes
-
-The harness already renders every plugin at a spread of sizes (now
-including 96x48):
-
-```bash
-python scripts/check_plugin.py --plugin <plugin-id> --sizes 64x32,128x32,96x48,128x64,256x64
-python scripts/render_plugin.py --plugin <plugin-id> --width 96 --height 48
-```
-
-`BoundsCheckingDisplayManager` flags right/bottom overflow and now records
-mediated draw calls with negative coordinates in
-`negative_coordinate_calls` (raw-PIL draws remain uncovered).
-
-Reference migration: the **text-display** plugin's `font_mode: "auto"`.

docs/ADVANCED_FEATURES.md

@@ -10,27 +10,22 @@ This guide covers advanced LEDMatrix features for users and developers, includin
 
 Vegas scroll mode displays content from multiple plugins in a continuous horizontal scroll, similar to news tickers seen in Las Vegas casinos. Plugins contribute content segments that flow across the display in a seamless ticker-style presentation.
 
-### How a Plugin Takes Part
+### Display Modes
 
-Each plugin has a *Vegas participation*:
+**SCROLL (Continuous Scrolling):**
+- Content scrolls continuously left
+- Smooth, fluid motion
+- Best for news-ticker style displays
 
-**`scroll` (the default):**
-- The plugin's content scrolls by with everyone else's
-- Best for news-ticker style content: scores, headlines, prices, the time
+**FIXED_SEGMENT (Fixed-Width Block):**
+- Plugin gets fixed-width block on display
+- Content doesn't scroll out of its segment
+- Multiple plugins can share the display simultaneously
 
-**`pause`:**
-- The scroll stops when the plugin's turn comes round
-- The plugin draws the whole panel for its display duration, then the
-  scroll resumes
-- Best for content that needs to be read in full, or alerts
-
-**`exclude`:**
-- The plugin is left out of Vegas mode
-
-A plugin declares its default; set `vegas_participation` in a plugin's
-config to override it (see [Per-Plugin Configuration](#per-plugin-configuration)).
-Older documentation also describes a *fixed segment* mode; Vegas never
-implemented one, and it has always behaved exactly like `scroll`.
+**STATIC (Scroll Pauses):**
+- Scrolling pauses when content is fully visible
+- Displays for specified duration, then resumes scrolling
+- Best for content that needs to be fully read
 
 ### Configuration
 
@@ -52,11 +47,6 @@ Enable Vegas mode in `config/config.json`:
 }
 ```
 
-Vegas mode can also be configured entirely from the web UI — the
-**Display** tab has a Vegas Scroll Mode section (enable toggle, scroll
-speed, separator width, dynamic duration, and more), so hand-editing
-JSON is optional.
-
 **Configuration Options:**
 
 | Setting | Default | Description |
@@ -67,113 +57,7 @@ JSON is optional.
 | `plugin_order` | `[]` | Plugin display order (empty = auto) |
 | `excluded_plugins` | `[]` | Plugins to exclude from Vegas mode |
 | `target_fps` | `125` | Target frame rate |
-| `buffer_ahead` | `2` | Number of plugins buffered ahead |
-
-This table is a subset — `display.vegas_scroll` supports 30 keys in
-total. See the full list in
-[CONFIG_REFERENCE.md](CONFIG_REFERENCE.md#displayvegas_scroll--continuous-scroll-mode).
-
-### Live Content in the Ticker
-
-By default (since 3.8.0) live content **stays in the ticker** and takes
-**extra turns inside it**, and a scoreboard that supports live cards updates
-the score on a card already crossing the screen (`live_refresh`, "Update live
-content while it scrolls").
-
-To get the old behaviour back -- live content **preempts** Vegas mode: while
-any plugin reports live priority the ticker stops and that plugin's
-full-screen display is shown instead -- untick **Keep live games in the
-ticker** under Vegas mode, or set `live_in_ticker` to `false`:
-
-```json
-"vegas_scroll": {
-  "live_in_ticker": false
-}
-```
-
-Until 3.8.0 `false` was the default and every config held it, copied from
-the template. The first start on 3.8.0 turns it on once (a backup of the
-config is kept as `config.json.backup`, and `live_in_ticker_migrated` records
-that it ran); a `false` set after that is left alone.
-
-The weights below apply while live content is in the ticker:
-
-```json
-"vegas_scroll": {
-  "live_weight": 3,
-  "favorite_live_weight": 5
-}
-```
-
-#### Why weights exist
-
-The rotation is otherwise a strict round robin — every plugin appears exactly
-once per cycle. With a dozen plugins enabled, a live score comes round once a
-lap and can be minutes old by the time you see it. A weight of *N* gives a
-plugin *N* slots per cycle.
-
-The slots are placed by **Smooth Weighted Round-Robin**, the same scheduler
-the sports plugins use internally to rotate their own games. The important
-property is that repeats are *spread through the cycle* rather than clumped:
-three appearances in a row followed by a long silence would be worse than not
-boosting at all.
-
-Twelve plugins, with a favorite's baseball game and an ordinary live hockey
-game (`live_weight: 3`, `favorite_live_weight: 5`):
-
-```
-baseball > hockey > weather  > clock  > baseball
-stocks   > news   > flights  > baseball > hockey
-calendar > f1     > music    > baseball > tides
-birds    > hockey > baseball
-```
-
-18 slots for 12 plugins. Baseball appears 5 times, hockey 3, everything else
-once, and no plugin ever appears twice in a row — **including across the seam**
-where the cycle loops back on itself. Smooth Weighted Round-Robin schedules the
-heaviest item first and usually last as well, so the strip would otherwise show
-it twice running at exactly the one join a within-cycle check cannot see. The
-trailing repeat is moved into the widest remaining gap. Where a double is
-unavoidable — a plugin holding most of the slots has to neighbour itself — the
-schedule is left as it is.
-
-#### Where the weight comes from
-
-For each plugin in the rotation, in order:
-
-1. **The plugin's own answer.** If it implements
-   `get_vegas_priority_weight()` and returns a number, that wins. This is the
-   only route for favorite-team awareness — the core can see *that* a game is
-   live, but not *whose*, so a scoreboard has to say so itself.
-2. **The core's default.** When the plugin returns `None` (the base-class
-   default), a plugin where both `has_live_priority()` and `has_live_content()`
-   are true gets `live_weight`.
-3. **Everything else** gets 1.
-
-Because of step 2, **existing plugins need no changes** — any scoreboard with
-`live_priority` enabled already gets extra turns. Step 1 is opt-in, for
-plugins that want to distinguish a favorite's game from any other live game.
-
-Weights are clamped to 1–10. A weight of 1 is no boost; a weight below 1 would
-drop the plugin from the rotation entirely, which is never what is meant.
-
-#### Things worth knowing
-
-- **Weights are per plugin, not per game.** A scoreboard showing four live
-  games still occupies one slot at a time, rotating its own games within that
-  slot using its own `favorite_live_boost`. This controls how often the
-  *plugin* comes round.
-- **The ticker is zero-sum.** Giving baseball 5 slots does not make the cycle
-  faster; it makes the cycle *longer* and everything else proportionally
-  rarer. If you want live scores sooner in wall-clock terms, pair this with a
-  smaller `plugins_per_cycle`.
-- **Frequency is not freshness.** Each appearance redraws from the plugin's
-  current data (`refresh_updated_plugins()` drops cached content when a
-  plugin's data changes), but how current that data is depends on the
-  plugin's own `live_update_interval`. Showing a stale score five times a lap
-  is no better than showing it once.
-- **Everything still appears.** A boost never starves another plugin out of
-  the cycle; low-weight plugins keep their single slot.
+| `buffer_ahead` | `2` | Number of panels to render ahead |
 
 ### Per-Plugin Configuration
 
@@ -183,7 +67,8 @@ Override Vegas behavior for specific plugins:
 {
   "my_plugin": {
     "enabled": true,
-    "vegas_participation": "pause",
+    "vegas_mode": "scroll",
+    "vegas_panel_count": 2,
     "display_duration": 10
   }
 }
@@ -193,80 +78,77 @@ Override Vegas behavior for specific plugins:
 
 | Setting | Values | Description |
 |---------|--------|-------------|
-| `vegas_participation` | `scroll`, `pause`, `exclude` | How this plugin takes part: its content scrolls by, the scroll pauses for its turn and shows it full screen, or it is left out. Unset uses the plugin's own default |
-| `display_duration` | seconds | How long a `pause` plugin holds the screen |
-| `vegas_width_pct` | 10–100 | Width of this plugin's card, as a percentage of the panel |
-| `vegas_overflow` | `rotate`, `truncate` | What to do when its content is wider than its allowance |
-| `vegas_max_width_screens` | number of screens | The widest its card may be |
-
-These are core-owned settings (see
-[PLUGIN_CONFIG_CORE_PROPERTIES.md](PLUGIN_CONFIG_CORE_PROPERTIES.md)): every
-plugin accepts them whether or not its own schema lists them. Set them in
-the plugin's section of config.json, in the web UI's **Config Editor**
-tab.
-
-Some plugins also offer a `vegas_mode` setting of their own (`scroll`,
-`fixed` or `static`). It still works — `static` pauses, the other two scroll
-— but `vegas_participation` takes precedence, and `fixed` has never done
-anything different from `scroll`. The old `vegas_panel_count` setting never
-had an effect and is deprecated (removed in 3.9.0).
+| `vegas_mode` | `scroll`, `fixed`, `static` | Display mode for this plugin |
+| `vegas_panel_count` | `1-10` | Width in panels (1 panel = display width) |
+| `display_duration` | seconds | Pause duration for STATIC mode |
 
 ### Plugin Integration (Developer Guide)
 
-All of these have defaults in
-[`BasePlugin`](../src/plugin_system/base_plugin.py); override only what you
-need. The reference is
-[PLUGIN_API_REFERENCE.md](PLUGIN_API_REFERENCE.md#vegas-scroll-hooks).
-
 **1. Implement Content Method:**
 
 ```python
 def get_vegas_content(self):
-    # Return a PIL Image, a list of Images, or None.
-    # A single image is one block; a list becomes one item per image.
-    return [self._render_game(game) for game in self.games]
+    """
+    Return PIL Image or list of Images for Vegas mode.
+
+    Returns:
+        PIL.Image or list[PIL.Image]: Content to display
+        - Single image: fixed-width content
+        - List of images: multiple segments
+        - None: skip this cycle
+    """
+    # Example: Return single wide image
+    img = Image.new('RGB', (256, 32))
+    # ... render your content ...
+    return img
+
+    # Example: Return multiple segments
+    return [image1, image2, image3]
 ```
 
-If it returns `None` (the default), Vegas falls back to the plugin's
-`scroll_helper` image, then to capturing `display()` output
-(`PluginAdapter.get_content()` in
-[`src/vegas_mode/plugin_adapter.py`](../src/vegas_mode/plugin_adapter.py)).
-
-**2. Declare how the plugin takes part:**
-
-Most plugins need nothing: the default is `scroll`. A plugin that should
-pause the scroll, or stay out of Vegas, says so in `manifest.json`:
-
-```json
-{
-  "vegas_participation": "pause"
-}
-```
-
-The user's own `vegas_participation` setting overrides the manifest. When
-the answer depends on state, override the method instead:
+**2. Specify Content Type:**
 
 ```python
-def get_vegas_participation(self):
-    # 'scroll' | 'pause' | 'exclude'
-    return 'pause' if self._alert_is_live() else 'scroll'
+def get_vegas_content_type(self):
+    """
+    Specify how content should be handled.
+
+    Returns:
+        str: 'multi' | 'static' | 'none'
+    """
+    return 'multi'  # Default for most plugins
 ```
 
-A plugin written for an older core that declares nothing keeps its
-behaviour: `get_vegas_display_mode()` returning `VegasDisplayMode.STATIC`
-pauses, `get_vegas_content_type()` returning `'none'` excludes, and
-everything else scrolls. `get_supported_vegas_modes()`,
-`get_vegas_segment_width()` and the SCROLL / FIXED_SEGMENT distinction are
-deprecated (removed in 3.9.0): Vegas never read them.
+**3. Optionally Specify Display Mode:**
+
+```python
+def get_vegas_display_mode(self):
+    """
+    Preferred display mode for this plugin.
+
+    Returns:
+        str: 'scroll' | 'fixed' | 'static'
+    """
+    return 'scroll'
+
+def get_supported_vegas_modes(self):
+    """
+    List of supported modes.
+
+    Returns:
+        list: ['scroll', 'fixed', 'static']
+    """
+    return ['scroll', 'static']
+```
 
 ### Content Rendering Guidelines
 
 **Image Dimensions:**
 - **Height:** Must match display height (typically 32 pixels)
-- **Width:** Any width for `scroll` (recommended 64-512 pixels);
-  `get_vegas_render_width()` is the width Vegas would like, and it narrows
-  `display_manager` to match while it asks. A `pause` plugin draws the
-  whole panel in `display()`.
+- **Width:** Varies by mode:
+  - SCROLL: Any width (recommended 64-512 pixels)
+  - FIXED_SEGMENT: `panel_count * display_width`
+  - STATIC: Any width, optimized for readability
 
 **Color Mode:**
 - Use RGB color mode
@@ -316,9 +198,16 @@ class WeatherPlugin(BasePlugin):
     def get_vegas_content(self):
         """Return cached Vegas image"""
         return self.vegas_image
-```
 
-It scrolls, the default participation, so it declares nothing else.
+    def get_vegas_content_type(self):
+        return 'multi'
+
+    def get_vegas_display_mode(self):
+        return 'scroll'
+
+    def get_supported_vegas_modes(self):
+        return ['scroll', 'static']
+```
 
 ### System Architecture
 
@@ -387,23 +276,15 @@ Vegas mode consists of four core components working together to provide smooth 1
 5. Compose into continuous stream with separators
 
 **Key Methods:**
-- `get_next_segment()` - Returns the next buffered `ContentSegment` (or `None`)
-- `take_next_group(count=None, offscreen_only=False)` - Hands over the next
-  slice of the rotation as `(plugin_id, images)` groups
-- `get_grouped_content_for_composition()` - Buffered images grouped by plugin
-- `mark_plugin_updated(plugin_id)` / `process_updates()` - Refresh one
-  plugin's segment in place when its data changes
-- `refresh()` - Re-read the plugin list and config
-- `advance_cycle()` - Clear the active buffer when a scroll cycle completes
-
-(`src/vegas_mode/stream_manager.py`)
+- `get_stream_content()` - Returns current stream content as PIL Image
+- `advance_stream(pixels)` - Advances stream by N pixels
+- `refresh_stream()` - Regenerates stream from current plugins
 
 #### 3. PluginAdapter
 
 **Responsibilities:**
 - Convert plugin content to scrollable images
-- Fetch the content of `scroll` plugins (a `pause` plugin is drawn by
-  its own `display()` when the scroll pauses; see StreamManager)
+- Handle different Vegas display modes (SCROLL, FIXED, STATIC)
 - Manage fallback for plugins without Vegas support
 - Cache plugin content for performance
 
@@ -412,16 +293,21 @@ Vegas mode consists of four core components working together to provide smooth 1
    - Calls `get_vegas_content()` if available
    - Falls back to `display()` method if not
 
-2. **Participation** is decided by the StreamManager, not here
-   (`resolve_vegas_participation()` in
-   [`base_plugin.py`](../src/plugin_system/base_plugin.py)): `exclude`
-   plugins never reach the adapter, and `pause` plugins are not fetched.
+2. **Handle display mode:**
+   - SCROLL: Returns image as-is for continuous scrolling
+   - FIXED_SEGMENT: Creates fixed-width block (panel_count * display_width)
+   - STATIC: Marks content for pause-when-visible behavior
+
+3. **Content type handling:**
+   - `multi`: Multiple segments (list of images)
+   - `static`: Single static image
+   - `none`: Skip this plugin in current cycle
 
 **Fallback Behavior:**
 - If plugin doesn't implement Vegas methods:
   - Calls plugin's `display()` method
   - Captures rendered display as static image
-  - Scrolls it by as one block
+  - Treats as fixed segment
 - Ensures all plugins work in Vegas mode without explicit support
 
 #### 4. RenderPipeline
@@ -446,14 +332,10 @@ Vegas mode consists of four core components working together to provide smooth 1
 - **Frame Rate Control:** Precise timing to maintain 125 FPS
 - **Pre-rendered Content:** Plugins pre-render during update()
 
-**Scroll Speed Calculation:** motion is by elapsed time; `target_fps` paces
-the render loop, not the speed.
+**Scroll Speed Calculation:**
 ```python
-# frame_based_scrolling: false
-scroll_position += scroll_speed * elapsed_time            # scroll_speed in px/s
-# frame_based_scrolling: true (the default) -- not stepping, just a clamp
-applied = clamp(scroll_speed * scroll_delay, 0.1, 5) / scroll_delay
-scroll_position += applied * elapsed_time
+pixels_per_frame = (scroll_speed / target_fps)
+scroll_position += pixels_per_frame * elapsed_time
 ```
 
 #### Component Interactions
@@ -524,7 +406,7 @@ All components use thread-safe patterns:
 If a plugin doesn't implement Vegas methods:
 - System calls the plugin's `display()` method
 - Captures the rendered display as a static image
-- Scrolls it by as one block
+- Treats it as a fixed segment
 
 This ensures all plugins work in Vegas mode, even without explicit support.
 
@@ -569,8 +451,7 @@ time when something is active.
 
 ### REST API Reference
 
-The API is mounted at `/api/v3` (the `api_v3` blueprint, registered in
-`web_interface/app.py`). Full details: [REST_API_REFERENCE.md](REST_API_REFERENCE.md#display-control).
+The API is mounted at `/api/v3` (`web_interface/app.py:144`).
 
 #### Start On-Demand Display
 
@@ -626,38 +507,24 @@ curl http://localhost:5000/api/v3/display/on-demand/status
 
 # Response:
 {
-  "status": "success",
-  "data": {
-    "state": {
-      "active": true,
-      "plugin_id": "weather",
-      "mode": "weather",
-      "duration": 30,
-      "pinned": false,
-      "status": "running",
-      "last_updated": 1234567890.1
-    },
-    "service": {"active": true, "returncode": 0, "stdout": "active", "stderr": ""}
-  }
+  "active": true,
+  "plugin_id": "weather",
+  "mode": "weather",
+  "remaining": 25.5,
+  "pinned": false,
+  "status": "active"
 }
 ```
 
-When nothing is running on demand, `data.state` is
-`{"active": false, "status": "idle", "last_updated": null}`.
-
 > There is no public Python on-demand API. The display controller's
 > on-demand machinery is internal — drive it through the REST endpoints
-> above (or the web UI buttons). The API handlers
-> (`start_on_demand_display()` / `stop_on_demand_display()` in
-> `web_interface/blueprints/api_v3/display.py`) send the request over the
-> display's control socket ([IPC_CONTROL_SOCKET.md](IPC_CONTROL_SOCKET.md)).
-> Only when the socket cannot carry it do they write it into the cache
-> manager under the `display_on_demand_request` key, which
-> `DisplayController._poll_on_demand_requests()`
-> (`src/display_controller.py`) picks up. A separate
+> above (or the web UI buttons), which write a request into the cache
+> manager under the `display_on_demand_request` key
+> (`web_interface/blueprints/api_v3.py:1622,1687`) that the controller
+> polls at `src/display_controller.py:921`. A separate
 > `display_on_demand_config` key is used by the controller itself
-> during activation (`_activate_on_demand()`) to track what's
-> currently running, and is cleared by `_clear_on_demand()`.
+> during activation to track what's currently running (written at
+> `display_controller.py:1195`, cleared at `:1221`).
 
 ### Duration Modes
 
@@ -749,14 +616,8 @@ keys helps troubleshoot stuck states.
   "timestamp": 1234567890.123
 }
 ```
-**Purpose:** Communication from web interface to display controller, as the
-fallback when the control socket cannot carry the request (deprecated; it
-will be removed in a later release)
-**When Set:** API endpoint receives a request and the display's control
-socket is unavailable (display stopped, or older than the socket or the
-command); some plugins also write it directly
-**Read:** once a second while the display serves the control socket (0.25 s
-without it), and only when the file changed since the last look
+**Purpose:** Communication from web interface to display controller
+**When Set:** API endpoint receives request
 **Auto-Cleared:** After processing or 1 hour TTL
 
 **2. display_on_demand_config** (No TTL)
@@ -785,13 +646,13 @@ without it), and only when the file changed since the last look
 **When Set:** Every display loop iteration
 **Auto-Cleared:** Never (continuously updated)
 
-**4. display_on_demand_processed_id** (TTL: 1 hour)
-```text
+**4. display_on_demand_processed_id** (TTL: 5 minutes)
+```
 "uuid-string-of-last-processed-request"
 ```
 **Purpose:** Prevents duplicate request processing
 **When Set:** After processing request
-**Auto-Cleared:** After 1 hour TTL
+**Auto-Cleared:** After 5 minutes TTL
 
 ### When Manual Clearing is Needed
 
@@ -824,9 +685,9 @@ without it), and only when the file changed since the last look
 The cache is stored as JSON files under one of:
 
 - `/var/cache/ledmatrix/` (preferred when the service has permission)
-- `~/.ledmatrix_cache/`
+- `~/.cache/ledmatrix/`
 - `/opt/ledmatrix/cache/`
-- `$TMPDIR/ledmatrix_cache/` (fallback)
+- `/tmp/ledmatrix-cache/` (fallback)
 
 ```bash
 # Find the cache dir actually in use
@@ -850,9 +711,8 @@ cache.clear_cache('display_on_demand_request')
 cache.clear_cache('display_on_demand_processed_id')
 ```
 
-> `CacheManager` also has a `delete(key)` method — a thin wrapper over
-> `clear_cache(key)` — so `cache.delete('display_on_demand_config')`
-> works equally well.
+> The actual public method is `clear_cache(key=None)` — there is no
+> `delete()` method on `CacheManager`.
 
 ### Cache Impact on Running Service
 
@@ -870,7 +730,7 @@ The display controller automatically handles cleanup:
 - **Config key**: Cleared when on-demand stops
 - **State key**: Updated every display loop iteration
 - **Request key**: Expires after 1 hour TTL (or after processing)
-- **Processed ID**: Expires after 1 hour TTL
+- **Processed ID**: Expires after 5 minutes TTL
 
 ---
 
@@ -900,13 +760,7 @@ Cache Check → Background Fetch → Partial Data → Completion → Cache
 
 ### Configuration
 
-Core does not read a `background_service` config block: the service itself
-(`src/background_data_service.py`) is a process-wide singleton, and its
-worker count is whatever the first caller of `get_background_service()`
-passes. The sports scoreboard plugins read their own
-`background_service` settings and pass them to it, so the exact keys and
-where they sit (top level or per league) are defined by each plugin's
-`config_schema.json`. A typical block looks like:
+Enable background service per plugin in `config/config.json`:
 
 ```json
 {
@@ -927,11 +781,11 @@ where they sit (top level or per league) are defined by each plugin's
 
 | Setting | Default | Description |
 |---------|---------|-------------|
-| `enabled` | plugin-defined | Use the background service for this plugin's fetches |
+| `enabled` | `false` | Enable background service for this plugin |
 | `max_workers` | `3` | Max concurrent background tasks |
 | `request_timeout` | `30` | Timeout per API request (seconds) |
 | `max_retries` | `3` | Retry attempts on failure |
-| `priority` | `1` | Stored on each request (higher number = higher priority, per `FetchRequest`), but the service runs requests in submission order; it does not reorder by priority |
+| `priority` | `1` | Task priority (1=highest, 10=lowest) |
 
 ### Performance Impact
 
@@ -948,9 +802,9 @@ where they sit (top level or per league) are defined by each plugin's
 
 The background data service is used by all of the sports scoreboard
 plugins (football, hockey, baseball/MLB, basketball, soccer, lacrosse,
-F1, UFC), the odds ticker, and the leaderboard plugin. Each plugin reads
-its own `background_service` block (under its own config namespace); check
-that plugin's `config_schema.json` for the keys it accepts.
+F1, UFC), the odds ticker, and the leaderboard plugin. Each plugin's
+`background_service` block (under its own config namespace) follows the
+same shape as the example above.
 
 ### Error Handling & Fallback
 
@@ -967,6 +821,9 @@ that plugin's `config_schema.json` for the keys it accepts.
 ### Testing
 
 ```bash
+# Run background service test
+python test_background_service.py
+
 # Check logs for background operations
 sudo journalctl -u ledmatrix -f | grep "background"
 ```
@@ -975,21 +832,15 @@ sudo journalctl -u ledmatrix -f | grep "background"
 
 **View Statistics:**
 ```python
-from src.background_data_service import get_background_service
-from src.cache_manager import CacheManager
+from src.background_data_service import BackgroundDataService
 
-service = get_background_service(CacheManager())
+service = BackgroundDataService()
 stats = service.get_statistics()
-print(f"Active: {stats['active_requests']}")
-print(f"Completed: {stats['completed_requests']}")
-print(f"Failed: {stats['failed_requests']}")
+print(f"Active tasks: {stats['active_tasks']}")
+print(f"Completed: {stats['completed']}")
+print(f"Failed: {stats['failed']}")
 ```
 
-Other keys: `total_requests`, `cached_hits`, `cache_misses`,
-`average_fetch_time`, `completed_requests_count` (results currently held in
-memory) — see `BackgroundDataService.get_statistics()` in
-[`src/background_data_service.py`](../src/background_data_service.py).
-
 **Enable Debug Logging:**
 ```python
 import logging
@@ -1000,10 +851,6 @@ logging.getLogger('src.background_data_service').setLevel(logging.DEBUG)
 
 ## 5. Permission Management
 
-Ownership, modes, sudo rules and the repair scripts are listed in
-[PERMISSIONS.md](PERMISSIONS.md). This section covers the helpers code uses
-to keep files shareable.
-
 ### Overview
 
 LEDMatrix uses a dual-user architecture: the display service runs as root (hardware access), while the web interface runs as a non-privileged user. Centralized permission management ensures both can access necessary files.
@@ -1028,7 +875,6 @@ from src.common.permission_utils import (
     ensure_file_permissions,
     get_config_file_mode,
     get_assets_file_mode,
-    get_assets_dir_mode,
     get_plugin_file_mode,
     get_cache_dir_mode
 )
@@ -1037,10 +883,7 @@ from src.common.permission_utils import (
 ensure_directory_permissions(Path("assets/sports"), get_assets_dir_mode())
 
 # Set file permissions after writing
-# (get_config_file_mode requires the file path — secrets files get a
-# stricter mode than the main config)
-config_path = Path("config/config.json")
-ensure_file_permissions(config_path, get_config_file_mode(config_path))
+ensure_file_permissions(Path("config/config.json"), get_config_file_mode())
 ```
 
 ### When to Use Utilities
@@ -1067,7 +910,7 @@ ensure_file_permissions(config_path, get_config_file_mode(config_path))
 | Config (secrets) | `rw-r-----` | `0o640` | Owner write, group read |
 | Assets | `rw-rw-r--` | `0o664` | Owner/group write, all read |
 | Plugins | `rw-rw-r--` | `0o664` | Owner/group write, all read |
-| Cache files | `rw-rw----` | `0o660` | Owner/group write, no world access (`_CACHE_FILE_MODE` in `src/cache/disk_cache.py`) |
+| Cache files | `rw-rw-r--` | `0o664` | Owner/group write, all read |
 
 **Directory Permissions:**
 
@@ -1095,7 +938,7 @@ from src.common.permission_utils import ensure_file_permissions, get_config_file
 config_path = Path("config/config.json")
 with open(config_path, 'w') as f:
     json.dump(data, f)
-ensure_file_permissions(config_path, get_config_file_mode(config_path))
+ensure_file_permissions(config_path, get_config_file_mode())
 ```
 
 **Pattern 3: Downloading Logo**
@@ -1138,28 +981,43 @@ These core utilities **already handle permissions** - you don't need to call per
 
 ### Manual Fixes
 
-[PERMISSIONS.md](PERMISSIONS.md) lists who owns what on an installed system,
-the expected modes, and which `scripts/fix_perms/` script to run as which
-user. In short:
+If you encounter permission issues:
 
-- `fix_assets_permissions.sh`, `fix_cache_permissions.sh` and
-  `fix_plugin_permissions.sh` are run with `sudo`.
-- `fix_web_permissions.sh` is run as the web interface user, without
-  `sudo` (it refuses to run as root and calls `sudo` itself where needed).
-  It resets project file ownership for that user, then makes the two
-  helper scripts the web user may run as root (`safe_plugin_rm.sh`,
-  `safe_pip_install.sh`) root-owned again and restores `config_secrets.json`
-  to its owner, the `ledmatrix` group and mode `640`. It does not write
-  sudoers rules; `scripts/install/configure_web_sudo.sh` does that.
+```bash
+# Fix all permissions at once
+sudo ./scripts/fix_permissions.sh
 
-Do not `chmod` the whole `config/` directory: `config_secrets.json` must stay
-`640`.
+# Fix specific directory
+sudo chown -R ledpi:ledpi /home/ledpi/LEDMatrix/config
+sudo chmod -R 2775 /home/ledpi/LEDMatrix/config
+sudo find /home/ledpi/LEDMatrix/config -type f -exec chmod 664 {} \;
+
+# Verify permissions
+ls -la config/
+ls -la assets/
+```
+
+### Verification
+
+```bash
+# Check directory has setgid bit
+ls -ld assets/
+# Should show: drwxrwsr-x (note the 's')
+
+# Check file has correct group
+ls -l assets/logo.png
+# Should show group 'ledpi'
+
+# Check file permissions
+stat -c "%a %n" config/config.json
+# Should show: 644 config/config.json
+```
 
 ---
 
 ## Related Documentation
 
-- [PLUGIN_DEVELOPMENT_GUIDE.md](PLUGIN_DEVELOPMENT_GUIDE.md) - Creating plugins with Vegas/on-demand support
+- [PLUGIN_DEVELOPMENT.md](PLUGIN_DEVELOPMENT.md) - Creating plugins with Vegas/on-demand support
 - [WEB_INTERFACE_GUIDE.md](WEB_INTERFACE_GUIDE.md) - Using on-demand controls in web UI
 - [PLUGIN_API_REFERENCE.md](PLUGIN_API_REFERENCE.md) - Complete API documentation
 - [DEVELOPMENT.md](DEVELOPMENT.md) - Development environment and testing

docs/ADVANCED_PLUGIN_DEVELOPMENT.md

@@ -2,18 +2,12 @@
 
 Advanced patterns, examples, and best practices for developing LEDMatrix plugins.
 
-> **Adaptive layout:** for plugins that should render legibly on any panel
-> size (fonts that grow on big panels, layouts that degrade gracefully on
-> small ones), use the adaptive layout system — `self.layout`, `draw_fit`,
-> `draw_image`, `scoreboard_regions` — documented in
-> [ADAPTIVE_LAYOUT.md](ADAPTIVE_LAYOUT.md).
-
 ## Table of Contents
 
 - [Using Weather Icons](#using-weather-icons)
 - [Implementing Scrolling with Deferred Updates](#implementing-scrolling-with-deferred-updates)
 - [Cache Strategy Patterns](#cache-strategy-patterns)
-- [Font Management](#font-management)
+- [Font Management and Overrides](#font-management-and-overrides)
 - [Error Handling Best Practices](#error-handling-best-practices)
 - [Performance Optimization](#performance-optimization)
 - [Testing Plugins with Mocks](#testing-plugins-with-mocks)
@@ -25,12 +19,69 @@ Advanced patterns, examples, and best practices for developing LEDMatrix plugins
 
 ## Using Weather Icons
 
-The Display Manager's icon methods — `draw_weather_icon()`, `draw_sun()`,
-`draw_cloud()`, `draw_rain()`, `draw_snow()` and `draw_text_with_icons()` —
-were removed in 3.8.0. Draw your own icons instead: render them
-onto a PIL image and paste it onto `self.display_manager.image`, or ship
-icon images with the plugin. The weather plugin's `WeatherIcons` class is an
-example. See [Deprecated APIs](PLUGIN_API_REFERENCE.md#deprecated-apis).
+The Display Manager provides built-in weather icon drawing methods for easy visual representation of weather conditions.
+
+### Basic Weather Icon Usage
+
+```python
+def display(self, force_clear=False):
+    if force_clear:
+        self.display_manager.clear()
+    
+    # Draw weather icon based on condition
+    condition = self.data.get('condition', 'clear')
+    self.display_manager.draw_weather_icon(condition, x=5, y=5, size=16)
+    
+    # Draw temperature next to icon
+    temp = self.data.get('temp', 72)
+    self.display_manager.draw_text(
+        f"{temp}°F",
+        x=25, y=10,
+        color=(255, 255, 255)
+    )
+    
+    self.display_manager.update_display()
+```
+
+### Supported Weather Conditions
+
+The `draw_weather_icon()` method automatically maps condition strings to appropriate icons:
+
+- `"clear"`, `"sunny"` → Sun icon
+- `"clouds"`, `"cloudy"`, `"partly cloudy"` → Cloud icon
+- `"rain"`, `"drizzle"`, `"shower"` → Rain icon
+- `"snow"`, `"sleet"`, `"hail"` → Snow icon
+- `"thunderstorm"`, `"storm"` → Storm icon
+
+### Custom Weather Icons
+
+For more control, use individual icon methods:
+
+```python
+# Draw specific icons
+self.display_manager.draw_sun(x=10, y=10, size=16)
+self.display_manager.draw_cloud(x=10, y=10, size=16, color=(150, 150, 150))
+self.display_manager.draw_rain(x=10, y=10, size=16)
+self.display_manager.draw_snow(x=10, y=10, size=16)
+```
+
+### Text with Weather Icons
+
+Use `draw_text_with_icons()` to combine text and icons:
+
+```python
+icons = [
+    ("sun", 5, 5),      # Sun icon at (5, 5)
+    ("cloud", 100, 5)   # Cloud icon at (100, 5)
+]
+
+self.display_manager.draw_text_with_icons(
+    "Weather: Sunny, Cloudy",
+    icons=icons,
+    x=10, y=20,
+    color=(255, 255, 255)
+)
+```
 
 ---
 
@@ -40,53 +91,31 @@ For plugins that scroll content (tickers, news feeds, etc.), use scrolling state
 
 ### Basic Scrolling Implementation
 
-Scroll with `ScrollHelper`, configured by `src.common.scroll_config`, and
-render one frame per `display()` call. Don't pace the scroll with
-`time.sleep()`: `update_display()` blocks on the panel's
-vsync, which is what paces a scroll. Pass the `frame_hold` that
-`scroll_config.configure()` returned to `set_scrolling_state()`, or the
-scroll runs faster than the configured speed (see
-`set_scrolling_state()` in [PLUGIN_API_REFERENCE.md](PLUGIN_API_REFERENCE.md)).
-
 ```python
-from PIL import Image, ImageDraw
-
-from src.common import scroll_config
-from src.common.scroll_helper import ScrollHelper
-
-def __init__(self, *args, **kwargs):
-    super().__init__(*args, **kwargs)
-    self.scroll_helper = ScrollHelper(
-        self.display_manager.width, self.display_manager.height, self.logger)
-    self.scroll_settings = scroll_config.configure(
-        self.scroll_helper,
-        plugin_config=self.config,
-        global_config=self.global_config,
-        display_manager=self.display_manager,
-        plugin_logger=self.logger,
-    )
-
-def _build_scroll_image(self, text):
-    font = self.display_manager.regular_font
-    width = self.display_manager.get_text_width(text, font)
-    img = Image.new("RGB", (width, self.display_manager.height))
-    ImageDraw.Draw(img).text((0, 0), text, font=font, fill=(255, 255, 255))
-    self.scroll_helper.set_scrolling_image(img)
-
 def display(self, force_clear=False):
-    if force_clear or self.scroll_helper.cached_image is None:
-        self._build_scroll_image(
-            "This is a long scrolling message that needs to scroll across the display...")
-
-    # Mark as scrolling (calling it every frame is fine)
-    self.display_manager.set_scrolling_state(
-        True, frame_hold=self.scroll_settings.frame_hold)
-    self.scroll_helper.update_scroll_position()
-    self.display_manager.image = self.scroll_helper.get_visible_portion()
-    self.display_manager.update_display()
-
-    if self.scroll_helper.is_scroll_complete():
-        # Mark as not scrolling when done
+    if force_clear:
+        self.display_manager.clear()
+    
+    # Mark as scrolling
+    self.display_manager.set_scrolling_state(True)
+    
+    try:
+        # Scroll content
+        text = "This is a long scrolling message that needs to scroll across the display..."
+        text_width = self.display_manager.get_text_width(text, self.display_manager.regular_font)
+        display_width = self.display_manager.width
+        
+        # Scroll from right to left
+        for x in range(display_width, -text_width, -2):
+            self.display_manager.clear()
+            self.display_manager.draw_text(text, x=x, y=16, color=(255, 255, 255))
+            self.display_manager.update_display()
+            time.sleep(0.05)
+            
+            # Update scroll activity timestamp
+            self.display_manager.set_scrolling_state(True)
+    finally:
+        # Always mark as not scrolling when done
         self.display_manager.set_scrolling_state(False)
 ```
 
@@ -194,8 +223,11 @@ def update(self):
     sport_key = "nhl"
     cache_key = f"{self.plugin_id}_{sport_key}_games"
     
-    # get_background_cached_data() was removed in 3.8.0 — use get()
-    cached = self.cache_manager.get(cache_key, max_age=60)
+    # Uses sport-specific live_update_interval from config
+    cached = self.cache_manager.get_background_cached_data(
+        cache_key,
+        sport_key=sport_key
+    )
     
     if cached:
         self.games = cached
@@ -222,9 +254,9 @@ def on_config_change(self, new_config):
 
 ---
 
-## Font Management
+## Font Management and Overrides
 
-The display manager's built-in fonts and text measurement. For fonts shipped with a plugin, see [FONT_MANAGER.md](FONT_MANAGER.md).
+Use the Font Manager for advanced font handling and user customization.
 
 ### Using Different Fonts
 
@@ -596,12 +628,14 @@ def update(self):
 
 ```python
 def update(self):
-    # get_enabled_plugins() was removed in 3.8.0 — check the instance's
-    # `enabled` flag instead
-    weather_plugin = self.plugin_manager.get_plugin("weather")
-    if weather_plugin is not None and weather_plugin.enabled:
-        # Use weather data
-        pass
+    # Check if another plugin is enabled
+    enabled_plugins = self.plugin_manager.get_enabled_plugins()
+    if "weather" in enabled_plugins:
+        # Weather plugin is available
+        weather_plugin = self.plugin_manager.get_plugin("weather")
+        if weather_plugin:
+            # Use weather data
+            pass
 ```
 
 ### Sharing Data Between Plugins

docs/ARCHITECTURE.md

@@ -1,416 +0,0 @@
-# Architecture
-
-A map of the codebase for a new contributor: which process does what, how
-they talk to each other, and where to start reading for common changes.
-
-## Processes
-
-| systemd unit | Runs as | Runs | Installed by |
-|---|---|---|---|
-| `ledmatrix.service` | root | [`run.py`](../run.py) → `DisplayController` | [`install_service.sh`](../scripts/install/install_service.sh) |
-| `ledmatrix-web.service` | the installing user | [`start_web_conditionally.py`](../scripts/utils/start_web_conditionally.py) → [`web_interface/start.py`](../web_interface/start.py) (Flask, port 5000) | `install_service.sh`, [`install_web_service.sh`](../scripts/install/install_web_service.sh) |
-| `ledmatrix-update-verify.path` / `.service` | the web user | Health check after an automatic update | the same installers, or [`src/auto_update_setup.py`](../src/auto_update_setup.py) at runtime |
-| `ledmatrix-wifi-monitor.service` | root | [`wifi_monitor_daemon.py`](../scripts/utils/wifi_monitor_daemon.py) | [`install_wifi_monitor.sh`](../scripts/install/install_wifi_monitor.sh) |
-| `ledmatrix-mqtt-bridge.service` | root | [MQTT bridge](../integrations/mqtt_bridge/README.md) (optional) | [`install_mqtt_bridge.sh`](../scripts/install/install_mqtt_bridge.sh) |
-| `ledmatrix-dns-fix.service` | root | DNS workaround (optional) | [`install_dns_fix.sh`](../scripts/install/install_dns_fix.sh) |
-
-Unit templates are in [`systemd/`](../systemd/README.md). The display runs as
-root because the LED matrix library needs direct GPIO access. The web
-interface runs unprivileged and uses a fixed list of `sudo` rules for the
-few privileged things it does; see [PERMISSIONS.md](PERMISSIONS.md).
-
-`start_web_conditionally.py` exits without starting Flask when
-`web_display_autostart` is explicitly false in `config.json`.
-
-## How the two main processes share state
-
-The display and the web interface are separate processes that never call
-each other. They share three things:
-
-1. **`config/config.json` and `config/config_secrets.json`.** The web
-   interface writes them through `ConfigManager`
-   ([`src/config_manager.py`](../src/config_manager.py)); the display
-   notices through `ConfigService` (below).
-2. **The disk cache**, `/var/cache/ledmatrix` (owned `root:ledmatrix`,
-   setgid, files `0660`), read and written through `CacheManager`
-   ([`src/cache_manager.py`](../src/cache_manager.py),
-   [`src/cache/disk_cache.py`](../src/cache/disk_cache.py)). Readers in the
-   other process pass `memory_ttl=0` so they do not serve a stale in-memory
-   copy.
-3. **A few files in `/tmp`.**
-
-| State | Where | Written by | Read by |
-|---|---|---|---|
-| On-demand command | control socket `/run/ledmatrix/control.sock` ([IPC_CONTROL_SOCKET.md](IPC_CONTROL_SOCKET.md)) | web: `start_on_demand_display()` / `stop_on_demand_display()` in [`api_v3/display.py`](../web_interface/blueprints/api_v3/display.py), via [`src/ipc/client.py`](../src/ipc/client.py) | display: [`src/ipc/server.py`](../src/ipc/server.py) acks; the render thread applies it in `_poll_on_demand_requests()` |
-| On-demand request (fallback) | cache `display_on_demand_request` | web, only when the socket could not carry the request (`should_fall_back`); four plugins write it directly | display: `_poll_on_demand_requests()`, a `stat()` every 1 s while the socket is up (0.25 s without), read only when the file changed |
-| On-demand state | cache `display_on_demand_state` | display: `_publish_on_demand_state()` | web: `/api/v3/display/on-demand/status` |
-| Current screen | cache `display_current_state` | display | web: `/api/v3/display/current-status` |
-| Plugin errors | cache `plugin_error_snapshot` | display: `ErrorSnapshotPublisher` ([`src/error_aggregator.py`](../src/error_aggregator.py)) | web: `read_error_report()` for `/api/v3/errors/*` |
-| Error clear | control socket `errors.clear`; cache `plugin_error_clear_request` as the fallback | web: `POST /api/v3/errors/clear` | display: applied before the socket answers; the mailbox on the error publisher's 5 s tick, read only when the file changed |
-| Font usage | cache `font_usage_snapshot` | display: `FontUsagePublisher` ([`src/font_usage.py`](../src/font_usage.py)) | web: Fonts tab |
-| Fetch statistics (requests per plugin and host) | cache `fetch_stats_snapshot` | display: `FetchStatsPublisher` ([`src/common/fetch_service.py`](../src/common/fetch_service.py)), at most once a minute on change | web: `read_fetch_stats()` for `/api/v3/plugins/fetch-stats` |
-| Plugin health | cache `plugin_health:<id>` | display (web writes on reset) | web: `/api/v3/plugins/health` |
-| Plugin runtime (loaded, state, last error, version) | cache `plugin_runtime_snapshot` | display: `PluginRuntimePublisher` ([`src/plugin_system/plugin_runtime.py`](../src/plugin_system/plugin_runtime.py)) | web: `read_plugin_runtime()` for `/api/v3/plugins/installed`, `/plugins/state`, reconciliation |
-| Preview frame | `/tmp/led_matrix_preview.png` | display: `DisplayManager`, gated by [`snapshot_policy`](../src/common/snapshot_policy.py): a changed frame at most once a second with a viewer, every 30 s without | web: display SSE stream (checks the mtime every 0.25 s), `/api/v3/health` (file age) |
-| Preview viewer marker | `/tmp/led_matrix_preview_viewer` | web, about once a second while a preview is open | display: writes viewer-rate snapshots only while it is fresh (5 s) |
-| Hardware init status | `/tmp/led_matrix_hw_status.json` | display | web: `/api/v3/hardware/status` |
-| Render-loop heartbeat | `/run/ledmatrix/display-heartbeat.json` (tmpfs) | display: the render thread, via [`display_watchdog`](../src/display_watchdog.py) | web: `/api/v3/health` (`checks.display_loop`); the update health check |
-
-The on-demand start route starts `ledmatrix.service` when it is not running
-(`start_service`, on by default) but never restarts a running one. The routes
-send the command over the display's control socket and get an ack; only when
-the socket could not carry it (a stopped display, one older than the socket
-or the command) do they write the mailbox instead. A display that had the
-request and refused it is answered with the error, not posted a mailbox
-copy. The display looks at the mailbox every
-`MAILBOX_POLL_INTERVAL_WITH_SOCKET` (1 s) while it serves the socket, and
-every `ON_DEMAND_POLL_INTERVAL` (0.25 s) without one, from its dwell sleep,
-its render loops and Vegas's interrupt check as well as the main loop; a
-look is one `stat()` unless the file changed. Both ways end in the same
-handler, `_handle_on_demand_request()`.
-The socket's handlers only queue; see [IPC_CONTROL_SOCKET.md](IPC_CONTROL_SOCKET.md)
-for the protocol, the permission model and the plan to retire the mailboxes.
-
-### Web and display processes: who runs plugins
-
-Only the display process imports plugin code, instantiates plugins and calls
-their lifecycle hooks (`update`, `display`, `on_config_change`, `on_enable`,
-`on_disable`). The web process is metadata-only: it reads plugins as files
--- manifests and directories through `PluginCatalog`
-([`src/plugin_system/plugin_catalog.py`](../src/plugin_system/plugin_catalog.py)),
-config schemas through `SchemaManager`, and each plugin's section of
-`config.json` through `ConfigManager`. The catalog keeps the
-read-only method names of `PluginManager` and has nothing that can run a
-plugin (no `load_plugin`, `get_plugin` or `plugins`).
-
-How a web-side change reaches the running plugins:
-
-| Change | How the display picks it up |
-|---|---|
-| Plugin settings saved, config reset | `ConfigService` sees the new `config.json` and calls the plugin's `on_config_change` with the prepared section |
-| Plugin enabled or disabled | `ConfigService` → `_controller_config_change` flags a reconcile; `_reconcile_enabled_plugins` loads it (fresh from disk) or unloads it on the render thread |
-| Plugin uninstalled (config removed) | the removed section flips its `enabled` flag, and the reconcile unloads it |
-| Plugin installed, not enabled | nothing to do until it is enabled, which loads it |
-| Plugin updated while enabled | the update route asks the display over the control socket (`plugin.reload`) to reload it on the render thread, and answers `restart_required: false` once the new code runs. Without the socket, as the next row |
-| Plugin installed while already enabled, updated while enabled and not reloaded, or uninstalled with its config kept | **not picked up**: the display keeps running what it loaded. The route answers `restart_required: true` and the UI shows its restart banner |
-
-`display_restart_required()` in `plugin_catalog.py` holds that last rule;
-routes return it as `restart_required` (with the banner's wording in
-`restart_message`), and `window.noteRestartRequired()` in
-`static/v3/app.js` raises the banner for any response that carries it,
-`POST /api/v3/config/main` included.
-
-Runtime state shown in the UI comes from what the display publishes to the
-shared cache: health and metrics (`/api/v3/plugins/health`,
-`/plugins/metrics`), errors (`/api/v3/errors/*`), the current mode, and the
-plugin runtime snapshot described below. `enabled` is read from
-`config.json` by the display's rule (a missing flag is disabled).
-
-Plugin code still runs in the web process in one place,
-`_import_plugin_code_in_web_process()` in
-[`api_v3/__init__.py`](../web_interface/blueprints/api_v3/__init__.py): the
-Starlark routes import the starlark-apps plugin's `tronbyte_repository` and
-`pixlet_renderer` helper modules (never the plugin class), and a web-UI
-action with `oauth_flow` imports its script for `get_auth_url()`. Every
-other web-UI action runs its script as a subprocess. A later, explicit
-**plugin web-entry contract** -- a declared entry point for plugin web code
--- replaces that function.
-
-The **control socket** from the web process to the display
-([IPC_CONTROL_SOCKET.md](IPC_CONTROL_SOCKET.md)) carries on-demand
-commands and reloads an updated plugin; its next stages stream the
-display's state and retire the cache-key mailboxes. The plugin web-entry
-contract above is still to come.
-
-### Plugin state: desired, observed, and who owns it
-
-There is one plugin state machine, and the display owns it:
-`PluginStateManager` in
-[`plugin_state.py`](../src/plugin_system/plugin_state.py) (unloaded →
-loaded → enabled ⇄ running, error, disabled), held by the display's
-`PluginManager`. It also records, per loaded plugin, the manifest version it
-loaded and when. Nothing else keeps plugin state:
-
-| Question | Answered by |
-|---|---|
-| Is it installed, at which version? | the plugins directory (`manifest.json`) |
-| Should it run? | `config.json` (`<id>.enabled`, missing = disabled) |
-| Has the user uninstalled it for good? | the store's uninstalled-plugins record |
-| Is the display running it, at which version, and why not? | the display's runtime snapshot |
-
-**The runtime snapshot.** `PluginRuntimePublisher`
-([`plugin_runtime.py`](../src/plugin_system/plugin_runtime.py)), started by
-`DisplayController` right after it creates the `PluginManager`, writes the
-cache key `plugin_runtime_snapshot`: per plugin `loaded`, `state`, `error`
-(type, a redacted message of at most 200 characters, when, recoverable),
-`version`, `loaded_at` and `modes` (the display modes `DisplayController`
-registered -- `plugin.modes` when the plugin computes them, else the
-manifest's), plus `published_at`, `stale_after` and `running`.
-The cache is on disk, usually the SD card, so it writes when something a
-reader sees changes -- throttled to once per 10 s -- and otherwise once a
-minute as a heartbeat. RUNNING, which every `update()` passes through, is
-published as ENABLED, so plugin updates alone never cause a write.
-`cleanup()` publishes `running: false`.
-
-**Reading it.** `read_plugin_runtime()` judges the snapshot before anyone
-uses it: `live` (fresh, from a running display), `stale` (older than
-`stale_after`, 3 minutes: a hung or crashed display), `stopped` or
-`unknown` (none, unreadable, or another schema). Only a live view reports
-per-plugin facts; every other status answers `null` for them, so stale
-truth cannot leak into a response. `/api/v3/plugins/installed` returns
-`loaded`, `state`, `error_info`, `loaded_version` and `loaded_at` per
-plugin and `data.runtime` (`status`, `published_at`, `age_seconds`);
-`/api/v3/plugins/state` returns the same beside the desired state.
-`PluginCatalog.get_plugin_display_modes` and `find_plugin_for_mode` prefer a
-live view's `modes` to the manifest's `display_modes`, so `/display/modes`
-and on-demand see modes a plugin generates from its config (#668).
-
-**Reconciliation**
-([`state_reconciliation.py`](../src/plugin_system/state_reconciliation.py))
-compares desired state (config + disk) with observed state (the snapshot).
-It fixes desired-state gaps -- a plugin on disk with no config section gets
-`{"enabled": false}`, a configured plugin missing from disk is reinstalled
-unless the user uninstalled it -- and only reports observed-state gaps
-(enabled but not loaded, loaded at an older version): the display loads and
-unloads by config on its own, and a version gap needs a restart.
-
-**`data/plugin_state.json` is retired.** The web process used to keep a
-second `PluginStateManager` (`state_manager.py`) persisted to that file:
-per plugin an enabled flag copied from config, a version copied from the
-manifest (when set at all), a status derived from those, and install/update
-timestamps. Reconciliation mostly synced it back to config and backups
-merged it into their plugin list. Every field is derivable (the timestamps
-from the operation history), so nothing is migrated: no code reads or
-writes the file, and a copy left on a device is inert and safe to delete.
-The two classes shared a name but not a concern -- a persisted install
-record versus the live lifecycle -- so they were not merged; the persisted
-one had nothing left to hold and was removed.
-
-## Display loop
-
-[`src/display_controller.py`](../src/display_controller.py), class
-`DisplayController`. `__init__` loads config, starts the cache and the
-error-snapshot publisher, runs the startup validator, creates the
-`DisplayManager` ([`src/display_manager.py`](../src/display_manager.py)),
-`FontManager` and `PluginManager`, loads the enabled plugins in parallel,
-runs an initial `update()` pass within a 20-second budget
-(`_INITIAL_UPDATE_BUDGET_SECONDS`; a plugin that misses it is deferred to
-the scheduler), and sets up Vegas mode.
-
-`run()` is the main loop. Each pass, in order: apply a pending plugin
-enable/disable, poll on-demand requests, run scheduled plugin updates, check
-the on/off schedule and brightness, then show one screen. Priority is
-on-demand, then WiFi status messages, then live priority, then Vegas mode,
-then normal rotation. [RUN_LOOP_REDESIGN.md](RUN_LOOP_REDESIGN.md) is the
-plan for restructuring this loop and lists its golden trace tests.
-
-- **Rotation.** `available_modes` is the ordered list of display modes;
-  `current_mode_index` advances after each screen.
-  `_apply_plugin_rotation_order()` applies `display.plugin_rotation_order`.
-- **Durations.** `_get_display_duration()`: `display.display_durations[mode]`,
-  else the plugin's `get_display_duration()`, else 30 s. Plugins that
-  support dynamic duration run until `is_cycle_complete()`, capped by
-  `display.dynamic_duration.max_duration_seconds` (default 180 s).
-- **On-demand.** A request from the web interface pins one plugin (or mode)
-  for a duration. `_activate_on_demand()` / `_clear_on_demand()`; the
-  session is saved under `display_on_demand_config` so it survives a
-  restart. It also keeps the display on during scheduled off hours. A
-  request for a plugin that is disabled in config loads it live
-  (`_load_plugin_for_on_demand()`, `load_plugin(force_enabled=True)`)
-  without writing `config.json`; the main loop unloads it once on-demand
-  moves off it (`_release_on_demand_plugins()`).
-- **Live priority.** `_check_live_priority()` looks for a plugin whose
-  `has_live_priority()` and `has_live_content()` are both true and switches
-  to it, rotating between several live games.
-- **Schedule and dim schedule.** `_check_schedule()` reads `schedule`;
-  `_check_dim_schedule()` reads `dim_schedule` and
-  `display.hardware.brightness`. Both are re-evaluated once a minute, and
-  both windows are half-open: on (or dimmed) from the start time, off at
-  the end time. When an on-demand session ends, the on/off schedule is
-  re-checked at once rather than at the next minute.
-- **Long screens.** While a screen is showing (a dwell, a scroll, a Vegas
-  iteration), `_service_pending_changes()` repeats the on-demand, schedule
-  and brightness checks every 0.25 s, so a change does not wait for the
-  screen to end.
-- **Config hot reload.** `ConfigService`
-  ([`src/config_service.py`](../src/config_service.py)) polls the config and
-  secrets files' mtimes every 2 s and notifies subscribers when the content
-  changes. The controller refreshes its cached settings; enabling or
-  disabling a plugin queues `_reconcile_enabled_plugins()`, which loads or
-  unloads it on the display thread; each plugin gets `on_config_change()`
-  for its own section, under its plugin lock
-  (`PluginManager.apply_config_change()`). Set `LEDMATRIX_HOT_RELOAD=false` to turn this off.
-  Matrix hardware settings are only read at start-up.
-- **Vegas mode.** [`src/vegas_mode/`](../src/vegas_mode/): the display loop
-  calls `VegasModeCoordinator.run_iteration()`
-  ([`coordinator.py`](../src/vegas_mode/coordinator.py)) when
-  `display.vegas_scroll.enabled` is set. `PluginAdapter` gets each plugin's
-  content (`get_vegas_content()`, else its `scroll_helper` image, else a
-  capture of `display()`), `StreamManager` orders it and `RenderPipeline`
-  scrolls it. See [ADVANCED_FEATURES.md](ADVANCED_FEATURES.md).
-- **Multi-display sync.** `DisplaySyncManager`
-  ([`src/common/sync_manager.py`](../src/common/sync_manager.py)), enabled by
-  `sync.role`: a leader sends a follower its share of each frame over UDP
-  (port 5765).
-
-### Liveness
-
-A render thread stuck inside a plugin leaves the service "active" and the
-panel frozen, so liveness is reported by the render thread itself
-([`src/display_watchdog.py`](../src/display_watchdog.py), standard library
-only). `beat()` from any other thread is ignored: the update worker, Vegas's
-tick thread and the prefetcher keep running while the render thread is stuck,
-and must not vouch for it.
-
-- **Check-in points.** The top of `run()`'s loop (`loop_pass()`), every
-  dwell second (`_sleep_with_plugin_updates`), every frame of the per-screen
-  loops (`_display_once`), every frame of Vegas's own loop and static pause
-  (`coordinator.run_iteration`), each plugin fetched for a Vegas cycle
-  (`StreamManager._fetch_plugin_content`), each update on the
-  `synchronous_updates` path, and every frame pushed
-  (`DisplayManager.update_display` -> `note_frame()`). Beats are
-  rate-limited to one ping and one heartbeat write every 5 s.
-- **systemd watchdog.** `ledmatrix.service` is `Type=simple` with
-  `WatchdogSec=120` and `NotifyAccess=main`. `run.py` sends
-  `WATCHDOG_USEC` = 15 minutes before importing anything heavy (start-up loads
-  plugins and runs the 20 s update budget, and the watchdog clock starts with
-  the process). After the first frame -- or the first full pass, when there is
-  nothing to draw -- the loop sends `READY=1`, restores the unit's 120 s and
-  pings. `PluginManager.load_plugin()` on the render thread (a plugin enabled
-  from the web UI, or loaded for on-demand) gets 15 minutes again, since it
-  can run pip. A missed deadline is a SIGABRT; faulthandler, enabled on
-  arming, dumps every thread's stack to the journal.
-- **Heartbeat.** `/run/ledmatrix/display-heartbeat.json`
-  (`{"pid", "mono", "wall"}`; `RuntimeDirectory=ledmatrix`, 0755, file 0644 so
-  the web user can read it). Readers compare `mono` with their own
-  `time.monotonic()` -- CLOCK_MONOTONIC is shared by every process and does not
-  jump when NTP first sets an RTC-less Pi's clock. `/api/v3/health` calls it
-  `stalled` past 60 s; no file is `not_reported` and changes nothing. A clean
-  stop removes it. Without `RuntimeDirectory=` (an older unit) the display,
-  as root, creates the directory itself; off Linux, or without root, there
-  is no heartbeat.
-
-## Plugin system
-
-[`src/plugin_system/`](../src/plugin_system/):
-
-| Area | Where |
-|---|---|
-| Base class plugins implement | [`base_plugin.py`](../src/plugin_system/base_plugin.py) (`BasePlugin`, `VegasDisplayMode`) |
-| Finding a plugin's directory | [`plugin_dirs.py`](../src/plugin_system/plugin_dirs.py): manifest `id` first, then directory `<id>` or `ledmatrix-<id>` |
-| Discovery, load, unload, scheduled updates (display process) | [`plugin_manager.py`](../src/plugin_system/plugin_manager.py) (`PluginManager`) |
-| Manifest reads (web process) | [`plugin_catalog.py`](../src/plugin_system/plugin_catalog.py) (`PluginCatalog`; see [who runs plugins](#web-and-display-processes-who-runs-plugins)) |
-| Import and instantiate | [`plugin_loader.py`](../src/plugin_system/plugin_loader.py) (`PluginLoader.load_plugin()`: dependencies, module, class) |
-| Timeouts | [`plugin_executor.py`](../src/plugin_system/plugin_executor.py) (`PluginExecutor`, 30 s default; a timed-out thread is abandoned, not killed) |
-| Circuit breaker | [`plugin_health.py`](../src/plugin_system/plugin_health.py) (`PluginHealthTracker`: 3 consecutive failures open the circuit for 300 s) |
-| Resource metrics | [`resource_monitor.py`](../src/plugin_system/resource_monitor.py) |
-| Config schemas and defaults | [`schema_manager.py`](../src/plugin_system/schema_manager.py) |
-| Install, update, uninstall | [`store_manager.py`](../src/plugin_system/store_manager.py) (`PluginStoreManager`), with its methods split across [`store_registry.py`](../src/plugin_system/store_registry.py) (registry, GitHub), [`store_install.py`](../src/plugin_system/store_install.py) and [`store_update.py`](../src/plugin_system/store_update.py) |
-| Core-version gate | [`compatibility.py`](../src/plugin_system/compatibility.py) |
-
-Discovery scans only `plugin_system.plugins_directory` (default
-`plugin-repos/`). Scheduled `update()` calls run on one background worker
-thread; a per-plugin lock keeps `display()` from running during an update.
-
-**Store flow.** `install_plugin()` renames any existing copy aside
-(`<id>.standalone-backup-preinstall`), installs the new one, and puts the old
-copy back if the install fails. Monorepo plugins come from the GitHub Trees
-API, falling back to the repository ZIP; other plugins by `git clone` or
-download. The manifest is checked (see
-[required fields](PLUGIN_API_REFERENCE.md#manifest-required-fields)), the core
-version gate runs, then dependencies are installed as root through
-`scripts/fix_perms/safe_pip_install.sh`. `update_plugin()` pulls git
-installs, undoing a pull whose new version is incompatible, and reinstalls
-everything else through `_reinstall_with_rollback()`.
-
-## Web interface
-
-- **App.** [`web_interface/app.py`](../web_interface/app.py) builds the
-  Flask `app` at import time, creates the managers -- a `PluginCatalog`,
-  never a `PluginManager` -- and registers two blueprints.
-  `web_interface/start.py` runs it on port 5000.
-- **Pages.** [`blueprints/pages_v3.py`](../web_interface/blueprints/pages_v3.py)
-  serves the shell `templates/v3/base.html` at `/` and each tab as a
-  partial at `/partials/<name>` (templates in
-  `web_interface/templates/v3/partials/`). Plugin configuration tabs are
-  rendered from the plugin's schema by `plugin_config.html`.
-- **API.** [`blueprints/api_v3/`](../web_interface/blueprints/api_v3/) is one
-  blueprint at `/api/v3`, split by area: `backup.py`, `config.py`,
-  `display.py`, `fonts.py`, `misc.py` (health, logs, errors, cache, sync),
-  `starlark.py`, `system.py` (service actions, updates, git), `wifi.py`, and
-  the plugin routes: `plugins.py` (installed list, enable/disable, plugin
-  actions), `plugin_store.py` (install, update, uninstall, store),
-  `plugin_config.py` (config, schema, reset), `plugin_assets.py` (uploads,
-  plugin static files), `plugin_health.py` (health, metrics, limits),
-  `plugin_operations.py` (operation history, state reconciliation) and
-  `plugin_calendar.py`. `__init__.py` defines the blueprint and shared helpers and
-  imports the modules so their routes register. Endpoints are listed in
-  [REST_API_REFERENCE.md](REST_API_REFERENCE.md).
-- **Front end.** HTMX loads each tab's partial on first open
-  (`hx-trigger="loadtab"`); Alpine.js holds page state. Scripts are in
-  `web_interface/static/v3/js/`; form widgets are bundled from
-  [`js/widgets/`](../web_interface/static/v3/js/widgets/README.md).
-- **Server-sent events** (`app.py`): `/api/v3/stream/stats` (CPU, memory,
-  temperature, service state, every 10 s), `/api/v3/stream/display` (preview
-  frames when the PNG changes) and `/api/v3/stream/logs` (journal of both
-  services). One generator thread per stream is shared by all clients.
-
-## Updates
-
-- **Update Code** on the Overview tab and the automatic updater both call
-  `perform_core_update()` in
-  [`api_v3/system.py`](../web_interface/blueprints/api_v3/system.py):
-  fetch branches and tags, move the checkout for the update channel, reinstall
-  changed requirement files, report whether a restart is needed.
-- **Update channels** (`auto_update.channel`):
-  [`web_interface/update_channel.py`](../web_interface/update_channel.py)
-  decides the move. `stable` checks out the newest `vX.Y.Z` tag (detached
-  HEAD) when it contains the current commit; `beta` is
-  `git pull --rebase --autostash` on the current branch, and leaves a
-  detached release for `main` first. A stable device newer than the newest
-  release keeps pulling `main` until a release contains its commit, so no
-  update ever moves backwards; a config without the key is written as
-  `stable` once the device reaches a release. Checkouts carry uncommitted
-  edits across with `git stash create`/`apply`, and keep them in the stash
-  list if they no longer apply.
-- **Automatic updates** (`auto_update.enabled`, off by default):
-  `AutoUpdater` in [`web_interface/auto_update.py`](../web_interface/auto_update.py)
-  runs in the web process, checks every 30 minutes, and updates at most
-  weekly between 02:00 and 05:00. Before pulling it copies
-  [`scripts/utils/auto_update_verify.py`](../scripts/utils/auto_update_verify.py)
-  to `data/auto_update_verifier.py`, then writes
-  `data/auto_update_verify.request`. That file triggers
-  `ledmatrix-update-verify.path`, which runs the verifier as a separate unit
-  (so restarting the web service does not kill it). The verifier restarts
-  both services, waits for the web API to answer and the display service to
-  stay up -- and, when the display wrote a heartbeat before the update, to
-  keep one fresh from the restarted process (see Liveness) -- and on failure
-  returns to where HEAD was (the branch, or detached on the previous
-  release; `old_ref` in the pending file), resets to the previous commit
-  and restarts again.
-  Plugin updates run only after a verified core update. State is in
-  `data/auto_update_state.json` and `data/auto_update_pending.json`.
-- **Startup validator.** `StartupValidator`
-  ([`src/startup_validator.py`](../src/startup_validator.py)) runs twice in
-  `DisplayController.__init__`: config and cache directory first, then
-  enabled plugins once the plugin manager exists. It also warns when an
-  installed systemd unit differs from its template in `systemd/`. Results
-  are logged; startup continues either way. Nothing rewrites installed units
-  on update: a unit change such as the watchdog reaches an existing install
-  only when `install_service.sh` is re-run.
-
-## Where to start reading
-
-| Task | Start with |
-|---|---|
-| Change rotation, durations or priorities | `DisplayController.run()` and `_get_display_duration()` in [`display_controller.py`](../src/display_controller.py) |
-| Add a config key | [CONFIG_REFERENCE.md](CONFIG_REFERENCE.md), [`config/config.template.json`](../config/config.template.json), the tab's partial and `api_v3/config.py` |
-| Change drawing or fonts | [`display_manager.py`](../src/display_manager.py), [`font_manager.py`](../src/font_manager.py), [`src/common/bdf_font.py`](../src/common/bdf_font.py) |
-| Add a plugin-facing API | [`base_plugin.py`](../src/plugin_system/base_plugin.py) or [`src/common/`](../src/common/README.md); document it in [PLUGIN_API_REFERENCE.md](PLUGIN_API_REFERENCE.md) |
-| Plugin install/update bugs | `PluginStoreManager` in [`store_manager.py`](../src/plugin_system/store_manager.py) |
-| A plugin that won't load | `PluginManager.load_plugin()` and `PluginLoader.load_plugin()`; `python3 scripts/check_plugin.py --plugin <id>` |
-| Add an API endpoint | the matching module in [`api_v3/`](../web_interface/blueprints/api_v3/) |
-| Add a web UI tab or control | `templates/v3/base.html`, the tab's partial, `pages_v3.py` |
-| Vegas scroll | [`src/vegas_mode/coordinator.py`](../src/vegas_mode/coordinator.py) |
-| Installer or permissions | [`first_time_install.sh`](../first_time_install.sh), [`scripts/install/`](../scripts/install/), [PERMISSIONS.md](PERMISSIONS.md) |
-| Work without a Pi | [DEV_PREVIEW.md](DEV_PREVIEW.md), [EMULATOR_SETUP_GUIDE.md](EMULATOR_SETUP_GUIDE.md), [HOW_TO_RUN_TESTS.md](HOW_TO_RUN_TESTS.md) |

docs/CONFIG_DEBUGGING.md

@@ -172,14 +172,10 @@ ERROR - Plugin football-scoreboard configuration validation failed: 'api_key' is
 
 ### Enable Debug Logging
 
-Run the display in the foreground with `-d`, or set `LEDMATRIX_DEBUG=true`
-(the value must be `true`; `1` is ignored — see `setup_logging()` in
-[`src/logging_config.py`](../src/logging_config.py)):
+Set environment variable:
 ```bash
-sudo systemctl stop ledmatrix.service
-sudo python3 run.py -d
-# or
-sudo LEDMATRIX_DEBUG=true python3 run.py
+export LEDMATRIX_DEBUG=1
+python run.py
 ```
 
 ### Check Merged Configuration
@@ -254,21 +250,14 @@ WARNING - Plugin ID 'Football-Scoreboard' may conflict with 'football-scoreboard
 
 ## Checking Configuration via API
 
-The API blueprint (`web_interface/blueprints/api_v3/`) is registered at
-`/api/v3` in `web_interface/app.py`.
+The API blueprint mounts at `/api/v3` (`web_interface/app.py:144`).
 
 ```bash
-# Get full main config (includes all plugin sections; credential-named
-# fields are blanked in the response)
+# Get full main config (includes all plugin sections)
 curl http://localhost:5000/api/v3/config/main
 
-# Change some settings: only the keys you send are changed
+# Save updated main config
 curl -X POST http://localhost:5000/api/v3/config/main \
-  -H "Content-Type: application/json" \
-  -d '{"timezone": "America/Chicago", "brightness": 80}'
-
-# Replace config.json wholesale (advanced)
-curl -X POST http://localhost:5000/api/v3/config/raw/main \
   -H "Content-Type: application/json" \
   -d @new-config.json
 
@@ -280,10 +269,8 @@ curl "http://localhost:5000/api/v3/plugins/config?plugin_id=football-scoreboard"
 ```
 
 > There is no dedicated `/config/plugin/<id>` or `/config/validate`
-> endpoint. `POST /plugins/config` validates against the plugin's schema
-> and rejects an invalid config with `400`; `POST /config/main` checks the
-> individual fields it knows (display hardware values, durations, Vegas
-> and sync settings). See
+> endpoint — config validation runs server-side automatically when you
+> POST to `/config/main` or `/plugins/config`. See
 > [REST_API_REFERENCE.md](REST_API_REFERENCE.md) for the full list.
 
 ## Backup and Recovery
@@ -296,12 +283,9 @@ cp config/config.json config/config.backup.json
 
 ### Automatic Backups
 
-LEDMatrix creates backups before saves (`src/config_manager_atomic.py`):
+LEDMatrix creates backups before saves:
 - Location: `config/backups/`
-- Format: `config.json.backup.YYYYMMDD_HHMMSS_ffffff` (microseconds last),
-  plus a matching `config_secrets.json.backup.<timestamp>` when a secrets
-  file exists
-- The five most recent are kept
+- Format: `config_YYYYMMDD_HHMMSS.json`
 
 ### Recovery
 
@@ -310,7 +294,7 @@ LEDMatrix creates backups before saves (`src/config_manager_atomic.py`):
 ls -la config/backups/
 
 # Restore from backup
-cp config/backups/config.json.backup.20240115_120000_000000 config/config.json
+cp config/backups/config_20240115_120000.json config/config.json
 ```
 
 ## Troubleshooting Checklist
@@ -325,10 +309,8 @@ cp config/backups/config.json.backup.20240115_120000_000000 config/config.json
 
 ## Getting Help
 
-1. Check logs. Both services log to journald, not to a file:
-   `sudo journalctl -u ledmatrix.service -f` (display) and
-   `sudo journalctl -u ledmatrix-web.service -f` (web interface)
-2. Enable debug: `LEDMATRIX_DEBUG=true` or `python3 run.py -d`
+1. Check logs: `tail -f logs/ledmatrix.log`
+2. Enable debug: `LEDMATRIX_DEBUG=1`
 3. Check error dashboard: `/api/v3/errors/summary`
 4. Validate JSON: https://jsonlint.com/
 5. File an issue: https://github.com/ChuckBuilds/LEDMatrix/issues

docs/CONFIG_REFERENCE.md

@@ -1,198 +0,0 @@
-# Configuration Reference
-
-Every key in `config/config.json`, what it does, its default, and where the
-code reads it. The file is created from `config/config.template.json` on
-first run, and `ConfigManager._migrate_config()` merges any template keys
-added by later releases into your existing config (your values are never
-overwritten). Secrets live in `config/config_secrets.json` and are merged
-into the config at load time.
-
-Most settings are editable from the web interface; this page documents the
-underlying keys for people editing `config.json` directly or writing
-tooling against it.
-
-## Top level
-
-| Key | Type / default | Meaning | Read by |
-|---|---|---|---|
-| `web_display_autostart` | bool, `true` | Whether the web interface service starts with the system | `scripts/utils/start_web_conditionally.py` |
-| `auto_update.enabled` | bool, `false` | Weekly automatic updates: LEDMatrix code first (health-checked, rolled back on failure), then installed plugins. Toggle in the General tab or install with `first_time_install.sh --enable-auto-update` | `web_interface/auto_update.py`, `src/auto_update_setup.py` (`is_enabled()`) |
-| `auto_update.channel` | `"stable"` or `"beta"`, `"stable"` (template) | What Update Code and the weekly update install. `stable`: the newest `vX.Y.Z` release tag (pre-releases ignored), checked out with a detached HEAD. `beta`: `main`. Never moves a device backwards: one newer than the newest release keeps following `main` until a release contains its commit. Missing (configs from before channels) behaves like `stable` and is saved as `stable` once the device is on a release. General tab, Update Channel | `web_interface/update_channel.py` (`resolve()`) |
-| `timezone` | string, `"America/New_York"` | IANA timezone for schedules and displays | `ConfigManager.get_timezone()` |
-| `target_fps` | int, `100` | Legacy "Scroll Frame Rate". Core scrolling no longer reads it: scroll frames are presented at `display.hardware.limit_refresh_rate_hz` divided by each scroll's frame hold, and speed comes from each plugin's scroll settings. Still exposed to plugins via `BasePlugin.global_config` | `src/plugin_system/base_plugin.py` |
-| `location` | object | `city` / `state` / `country`. Supplies the **default** for a plugin's own `location_city` / `location_state` / `location_country` setting, so weather, radar and friends follow this device without being configured twice. A value saved on the plugin itself still overrides it. Starlark (Tidbyt) apps get the same treatment: a `Location` field left blank on the app renders at this city (geocoded once via Open-Meteo, coordinates cached permanently) instead of the app author's default, which is usually San Francisco. If the city can't be looked up (no match, or the geocoder is unreachable; retried after 30 minutes), the app keeps its own default. | `SchemaManager.apply_device_location()`, then plugins via merged config; `src/device_location.py` for Starlark apps |
-
-## `schedule` — display on/off hours
-
-| Key | Type / default | Meaning |
-|---|---|---|
-| `enabled` | bool, `false` | Master switch for scheduled display on/off |
-| `mode` | `"global"` or `"per-day"`, template uses `"per-day"` | Whether one time range applies to all days or each day has its own |
-| `start_time` / `end_time` | `"HH:MM"`, `07:00`–`23:00` | Global-mode on/off times |
-| `days.<weekday>.{enabled,start_time,end_time}` | per-day objects | Per-day-mode overrides |
-
-The display is on from `start_time` up to, but not including, `end_time`:
-with `07:00`–`23:00` it turns on at 07:00 and off at 23:00. An end earlier
-than the start crosses midnight (`22:00`–`07:00` is on overnight). In
-per-day mode, the entry for the current day decides. An on-demand session
-keeps the display on during off hours; once it ends or is stopped, the
-display blanks within about a second.
-
-Read by `DisplayController._check_schedule()` (`src/display_controller.py`).
-Managed in the web UI under Schedule.
-
-## `dim_schedule` — scheduled brightness dimming
-
-Same shape as `schedule` (the template sets its `mode` to `"global"`), plus:
-
-| Key | Type / default | Meaning |
-|---|---|---|
-| `dim_brightness` | int, `30` | Brightness percentage applied while the dim window is active |
-
-Read by `DisplayController._check_dim_schedule()` (`src/display_controller.py`;
-saved via `POST /api/v3/config/dim-schedule`). The display returns to
-`display.hardware.brightness` outside the window. The window has the same
-boundaries as `schedule`: dimmed from `start_time` up to, but not including,
-`end_time`.
-
-## `display.hardware` — matrix panel hardware
-
-All keys map to the corresponding `rpi-rgb-led-matrix` options and are read
-in `DisplayManager._setup_matrix` (`src/display_manager.py`). Defaults are the
-`config/config.template.json` values: `ConfigManager` adds any key missing from
-`config.json` from the template on load, so `DisplayManager`'s own fallbacks
-don't apply on a normal install.
-
-The ranges are what the pinned rgbmatrix library and its Python binding accept
-(`src/matrix_support.py`). The config API refuses anything else; a value
-hand-edited into `config.json` makes the display log the setting and run in
-fallback mode instead of starting the matrix.
-
-| Key | Type / default |
-|---|---|
-| `rows` / `cols` | int, `32` / `64` — rows: even, 8–64; cols: at least 16 |
-| `chain_length` | int, `2` — 1–255 (the Python binding stores it in one byte) |
-| `parallel` | int, `1` — 1–3, and no more than `hardware_mapping` has outputs (`regular`, `classic`: 3; the others: 1) |
-| `brightness` | int, `90` — 1–100 |
-| `hardware_mapping` | string, `"adafruit-hat"` — `"adafruit-hat-pwm"`, `"adafruit-hat"`, `"regular"`, `"regular-pi1"`, `"classic"` or `"classic-pi1"` (case-insensitive; `compute-module` isn't in the installed build). A Pi 5 doesn't support `"classic-pi1"` |
-| `scan_mode` | int, `0` — `0` progressive, `1` interlaced |
-| `pwm_bits` | int, `9` — 1–11 |
-| `pwm_dither_bits` | int, `1` — 0–2 |
-| `pwm_lsb_nanoseconds` | int, `130` — 50–3000 |
-| `disable_hardware_pulsing` | bool, `false` — `true` times brightness pulses in software (less exact); hardware pulsing needs the OE line on GPIO 18 and the Pi's onboard sound driver off |
-| `inverse_colors` | bool, `false` |
-| `show_refresh_rate` | bool, `false` — prints the refresh rate to stdout; draws nothing on the panel |
-| `led_rgb_sequence` | string, `"RGB"` — `"RGB"`, `"RBG"`, `"GRB"`, `"GBR"`, `"BRG"` or `"BGR"` |
-| `limit_refresh_rate_hz` | int, `100` — `0` = no cap; scroll timing assumes 100 Hz when `0` |
-| `pixel_mapper_config` | string, `""` — e.g. `"U-mapper"` / `"Rotate:90"`; mappers that rotate or fold the chain change the display size plugins and the web preview see |
-| `orientation` | string, `"normal"` — `"180"` rotates the rendered image 180° for panels physically mounted upside down (e.g. to move the Pi/wiring to a more convenient side); `"90"` / `"270"` for a panel on its side, swapping width and height; composed onto `pixel_mapper_config` as a trailing `Rotate:<degrees>` mapper, so it stays independent of any custom `pixel_mapper_config` value |
-| `row_address_type` | int, `0` — non-standard panel row addressing: `1` AB, `2` direct row select, `3` ABC, `4` ABC shift + DE direct, `5` SM5368 / B707 row shift register (e.g. Waveshare 96x48 V2, with `led_rgb_sequence` `"BGR"`). On a Pi 5 the library supports only `0` and `2`, and LEDMatrix enforces that (`src/pi5_matrix_support.py`) |
-| `multiplexing` | int, `0` — 0–22, pixel wiring scheme for outdoor/specialty panels (names listed in the README) |
-| `panel_type` | string, `""` — set to `"FM6126A"` or `"FM6127"` for panels needing init; FM6124 / FM6124D / FM6124DJ panels need none, so leave it `""` |
-
-## `display.runtime`
-
-| Key | Type / default | Meaning |
-|---|---|---|
-| `gpio_slowdown` | int, `3` | GPIO timing slowdown for faster Pis (0–10). On a Pi 5 in PIO mode start at `1` (`0` acts as `1`) and raise it if the image flickers or shows garbage. Panels on `row_address_type` `5` (SM5368 row drivers) can need 6–8 on a Pi 4 — lower values make rows jump |
-| `rp1_rio` | int, `0` | Pi 5 only: `0` = PIO (less CPU), `1` = RIO (higher refresh; `gpio_slowdown` effect inverted). Applied only if the installed matrix library supports it |
-
-## `display.double_sided`
-
-Drives `_LogicalMatrix` in `src/display_manager.py` — renders the same
-logical image to multiple chained physical panels.
-
-| Key | Type / default | Meaning |
-|---|---|---|
-| `enabled` | bool, `false` | Mirror output across panel copies |
-| `copies` | int, `2` | Number of physical copies in the chain |
-| `axis` | `"horizontal"`, default | Axis along which panels are chained |
-
-## `display` — other keys
-
-| Key | Type / default | Meaning | Read by |
-|---|---|---|---|
-| `display_durations` | object, `{}` | Per-plugin display duration in seconds, keyed by plugin id (e.g. `"clock": 15`) | `DisplayController._get_display_duration()` (`src/display_controller.py`) |
-| `plugin_rotation_order` | array, `[]` | Explicit rotation order of plugin ids; empty = all enabled plugins in discovery order | `DisplayController._apply_plugin_rotation_order()` (`src/display_controller.py`) |
-| `use_short_date_format` | bool, `true` | Compact date rendering in sports scoreboards | Nothing since `src/base_classes` was removed; scoreboards read `display.use_short_date_format` from their own plugin config |
-| `scan_order_compensation` | string, `"auto"` | `"auto"` shows one half of each panel a refresh behind while something scrolls at one frame per refresh, which removes the 1px step a 1:N-scan panel shows across its middle; `"off"` disables it. Applies only to layouts whose row order is known: plain or parallel chains, 0 or 180 degree orientation, `multiplexing` 0, `scan_mode` 0, and not in the emulator | `DisplayManager._setup_scan_order_compensation()` (`src/display_manager.py`, `src/scan_order.py`) |
-| `dynamic_duration.max_duration_seconds` | int, optional | Cap for plugins that request dynamic display time | `DisplayController._get_global_dynamic_cap()` (`src/display_controller.py`) |
-
-## `display.vegas_scroll` — continuous scroll mode
-
-Read by `src/vegas_mode/config.py` (`VegasScrollConfig.from_config`). See
-[ADVANCED_FEATURES.md](ADVANCED_FEATURES.md) for behavior details, including
-[live content in the ticker](ADVANCED_FEATURES.md#live-content-in-the-ticker).
-
-| Key | Type / default |
-|---|---|
-| `enabled` | bool, `false` |
-| `scroll_speed` | int, `50` (px/s) |
-| `separator_width` | int, `32` |
-| `plugin_order` | array, `[]` |
-| `excluded_plugins` | array, `[]` |
-| `target_fps` | int, `125` |
-| `buffer_ahead` | int, `2` |
-| `intra_plugin_gap` | int, `8` |
-| `render_width_pct` | int, `100` |
-| `min_content_separation` | int, `24` |
-| `min_cut_gap` | int, `6` |
-| `continuous_scroll` | bool, `true` |
-| `offscreen_prefetch` | bool, `true` — render every plugin's ticker content on the background thread, each on its own canvas. `false` restores handing canvas-bound plugins to the render thread, one pause at a time. Temporary; see [OFFSCREEN_RENDERING.md](OFFSCREEN_RENDERING.md) |
-| `prefetch_gate` | bool, `true` — let that background thread run Python only while the render thread is waiting for the panel, so the render thread never waits for the GIL when a refresh comes round. Only takes effect with the rebuilt rgbmatrix binding (`scripts/build_rgbmatrix_nogil.sh`). See [OFFSCREEN_RENDERING.md](OFFSCREEN_RENDERING.md) |
-| `switch_interval_ms` | float, `0` — experimental: shorten Python's GIL switch interval to this many ms while Vegas runs. `0` leaves the default (5 ms) alone |
-| `live_refresh` | bool, `true` — live elements: a plugin that supports them (scores, the flight map) has what is already scrolling updated when its data changes, instead of freezing each card as it was drawn. Always off under multi-display sync, in swap mode and with `offscreen_prefetch` off. `false` restores the frozen behaviour exactly. Per plugin: `vegas_live` in the plugin's section |
-| `live_max_hz` | float, `5` (0–10) — ceiling on how often an animated live element (a moving aircraft) is redrawn; `0` keeps data updates and turns animation off. Capped at 1 Hz without the rebuilt rgbmatrix binding |
-| `live_min_interval` | float, `2` (0.5–60) — shortest time between two data redraws of one plugin; a faster plugin is redrawn at this rate, never skipped |
-| `live_lead_screens` | float, `1` (0–5) — how far ahead of the screen, in screen widths, an animated element starts being redrawn |
-| `smooth_scroll` | bool, `true` — move a whole number of pixels per panel refresh, locked to vsync. `scroll_speed` is snapped to the nearest speed the panel can show that way (at 95Hz: 95, 47.5, 31.7 px/s…), measured against the panel's real refresh rate once scrolling starts |
-| `sub_pixel_blend` | bool, `false` — the older smoothing: advance by elapsed time and blend neighbouring pixel columns. Looks anti-aliased in the web preview but shimmers on the panel and is not locked to the refresh. Overrides `smooth_scroll` when on |
-| `extend_threshold_screens` | float, `2.0` |
-| `auto_trim` | bool, `true` |
-| `trim_threshold` | int, `10` |
-| `content_padding` | int, `8` |
-| `min_plugin_width` | int, `8` |
-| `lead_in_width` | int, `0` |
-| `plugins_per_cycle` | int, `6` |
-| `max_plugin_width_ratio` | float, `0.0` |
-| `overflow_mode` | string, `"rotate"` |
-| `dynamic_duration_enabled` | bool, `true` |
-| `min_cycle_duration` | int, `60` |
-| `max_cycle_duration` | int, `240` |
-| `frame_based_scrolling` | bool, `true` — does not step or set a frame rate; motion is by elapsed time either way. When `true`, `scroll_speed` passes through a clamp of 0.1–5 px per `scroll_delay` (see next row) |
-| `scroll_delay` | float, `0.02` — not a frame period. Only used with `frame_based_scrolling`: the applied speed is `clamp(scroll_speed × scroll_delay, 0.1, 5) / scroll_delay` px/s, so at `0.02` speeds under 5 px/s run at 5, and at `0.001` nothing runs slower than 100 px/s |
-| `live_in_ticker` | bool, `true` — keep scrolling during live games instead of handing the display to a full-screen scoreboard. `false` was the default before 3.8.0; the first start on 3.8.0 turns a stored `false` on once and sets `live_in_ticker_migrated` |
-| `live_weight` | int, `3` (1–10) — slots per cycle for a plugin with live content |
-| `favorite_live_weight` | int, `5` (1–10) — slots per cycle when a plugin reports a favorite team is live |
-
-## `sync` — multi-display synchronization
-
-Read by `src/common/sync_manager.py` and `src/display_controller.py`.
-
-| Key | Type / default | Meaning |
-|---|---|---|
-| `role` | `"standalone"` (default), `"leader"`, or `"follower"` | This device's role in a synced pair |
-| `port` | int, `5765` | TCP port used for sync traffic |
-| `follower_position` | `"left"` (default) or `"right"` | Which half of the combined image this follower renders (`src/display_controller.py`) |
-
-## `plugin_system`
-
-| Key | Type / default | Meaning |
-|---|---|---|
-| `plugins_directory` | string, `"plugin-repos"` | Where the Plugin Store installs plugins and the only directory the plugin loader scans. Read by `PluginManager` and `PluginStoreManager` (`src/plugin_system/`); editable under General settings |
-| `auto_discover`, `auto_load_enabled`, `development_mode` | bool | **Unused.** Legacy keys, read by nothing and no longer in the template; older configs may still carry them. Plugins are always discovered, and every plugin with `enabled: true` is loaded — to keep a plugin installed but dormant, set its own `enabled` to `false`. Not shown in the web UI; may be left in or removed from config.json |
-
-## Plugin config blocks
-
-Every installed plugin stores its settings under a top-level key equal to
-its plugin id (the template ships one for the bundled `web-ui-info`
-plugin). The shape of each block is defined by that plugin's
-`config_schema.json`; common keys are `enabled` and `display_duration`.
-See [PLUGIN_CONFIG_CORE_PROPERTIES.md](PLUGIN_CONFIG_CORE_PROPERTIES.md).
-
-## `config/config_secrets.json`
-
-| Key | Meaning |
-|---|---|
-| `github.api_token` | Optional GitHub token the Plugin Store uses to avoid API rate limits (`src/plugin_system/store_registry.py`) |
-| `<plugin-id>.*` | Secrets a plugin declares with `"x-secret": true` in its config schema; merged into that plugin's config at load time |

docs/DEPRECATIONS_3.8.md

@@ -1,347 +0,0 @@
-# Deprecated plugin APIs: usage scan
-
-Generated by `scripts/plugin_api_usage.py` — do not edit by hand; re-run it (see [How to re-run](#how-to-re-run)).
-
-- Scanned: 2026-10-05, core 3.8.2
-- Monorepo: [ChuckBuilds/ledmatrix-plugins](https://github.com/ChuckBuilds/ledmatrix-plugins) (main @ 662fb86f), 46 plugins
-- Third-party plugins: 8 with their own repo in `plugins.json` (f1-live, gif-player, pga-tour-leaderboard, plex-marquee, ledmatrix-dresden-departures, tidbyt-baseball-scoreboard, sleeper-fantasy, ledmatrix-nascar)
-
-**45 deprecated methods: 31 unused, 3 still used, 11 need review.**
-
-Counted per plugin: a *call* is `<receiver>.method` on an object named like the owner (`cache_manager`, `display_manager`, `font_manager`, `plugin_manager`), or on `self`/`super()` in a subclass; an *override* is `def method` in a subclass of the owner. *Review* hits are `.method` on a receiver whose type the scan cannot tell. *Internal* hits sit inside another deprecated core method and go with it. *Unrelated* hits are a different class's own method with the same name (a name collision), and never block removal; neither do hits in test files.
-
-| Method | Removal | Core | Plugins (calls / overrides) | Name collisions & tests | Verdict |
-|---|---|---|---|---|---|
-| `BackgroundDataService.get_result` | 3.10.0 | core tests (15 test reviews) | — | — | unused — safe to remove in 3.10.0 |
-| `BackgroundDataService.is_request_complete` | 3.10.0 | core tests (11 test reviews) | — | — | unused — safe to remove in 3.10.0 |
-| `BackgroundDataService.get_request_status` | 3.10.0 | core tests (2 test reviews) | — | — | unused — safe to remove in 3.10.0 |
-| `BaseOddsManager.get_odds_for_games` | 3.10.0 | core tests (3 test reviews) | — | — | unused — safe to remove in 3.10.0 |
-| `BaseOddsManager.format_odds_summary` | 3.10.0 | core tests (5 test reviews) | — | — | unused — safe to remove in 3.10.0 |
-| `CacheManager.load_cache` | 3.10.0 | core tests (1 test review) | — | — | unused — safe to remove in 3.10.0 |
-| `CacheManager.generate_sport_cache_key` | 3.10.0 | core tests (2 test calls, 1 test review) | — | — | unused — safe to remove in 3.10.0 |
-| `APIHelper.fetch_espn_scoreboard` | 3.10.0 | core tests (1 test call, 4 test reviews) | — | football-scoreboard (1 test review); hockey-scoreboard (1 test review); ufc-scoreboard (3 test reviews) | unused — safe to remove in 3.10.0 |
-| `APIHelper.fetch_espn_standings` | 3.10.0 | core tests (1 test review) | — | — | unused — safe to remove in 3.10.0 |
-| `APIHelper.fetch_espn_rankings` | 3.10.0 | core tests (1 test review) | — | — | unused — safe to remove in 3.10.0 |
-| `APIHelper.set_cache` | 3.10.0 | core tests (1 test call, 1 test review) | — | — | unused — safe to remove in 3.10.0 |
-| `APIHelper.get_cache` | 3.10.0 | core tests (1 test call) | — | — | unused — safe to remove in 3.10.0 |
-| `APIHelper.set_rate_limit` | 3.10.0 | core tests (10 test calls, 3 test reviews) | — | — | unused — safe to remove in 3.10.0 |
-| `APIHelper.get_request_stats` | 3.10.0 | — | — | — | unused — safe to remove in 3.10.0 |
-| `ConfigManager.rollback_config` | 3.10.0 | core (1 internal); core tests (1 test review) | — | — | unused — safe to remove in 3.10.0 |
-| `ConfigManager.list_backups` | 3.10.0 | core (1 internal); core tests (1 test review) | — | — | unused — safe to remove in 3.10.0 |
-| `ConfigManager.validate_config_file` | 3.10.0 | core (1 internal) | — | — | unused — safe to remove in 3.10.0 |
-| `ConfigManager.get_secret` | 3.10.0 | core tests (5 test calls, 1 test review) | — | — | unused — safe to remove in 3.10.0 |
-| `ConfigManager.cleanup_orphaned_plugin_configs` | 3.10.0 | core tests (2 test calls, 1 test review) | — | — | unused — safe to remove in 3.10.0 |
-| `ConfigManager.validate_all_plugin_configs` | 3.10.0 | core tests (1 test call, 1 test review) | — | — | unused — safe to remove in 3.10.0 |
-| `DynamicTeamResolver.get_available_dynamic_teams` | 3.10.0 | — | — | — | unused — safe to remove in 3.10.0 |
-| `DynamicTeamResolver.is_dynamic_team` | 3.10.0 | — | — | — | unused — safe to remove in 3.10.0 |
-| `FontManager.get_native_bdf_size` | 3.10.0 | core tests (3 test calls) | — | — | unused — safe to remove in 3.10.0 |
-| `FontManager.measure_text` | 3.10.0 | core tests (5 test calls) | — | — | unused — safe to remove in 3.10.0 |
-| `LogoDownloader.fetch_teams_data` | 3.10.0 | core (2 internals) | — | — | still used by core — keep or migrate first |
-| `LogoDownloader.extract_teams_from_data` | 3.10.0 | core (2 internals) | — | — | still used by core — keep or migrate first |
-| `LogoDownloader.download_missing_logos_for_league` | 3.10.0 | core (1 call, 1 internal); core tests (2 test calls) | — | — | still used by core — keep or migrate first |
-| `LogoDownloader.download_all_ncaa_football_logos` | 3.10.0 | core tests (2 test calls) | — | — | unused — safe to remove in 3.10.0 |
-| `LogoDownloader.download_all_missing_logos` | 3.10.0 | — | — | — | unused — safe to remove in 3.10.0 |
-| `LogoDownloader.convert_image_to_rgba` | 3.10.0 | core (1 internal) | — | — | unused — safe to remove in 3.10.0 |
-| `LogoDownloader.convert_all_logos_to_rgba` | 3.10.0 | — | — | — | unused — safe to remove in 3.10.0 |
-| `BasePlugin.get_supported_vegas_modes` | 3.9.0 | core tests (2 test reviews) | — | — | unused — safe to remove in 3.9.0 |
-| `BasePlugin.get_vegas_segment_width` | 3.9.0 | core tests (1 test review) | — | — | unused — safe to remove in 3.9.0 |
-| `PluginManager.get_all_plugins` | 3.10.0 | — | football-scoreboard (1 review) | football-scoreboard (2 test reviews); hockey-scoreboard (1 test review) | needs review: possible use in football-scoreboard |
-| `PluginManager.get_plugin_info` | 3.10.0 | core (12 reviews, 1 internal); core tests (6 test calls, 9 test reviews) | — | — | needs review: possible use in core |
-| `PluginManager.get_all_plugin_info` | 3.10.0 | core (3 reviews); core tests (2 test calls, 11 test reviews) | — | — | needs review: possible use in core |
-| `PluginManager.get_plugin_display_modes` | 3.10.0 | core (4 reviews); core tests (3 test calls, 5 test reviews) | — | — | needs review: possible use in core |
-| `PluginManager.find_plugin_for_mode` | 3.10.0 | core (2 reviews) | — | — | needs review: possible use in core |
-| `PluginStateManager.is_loaded` | 3.10.0 | core (1 internal) | — | — | needs review: possible use in core |
-| `PluginStateManager.is_running` | 3.10.0 | core (1 internal) | — | — | needs review: possible use in core |
-| `PluginStateManager.is_error` | 3.10.0 | core (1 internal) | — | — | needs review: possible use in core |
-| `PluginStateManager.get_error_info` | 3.10.0 | core (1 internal); core tests (4 test calls) | — | — | needs review: possible use in core |
-| `PluginStateManager.get_last_update` | 3.10.0 | core (1 internal) | — | — | needs review: possible use in core |
-| `PluginStateManager.get_state_info` | 3.10.0 | core (1 internal); core tests (7 test reviews) | — | — | needs review: possible use in core |
-| `PluginTestCase.setUp` | 3.10.0 | — | — | basketball-scoreboard (2 test unrelateds); cricket-scoreboard (1 test unrelated); hockey-scoreboard (1 test unrelated); nrl-scoreboard (1 test unrelated) | unused — safe to remove in 3.10.0 |
-
-## Unused — safe to remove (31)
-
-`BackgroundDataService.get_result`, `BackgroundDataService.is_request_complete`, `BackgroundDataService.get_request_status`, `BaseOddsManager.get_odds_for_games`, `BaseOddsManager.format_odds_summary`, `CacheManager.load_cache`, `CacheManager.generate_sport_cache_key`, `APIHelper.fetch_espn_scoreboard`, `APIHelper.fetch_espn_standings`, `APIHelper.fetch_espn_rankings`, `APIHelper.set_cache`, `APIHelper.get_cache`, `APIHelper.set_rate_limit`, `APIHelper.get_request_stats`, `ConfigManager.rollback_config`, `ConfigManager.list_backups`, `ConfigManager.validate_config_file`, `ConfigManager.get_secret`, `ConfigManager.cleanup_orphaned_plugin_configs`, `ConfigManager.validate_all_plugin_configs`, `DynamicTeamResolver.get_available_dynamic_teams`, `DynamicTeamResolver.is_dynamic_team`, `FontManager.get_native_bdf_size`, `FontManager.measure_text`, `LogoDownloader.download_all_ncaa_football_logos`, `LogoDownloader.download_all_missing_logos`, `LogoDownloader.convert_image_to_rgba`, `LogoDownloader.convert_all_logos_to_rgba`, `BasePlugin.get_supported_vegas_modes`, `BasePlugin.get_vegas_segment_width`, `PluginTestCase.setUp`
-
-## Still used — keep or migrate first (3)
-
-`LogoDownloader.fetch_teams_data`, `LogoDownloader.extract_teams_from_data`, `LogoDownloader.download_missing_logos_for_league`
-
-## Needs review (11)
-
-`PluginManager.get_all_plugins`, `PluginManager.get_plugin_info`, `PluginManager.get_all_plugin_info`, `PluginManager.get_plugin_display_modes`, `PluginManager.find_plugin_for_mode`, `PluginStateManager.is_loaded`, `PluginStateManager.is_running`, `PluginStateManager.is_error`, `PluginStateManager.get_error_info`, `PluginStateManager.get_last_update`, `PluginStateManager.get_state_info`
-
-## Every hit
-
-File paths are relative to the plugin's directory (core: the repo root).
-
-| Method | Where | File:line | Kind | Code |
-|---|---|---|---|---|
-| `BackgroundDataService.get_result` | core tests | test/test_background_data_service.py:85 | test review | `result = service.get_result(req_id)` |
-| `BackgroundDataService.get_result` | core tests | test/test_background_data_service.py:107 | test review | `seen["filed"] = service.get_result(result.request_id) is result` |
-| `BackgroundDataService.get_result` | core tests | test/test_background_data_service.py:148 | test review | `result = service.get_result(req_id)` |
-| `BackgroundDataService.get_result` | core tests | test/test_background_data_service.py:165 | test review | `result = service.get_result(req_id)` |
-| `BackgroundDataService.get_result` | core tests | test/test_background_data_service.py:254 | test review | `assert service.get_result("unknown") is None` |
-| `BackgroundDataService.get_result` | core tests | test/test_background_data_service.py:391 | test review | `assert service.get_result(rid).cached is True` |
-| `BackgroundDataService.get_result` | core tests | test/test_background_fetch_dedupe.py:198 | test review | `assert service.get_result(req).success is True` |
-| `BackgroundDataService.get_result` | core tests | test/test_background_payload_release.py:85 | test review | `result = service.get_result(req_id)` |
-| `BackgroundDataService.get_result` | core tests | test/test_background_payload_release.py:117 | test review | `stored = service.get_result(req_id)` |
-| `BackgroundDataService.get_result` | core tests | test/test_background_payload_release.py:144 | test review | `assert service.get_result(req_id).data == PAYLOAD` |
-| `BackgroundDataService.get_result` | core tests | test/test_background_payload_release.py:154 | test review | `stored = service.get_result(req_id)` |
-| `BackgroundDataService.get_result` | core tests | test/test_background_payload_release.py:171 | test review | `assert service.get_result(req_id).data is None` |
-| `BackgroundDataService.get_result` | core tests | test/test_background_payload_release.py:193 | test review | `assert service.get_result(req_id).data == PAYLOAD` |
-| `BackgroundDataService.get_result` | core tests | test/test_background_payload_release.py:278 | test review | `stored = service.get_result(first)` |
-| `BackgroundDataService.get_result` | core tests | test/test_fetch_service.py:703 | test review | `assert bds.get_result(request_id).success` |
-| `BackgroundDataService.is_request_complete` | core tests | test/test_background_data_service.py:145 | test review | `while not service.is_request_complete(req_id) and time.time() < deadline:` |
-| `BackgroundDataService.is_request_complete` | core tests | test/test_background_data_service.py:162 | test review | `while not service.is_request_complete(req_id) and time.time() < deadline:` |
-| `BackgroundDataService.is_request_complete` | core tests | test/test_background_data_service.py:194 | test review | `while not service.is_request_complete(req_id) and time.time() < deadline:` |
-| `BackgroundDataService.is_request_complete` | core tests | test/test_background_data_service.py:211 | test review | `while not service.is_request_complete(req_id) and time.time() < deadline:` |
-| `BackgroundDataService.is_request_complete` | core tests | test/test_background_data_service.py:246 | test review | `assert service.is_request_complete("r2") is False` |
-| `BackgroundDataService.is_request_complete` | core tests | test/test_background_data_service.py:251 | test review | `assert service.is_request_complete("r3") is True` |
-| `BackgroundDataService.is_request_complete` | core tests | test/test_background_data_service_espn_ranges.py:91 | test review | `while not service.is_request_complete(request_id) and time.time() < deadline:` |
-| `BackgroundDataService.is_request_complete` | core tests | test/test_background_data_service_espn_ranges.py:154 | test review | `while not service.is_request_complete(request_id) and time.time() < deadline:` |
-| `BackgroundDataService.is_request_complete` | core tests | test/test_background_fetch_dedupe.py:55 | test review | `while not service.is_request_complete(req_id) and time.time() < deadline:` |
-| `BackgroundDataService.is_request_complete` | core tests | test/test_background_payload_release.py:67 | test review | `while not service.is_request_complete(req_id) and time.time() < deadline:` |
-| `BackgroundDataService.is_request_complete` | core tests | test/test_fetch_service.py:701 | test review | `while not bds.is_request_complete(request_id) and time.monotonic() < deadline:` |
-| `BackgroundDataService.get_request_status` | core tests | test/test_background_data_service.py:223 | test review | `assert service.get_request_status("nonexistent") is None` |
-| `BackgroundDataService.get_request_status` | core tests | test/test_background_fetch_dedupe.py:448 | test review | `assert service.get_request_status(rid) is FetchStatus.CANCELLED, (` |
-| `BaseOddsManager.get_odds_for_games` | core tests | test/test_base_odds_manager.py:356 | test review | `result = manager.get_odds_for_games(games)` |
-| `BaseOddsManager.get_odds_for_games` | core tests | test/test_base_odds_manager.py:374 | test review | `result = manager.get_odds_for_games(games)` |
-| `BaseOddsManager.get_odds_for_games` | core tests | test/test_base_odds_manager.py:385 | test review | `result = manager.get_odds_for_games([game])` |
-| `BaseOddsManager.format_odds_summary` | core tests | test/test_base_odds_manager.py:322 | test review | `result = manager.format_odds_summary({` |
-| `BaseOddsManager.format_odds_summary` | core tests | test/test_base_odds_manager.py:329 | test review | `result = manager.format_odds_summary(FULL_EXTRACTED)` |
-| `BaseOddsManager.format_odds_summary` | core tests | test/test_base_odds_manager.py:333 | test review | `assert manager.format_odds_summary(None) == 'No odds available'` |
-| `BaseOddsManager.format_odds_summary` | core tests | test/test_base_odds_manager.py:336 | test review | `assert manager.format_odds_summary({}) == 'No odds available'` |
-| `BaseOddsManager.format_odds_summary` | core tests | test/test_base_odds_manager.py:339 | test review | `assert manager.format_odds_summary(` |
-| `CacheManager.load_cache` | core tests | test/conftest.py:219 | test review | `mock.load_cache = Mock(side_effect=mock_get)` |
-| `CacheManager.generate_sport_cache_key` | core tests | test/test_background_data_service.py:42 | test review | `m.generate_sport_cache_key.return_value = "test_key"` |
-| `CacheManager.generate_sport_cache_key` | core tests | test/test_background_data_service.py:356 | test call | `expected = CacheManager.generate_sport_cache_key(None, sport, date_str)` |
-| `CacheManager.generate_sport_cache_key` | core tests | test/test_background_data_service.py:367 | test call | `theirs = cm_module.CacheManager.generate_sport_cache_key(None, "nba")` |
-| `APIHelper.fetch_espn_scoreboard` | core tests | test/test_api_helper.py:214 | test review | `result = helper.fetch_espn_scoreboard('football', 'nfl')` |
-| `APIHelper.fetch_espn_scoreboard` | core tests | test/test_api_helper.py:230 | test review | `helper.fetch_espn_scoreboard('basketball', 'nba', date='20250115')` |
-| `APIHelper.fetch_espn_scoreboard` | core tests | test/test_api_helper.py:239 | test review | `helper.fetch_espn_scoreboard('basketball', 'nba', date='20250115', cache_key='mine')` |
-| `APIHelper.fetch_espn_scoreboard` | core tests | test/test_api_helper.py:251 | test review | `assert helper.fetch_espn_scoreboard('basketball', 'nba', date='20250115') == {` |
-| `APIHelper.fetch_espn_scoreboard` | core tests | test/test_espn_scoreboard_cache.py:199 | test call | `helper.fetch_espn_scoreboard("football", "nfl", date=self.DAY)` |
-| `APIHelper.fetch_espn_scoreboard` | football-scoreboard | test_espn_date_ranges.py:119 | test review | `helper = sys.modules[sports.fetch_espn_scoreboard.__module__]` |
-| `APIHelper.fetch_espn_scoreboard` | hockey-scoreboard | test_espn_date_ranges.py:106 | test review | `helper = sys.modules[sports.fetch_espn_scoreboard.__module__]` |
-| `APIHelper.fetch_espn_scoreboard` | ufc-scoreboard | test_every_bout_is_its_own_fight.py:103 | test review | `_real_fetch = sports.fetch_espn_scoreboard` |
-| `APIHelper.fetch_espn_scoreboard` | ufc-scoreboard | test_every_bout_is_its_own_fight.py:108 | test review | `sports.fetch_espn_scoreboard = lambda *a, **k: board(name)` |
-| `APIHelper.fetch_espn_scoreboard` | ufc-scoreboard | test_every_bout_is_its_own_fight.py:113 | test review | `sports.fetch_espn_scoreboard = _real_fetch` |
-| `APIHelper.fetch_espn_standings` | core tests | test/test_api_helper.py:258 | test review | `helper.fetch_espn_standings('football', 'nfl')` |
-| `APIHelper.fetch_espn_rankings` | core tests | test/test_api_helper.py:269 | test review | `helper.fetch_espn_rankings('football', 'college-football')` |
-| `APIHelper.set_cache` | core tests | test/test_api_helper.py:128 | test review | `helper.set_cache('k', {'a': 1}, ttl=42)` |
-| `APIHelper.set_cache` | core tests | test/test_api_helper.py:350 | test call | `assert helper.set_cache('k', {'a': 1}) is None` |
-| `APIHelper.get_cache` | core tests | test/test_api_helper.py:348 | test call | `assert helper.get_cache('k') is None` |
-| `APIHelper.set_rate_limit` | core tests | test/test_api_helper.py:42 | test call | `helper.set_rate_limit(0)` |
-| `APIHelper.set_rate_limit` | core tests | test/test_api_helper.py:57 | test review | `helper.set_rate_limit(5)` |
-| `APIHelper.set_rate_limit` | core tests | test/test_api_helper.py:72 | test review | `helper.set_rate_limit(5)` |
-| `APIHelper.set_rate_limit` | core tests | test/test_api_helper.py:91 | test review | `helper.set_rate_limit(5)` |
-| `APIHelper.set_rate_limit` | core tests | test/test_api_helper.py:150 | test call | `helper.set_rate_limit(0)` |
-| `APIHelper.set_rate_limit` | core tests | test/test_api_helper.py:305 | test call | `helper.set_rate_limit(0)` |
-| `APIHelper.set_rate_limit` | core tests | test/test_api_helper.py:313 | test call | `helper.set_rate_limit(0)` |
-| `APIHelper.set_rate_limit` | core tests | test/test_api_helper.py:326 | test call | `helper.set_rate_limit(0)` |
-| `APIHelper.set_rate_limit` | core tests | test/test_api_helper.py:334 | test call | `helper.set_rate_limit(0)` |
-| `APIHelper.set_rate_limit` | core tests | test/test_api_helper.py:346 | test call | `helper.set_rate_limit(0)` |
-| `APIHelper.set_rate_limit` | core tests | test/test_espn_scoreboard_cache.py:197 | test call | `helper.set_rate_limit(0)` |
-| `APIHelper.set_rate_limit` | core tests | test/test_fetch_service.py:726 | test call | `helper.set_rate_limit(0)` |
-| `APIHelper.set_rate_limit` | core tests | test/test_fetch_service.py:1143 | test call | `helper.set_rate_limit(0)` |
-| `ConfigManager.rollback_config` | core | src/config_manager.py:191 | internal (in `ConfigManager.rollback_config`) | `success = atomic_mgr.rollback_config(backup_version)` |
-| `ConfigManager.rollback_config` | core | src/config_manager_atomic.py:297 | unrelated | `def rollback_config(self, backup_version: Optional[str] = None) -> bool:` |
-| `ConfigManager.rollback_config` | core tests | test/test_config_durable_writes.py:345 | test review | `assert manager.rollback_config()` |
-| `ConfigManager.list_backups` | core | src/config_manager.py:212 | internal (in `ConfigManager.list_backups`) | `return atomic_mgr.list_backups()` |
-| `ConfigManager.list_backups` | core | src/config_manager_atomic.py:334 | unrelated | `def list_backups(self) -> List[BackupInfo]:` |
-| `ConfigManager.list_backups` | core | src/config_manager_atomic.py:309 | unrelated | `backups = self.list_backups()` |
-| `ConfigManager.list_backups` | core tests | test/test_config_durable_writes.py:323 | test review | `assert [b.path for b in manager.list_backups()] == [` |
-| `ConfigManager.validate_config_file` | core | src/config_manager.py:226 | internal (in `ConfigManager.validate_config_file`) | `return atomic_mgr.validate_config_file(config_path)` |
-| `ConfigManager.validate_config_file` | core | src/config_manager_atomic.py:426 | unrelated | `def validate_config_file(self, config_path: Optional[str] = None) -> ValidationResult:` |
-| `ConfigManager.get_secret` | core tests | test/conftest.py:246 | test review | `mock.get_secret = Mock(side_effect=mock_get_secret)` |
-| `ConfigManager.get_secret` | core tests | test/test_config_manager.py:317 | test call | `assert manager.get_secret("api_key") == "secret123"` |
-| `ConfigManager.get_secret` | core tests | test/test_config_manager.py:318 | test call | `assert manager.get_secret("token") == "token456"` |
-| `ConfigManager.get_secret` | core tests | test/test_config_manager.py:319 | test call | `assert manager.get_secret("nonexistent") is None` |
-| `ConfigManager.get_secret` | core tests | test/test_config_manager.py:325 | test call | `assert manager.get_secret("api_key") is None` |
-| `ConfigManager.get_secret` | core tests | test/test_config_manager.py:337 | test call | `assert manager.get_secret("api_key") is None` |
-| `ConfigManager.cleanup_orphaned_plugin_configs` | core tests | test/test_config_manager.py:447 | test call | `removed = manager.cleanup_orphaned_plugin_configs(["plugin1", "plugin2"])` |
-| `ConfigManager.cleanup_orphaned_plugin_configs` | core tests | test/test_core_config_key_adopters.py:80 | test review | `removed = manager.cleanup_orphaned_plugin_configs(['installed'])` |
-| `ConfigManager.cleanup_orphaned_plugin_configs` | core tests | test/test_web_auth.py:616 | test call | `config_manager.cleanup_orphaned_plugin_configs([])` |
-| `ConfigManager.validate_all_plugin_configs` | core tests | test/test_core_config_key_adopters.py:91 | test review | `results = manager.validate_all_plugin_configs(schema_manager)` |
-| `ConfigManager.validate_all_plugin_configs` | core tests | test/test_retired_plugin_config_keys.py:112 | test call | `results = config_manager.validate_all_plugin_configs(schema_manager)` |
-| `FontManager.get_native_bdf_size` | core tests | test/test_font_manager.py:104 | test call | `assert fm.get_native_bdf_size("five_by_seven") == 7` |
-| `FontManager.get_native_bdf_size` | core tests | test/test_font_manager.py:107 | test call | `assert fm.get_native_bdf_size("press_start") is None` |
-| `FontManager.get_native_bdf_size` | core tests | test/test_font_manager.py:110 | test call | `assert fm.get_native_bdf_size("no-such-family") is None` |
-| `FontManager.measure_text` | core tests | test/test_font_manager.py:116 | test call | `width, height, baseline = fm.measure_text("SCORE", font)` |
-| `FontManager.measure_text` | core tests | test/test_font_manager.py:119 | test call | `assert fm.measure_text("SCORE", font) == (width, height, baseline)` |
-| `FontManager.measure_text` | core tests | test/test_font_manager.py:124 | test call | `short, _, _ = fm.measure_text("AB", font)` |
-| `FontManager.measure_text` | core tests | test/test_font_manager.py:125 | test call | `long, _, _ = fm.measure_text("ABCD", font)` |
-| `FontManager.measure_text` | core tests | test/test_font_manager.py:132 | test call | `fm.measure_text("X", font)` |
-| `LogoDownloader.fetch_teams_data` | core | src/logo_downloader.py:639 | internal (in `LogoDownloader.download_missing_logos_for_league`) | `data = self.fetch_teams_data(league)` |
-| `LogoDownloader.fetch_teams_data` | core | src/logo_downloader.py:695 | internal (in `LogoDownloader.download_all_ncaa_football_logos`) | `data = self.fetch_teams_data(league)` |
-| `LogoDownloader.extract_teams_from_data` | core | src/logo_downloader.py:645 | internal (in `LogoDownloader.download_missing_logos_for_league`) | `teams = self.extract_teams_from_data(data, league)` |
-| `LogoDownloader.extract_teams_from_data` | core | src/logo_downloader.py:701 | internal (in `LogoDownloader.download_all_ncaa_football_logos`) | `teams = self.extract_teams_from_data(data, league)` |
-| `LogoDownloader.download_missing_logos_for_league` | core | src/logo_downloader.py:786 | internal (in `LogoDownloader.download_all_missing_logos`) | `downloaded, failed = self.download_missing_logos_for_league(league, force_download)` |
-| `LogoDownloader.download_missing_logos_for_league` | core | src/logo_downloader.py:1034 | call | `return downloader.download_missing_logos_for_league(league, force_download)` |
-| `LogoDownloader.download_missing_logos_for_league` | core tests | test/test_logo_downloader.py:292 | test call | `downloader.download_missing_logos_for_league("nfl")` |
-| `LogoDownloader.download_missing_logos_for_league` | core tests | test/test_logo_downloader.py:304 | test call | `downloader.download_missing_logos_for_league("nfl")` |
-| `LogoDownloader.download_all_ncaa_football_logos` | core tests | test/test_logo_downloader.py:319 | test call | `downloader.download_all_ncaa_football_logos()` |
-| `LogoDownloader.download_all_ncaa_football_logos` | core tests | test/test_logo_downloader.py:332 | test call | `downloader.download_all_ncaa_football_logos()` |
-| `LogoDownloader.convert_image_to_rgba` | core | src/logo_downloader.py:897 | internal (in `LogoDownloader.convert_all_logos_to_rgba`) | `if self.convert_image_to_rgba(logo_file):` |
-| `BasePlugin.get_supported_vegas_modes` | core tests | test/test_vegas_participation.py:356 | test review | `assert plugin.get_supported_vegas_modes() == [` |
-| `BasePlugin.get_supported_vegas_modes` | core tests | test/test_vegas_participation.py:358 | test review | `assert plugin.get_supported_vegas_modes()` |
-| `BasePlugin.get_vegas_segment_width` | core tests | test/test_vegas_participation.py:359 | test review | `assert plugin.get_vegas_segment_width() == 2` |
-| `PluginManager.get_all_plugins` | core | src/plugin_system/testing/mocks.py:218 | unrelated | `def get_all_plugins(self) -> Dict[str, Any]:` |
-| `PluginManager.get_all_plugins` | football-scoreboard | emulator_demo.py:68 | review | `mock_plugin_manager.get_all_plugins = Mock(return_value=[])` |
-| `PluginManager.get_all_plugins` | football-scoreboard | test_dynamic_duration.py:64 | test review | `mock_plugin_manager.get_all_plugins = Mock(return_value=[])` |
-| `PluginManager.get_all_plugins` | football-scoreboard | test_football_plugin.py:74 | test review | `mock_plugin_manager.get_all_plugins = Mock(return_value=[])` |
-| `PluginManager.get_all_plugins` | hockey-scoreboard | test_hockey_emulator.py:99 | test review | `mock_plugin_manager.get_all_plugins = Mock(return_value=[])` |
-| `PluginManager.get_plugin_info` | core | src/plugin_system/plugin_catalog.py:120 | unrelated | `def get_plugin_info(self, plugin_id: str) -> Optional[Dict[str, Any]]:` |
-| `PluginManager.get_plugin_info` | core | src/plugin_system/plugin_catalog.py:133 | unrelated | `return [info for info in (self.get_plugin_info(pid) for pid in ids) if info]` |
-| `PluginManager.get_plugin_info` | core | src/plugin_system/plugin_manager.py:1001 | internal (in `PluginManager.get_all_plugin_info`) | `return [info for info in [self.get_plugin_info(pid) for pid in pids] if info]` |
-| `PluginManager.get_plugin_info` | core | src/plugin_system/store_install.py:208 | review | `plugin_info = self.get_plugin_info(plugin_id, fetch_latest_from_github=True, force_refresh=True)` |
-| `PluginManager.get_plugin_info` | core | src/plugin_system/store_registry.py:801 | unrelated | `def get_plugin_info(self, plugin_id: str, fetch_latest_from_github: bool = True, force_refresh: bool = False) -> Optional[Dict]:` |
-| `PluginManager.get_plugin_info` | core | src/plugin_system/store_update.py:357 | review | `plugin_info_remote = self.get_plugin_info(plugin_id, fetch_latest_from_github=True, force_refresh=True)` |
-| `PluginManager.get_plugin_info` | core | src/plugin_system/store_update.py:362 | review | `plugin_info_remote = self.get_plugin_info(alt_id, fetch_latest_from_github=True, force_refresh=True)` |
-| `PluginManager.get_plugin_info` | core | src/plugin_system/store_update.py:685 | review | `plugin_info_remote = self.get_plugin_info(plugin_id, fetch_latest_from_github=True, force_refresh=True)` |
-| `PluginManager.get_plugin_info` | core | src/plugin_system/store_update.py:691 | review | `plugin_info_remote = self.get_plugin_info(alt_id, fetch_latest_from_github=True, force_refresh=True)` |
-| `PluginManager.get_plugin_info` | core | src/plugin_system/testing/mocks.py:223 | unrelated | `def get_plugin_info(self, plugin_id: str) -> Optional[Dict[str, Any]]:` |
-| `PluginManager.get_plugin_info` | core | web_interface/blueprints/api_v3/plugin_store.py:216 | review | `remote_info = api_v3.plugin_store_manager.get_plugin_info(plugin_id, fetch_latest_from_github=True)` |
-| `PluginManager.get_plugin_info` | core | web_interface/blueprints/api_v3/plugin_store.py:334 | review | `plugin_info = api_v3.plugin_store_manager.get_plugin_info(plugin_id)` |
-| `PluginManager.get_plugin_info` | core | web_interface/blueprints/api_v3/plugin_store.py:545 | review | `elif not api_v3.plugin_store_manager.get_plugin_info(plugin_id):` |
-| `PluginManager.get_plugin_info` | core | web_interface/blueprints/api_v3/plugin_store.py:602 | review | `elif not api_v3.plugin_store_manager.get_plugin_info(plugin_id):` |
-| `PluginManager.get_plugin_info` | core | web_interface/blueprints/pages_v3.py:224 | review | `info = pages_v3.plugin_catalog.get_plugin_info(pid) or {}` |
-| `PluginManager.get_plugin_info` | core | web_interface/blueprints/pages_v3.py:722 | review | `plugin_info = pages_v3.plugin_catalog.get_plugin_info(plugin_id)` |
-| `PluginManager.get_plugin_info` | core | web_interface/blueprints/pages_v3.py:727 | review | `plugin_info = pages_v3.plugin_catalog.get_plugin_info(plugin_id)` |
-| `PluginManager.get_plugin_info` | core tests | test/test_api_v3_plugin_install_endpoints.py:111 | test review | `manager.get_plugin_info.return_value = None` |
-| `PluginManager.get_plugin_info` | core tests | test/test_api_v3_plugin_install_endpoints.py:119 | test review | `manager.get_plugin_info.return_value = {"id": "clock"}` |
-| `PluginManager.get_plugin_info` | core tests | test/test_pages_v3_path_guards.py:47 | test call | `plugin_manager.get_plugin_info.return_value = {"name": "Weather", "version": "1.0.0"}` |
-| `PluginManager.get_plugin_info` | core tests | test/test_registry_id_resolution.py:81 | test review | `_ids(store.get_plugin_info("ledmatrix-weather", fetch_latest_from_github=False))` |
-| `PluginManager.get_plugin_info` | core tests | test/test_store_manager_caches.py:612 | test review | `info = self.sm.get_plugin_info("foo", fetch_latest_from_github=True, force_refresh=True)` |
-| `PluginManager.get_plugin_info` | core tests | test/test_store_non_plugin_entries.py:37 | test review | `store.get_plugin_info = MagicMock(return_value=dict(SKIN))` |
-| `PluginManager.get_plugin_info` | core tests | test/test_web_plugin_dir_resolution.py:86 | test review | `api.plugin_store_manager.get_plugin_info = MagicMock(return_value=None)` |
-| `PluginManager.get_plugin_info` | core tests | test/test_web_plugin_dir_resolution.py:118 | test review | `api.plugin_store_manager.get_plugin_info = MagicMock(return_value=None)` |
-| `PluginManager.get_plugin_info` | core tests | test/test_web_plugin_dir_resolution.py:178 | test call | `plugin_manager.get_plugin_info.return_value = {"id": "weather", "name": "Weather"}` |
-| `PluginManager.get_plugin_info` | core tests | test/web_interface/test_plugin_config_form_defaults.py:119 | test call | `pm.get_plugin_info.return_value = {"name": "Demo", "version": "1.0.0"}` |
-| `PluginManager.get_plugin_info` | core tests | test/web_interface/test_plugin_config_schema_expansion.py:88 | test call | `pm.get_plugin_info.return_value = {"id": plugin_id, "name": plugin_id}` |
-| `PluginManager.get_plugin_info` | core tests | test/web_interface/test_plugin_widget_route.py:226 | test call | `pm.get_plugin_info.return_value = {"id": plugin_id, "name": plugin_id}` |
-| `PluginManager.get_plugin_info` | core tests | test/web_interface/test_plugin_widget_route.py:228 | test call | `pm.get_plugin_info.return_value["version"] = version` |
-| `PluginManager.get_plugin_info` | core tests | test/web_interface/test_update_all_plugins.py:41 | test review | `sm.get_plugin_info.return_value = None` |
-| `PluginManager.get_plugin_info` | core tests | test/web_interface/test_web_process_runs_no_plugin_code.py:132 | test review | `store.get_plugin_info.return_value = None` |
-| `PluginManager.get_all_plugin_info` | core | src/plugin_system/plugin_catalog.py:129 | unrelated | `def get_all_plugin_info(self) -> List[Dict[str, Any]]:` |
-| `PluginManager.get_all_plugin_info` | core | web_interface/blueprints/api_v3/plugins.py:68 | review | `all_plugin_info = api_v3.plugin_catalog.get_all_plugin_info()` |
-| `PluginManager.get_all_plugin_info` | core | web_interface/blueprints/pages_v3.py:209 | review | `pi.get('id') for pi in pages_v3.plugin_catalog.get_all_plugin_info()` |
-| `PluginManager.get_all_plugin_info` | core | web_interface/blueprints/pages_v3.py:559 | review | `infos = sorted(pages_v3.plugin_catalog.get_all_plugin_info(),` |
-| `PluginManager.get_all_plugin_info` | core tests | test/test_api_v3_installed_display_modes.py:30 | test review | `api.plugin_catalog.get_all_plugin_info = MagicMock(return_value=[info])` |
-| `PluginManager.get_all_plugin_info` | core tests | test/test_api_v3_installed_plugin_icon.py:24 | test review | `api.plugin_catalog.get_all_plugin_info = MagicMock(return_value=[info])` |
-| `PluginManager.get_all_plugin_info` | core tests | test/test_installed_list_registry_offline.py:71 | test review | `api.plugin_catalog.get_all_plugin_info = MagicMock(return_value=[` |
-| `PluginManager.get_all_plugin_info` | core tests | test/test_onboarding_checklist.py:68 | test review | `mock_pm.get_all_plugin_info.return_value = []` |
-| `PluginManager.get_all_plugin_info` | core tests | test/test_plugin_manager_load_failures.py:78 | test call | `infos = {i["id"]: i for i in pm.get_all_plugin_info()}` |
-| `PluginManager.get_all_plugin_info` | core tests | test/test_plugin_runtime_snapshot.py:422 | test review | `api.plugin_catalog.get_all_plugin_info = MagicMock(return_value=[` |
-| `PluginManager.get_all_plugin_info` | core tests | test/test_vegas_participation.py:447 | test review | `api.plugin_catalog.get_all_plugin_info = MagicMock(return_value=[info])` |
-| `PluginManager.get_all_plugin_info` | core tests | test/test_web_api.py:551 | test review | `mock_plugin_catalog.get_all_plugin_info.return_value = [` |
-| `PluginManager.get_all_plugin_info` | core tests | test/test_web_api.py:570 | test review | `mock_plugin_catalog.get_all_plugin_info.return_value = [` |
-| `PluginManager.get_all_plugin_info` | core tests | test/test_web_api.py:592 | test review | `mock_plugin_catalog.get_all_plugin_info.return_value = [` |
-| `PluginManager.get_all_plugin_info` | core tests | test/test_web_plugin_dir_resolution.py:61 | test review | `api.plugin_catalog.get_all_plugin_info = MagicMock(return_value=[info])` |
-| `PluginManager.get_all_plugin_info` | core tests | test/test_web_plugin_dir_resolution.py:195 | test call | `plugin_manager.get_all_plugin_info.assert_not_called()` |
-| `PluginManager.get_all_plugin_info` | core tests | test/test_web_smoke.py:95 | test review | `mock_pm.get_all_plugin_info.return_value = [` |
-| `PluginManager.get_plugin_display_modes` | core | src/plugin_system/plugin_catalog.py:175 | unrelated | `def get_plugin_display_modes(self, plugin_id: str) -> List[str]:` |
-| `PluginManager.get_plugin_display_modes` | core | web_interface/blueprints/api_v3/display.py:197 | review | `plugin_modes = api_v3.plugin_catalog.get_plugin_display_modes(plugin_id) or [plugin_id]` |
-| `PluginManager.get_plugin_display_modes` | core | web_interface/blueprints/api_v3/display.py:267 | review | `modes = api_v3.plugin_catalog.get_plugin_display_modes(resolved_plugin)` |
-| `PluginManager.get_plugin_display_modes` | core | web_interface/blueprints/api_v3/plugins.py:157 | review | `declared_modes = api_v3.plugin_catalog.get_plugin_display_modes(plugin_id)` |
-| `PluginManager.get_plugin_display_modes` | core | web_interface/blueprints/pages_v3.py:565 | review | `modes = pages_v3.plugin_catalog.get_plugin_display_modes(pid) or [pid]` |
-| `PluginManager.get_plugin_display_modes` | core tests | test/test_api_v3_display_modes.py:40 | test call | `pm.get_plugin_display_modes = MagicMock(` |
-| `PluginManager.get_plugin_display_modes` | core tests | test/test_api_v3_display_modes.py:100 | test call | `pm.get_plugin_display_modes = MagicMock(return_value=[])` |
-| `PluginManager.get_plugin_display_modes` | core tests | test/test_api_v3_display_modes.py:122 | test call | `pm.get_plugin_display_modes = MagicMock(` |
-| `PluginManager.get_plugin_display_modes` | core tests | test/test_api_v3_installed_display_modes.py:31 | test review | `api.plugin_catalog.get_plugin_display_modes = MagicMock(return_value=declared_modes)` |
-| `PluginManager.get_plugin_display_modes` | core tests | test/test_api_v3_installed_display_modes.py:39 | test review | `api.plugin_catalog.get_plugin_display_modes.assert_any_call('football-scoreboard')` |
-| `PluginManager.get_plugin_display_modes` | core tests | test/test_installed_list_registry_offline.py:75 | test review | `api.plugin_catalog.get_plugin_display_modes = MagicMock(return_value=[])` |
-| `PluginManager.get_plugin_display_modes` | core tests | test/test_onboarding_checklist.py:69 | test review | `mock_pm.get_plugin_display_modes.side_effect = lambda pid: []` |
-| `PluginManager.get_plugin_display_modes` | core tests | test/test_web_smoke.py:99 | test review | `mock_pm.get_plugin_display_modes.side_effect = (` |
-| `PluginManager.find_plugin_for_mode` | core | src/plugin_system/plugin_catalog.py:186 | unrelated | `def find_plugin_for_mode(self, mode: str) -> Optional[str]:` |
-| `PluginManager.find_plugin_for_mode` | core | web_interface/blueprints/api_v3/display.py:271 | review | `resolved_plugin = api_v3.plugin_catalog.find_plugin_for_mode(resolved_mode)` |
-| `PluginManager.find_plugin_for_mode` | core | web_interface/blueprints/api_v3/display.py:276 | review | `resolved_plugin = api_v3.plugin_catalog.find_plugin_for_mode(resolved_mode)` |
-| `PluginStateManager.is_loaded` | core | src/plugin_system/plugin_state.py:299 | internal (in `PluginStateManager.get_state_info`) | `'is_loaded': self.is_loaded(plugin_id),` |
-| `PluginStateManager.is_running` | core | src/plugin_system/plugin_state.py:301 | internal (in `PluginStateManager.get_state_info`) | `'is_running': self.is_running(plugin_id),` |
-| `PluginStateManager.is_error` | core | src/plugin_system/plugin_state.py:302 | internal (in `PluginStateManager.get_state_info`) | `'is_error': self.is_error(plugin_id),` |
-| `PluginStateManager.get_error_info` | core | src/plugin_system/plugin_state.py:305 | internal (in `PluginStateManager.get_state_info`) | `'error_info': self.get_error_info(plugin_id),` |
-| `PluginStateManager.get_error_info` | core tests | test/test_async_plugin_updates.py:236 | test call | `error = pm.state_manager.get_error_info(plugin_id)` |
-| `PluginStateManager.get_error_info` | core tests | test/test_plugin_hang_containment.py:191 | test call | `error_info = pm.state_manager.get_error_info('hung')` |
-| `PluginStateManager.get_error_info` | core tests | test/test_sports_sunset_matrix.py:212 | test call | `f"{manager.state_manager.get_error_info(plugin_id)}"` |
-| `PluginStateManager.get_error_info` | core tests | test/test_sports_sunset_matrix.py:285 | test call | `info = manager.state_manager.get_error_info(plugin_id)` |
-| `PluginStateManager.get_last_update` | core | src/plugin_system/plugin_state.py:304 | internal (in `PluginStateManager.get_state_info`) | `'last_update': self.get_last_update(plugin_id),` |
-| `PluginStateManager.get_state_info` | core | src/plugin_system/plugin_manager.py:987 | internal (in `PluginManager.get_plugin_info`) | `info['state'] = self.state_manager.get_state_info(plugin_id)` |
-| `PluginStateManager.get_state_info` | core tests | test/test_plugin_state_transition_count.py:39 | test review | `info = manager.get_state_info("clock")` |
-| `PluginStateManager.get_state_info` | core tests | test/test_plugin_state_transition_count.py:51 | test review | `info = manager.get_state_info("clock")` |
-| `PluginStateManager.get_state_info` | core tests | test/test_plugin_state_transition_count.py:62 | test review | `assert manager.get_state_info("clock")["state_history_count"] == 101` |
-| `PluginStateManager.get_state_info` | core tests | test/test_plugin_state_transition_count.py:63 | test review | `assert manager.get_state_info("weather")["state_history_count"] == 1` |
-| `PluginStateManager.get_state_info` | core tests | test/test_plugin_state_transition_count.py:74 | test review | `info = manager.get_state_info("clock")` |
-| `PluginStateManager.get_state_info` | core tests | test/test_plugin_state_transition_count.py:95 | test review | `info = m.get_state_info("clock")` |
-| `PluginStateManager.get_state_info` | core tests | test/test_plugin_state_transition_count.py:130 | test review | `info = manager.get_state_info("clock")` |
-
-## Sources scanned
-
-| Source | Group | Python files | Hits |
-|---|---|---|---|
-| core | core | 188 | 50 |
-| core tests | core-tests | 416 | 176 |
-| 7-segment-clock | monorepo | 3 | 0 |
-| afl-scoreboard | monorepo | 36 | 0 |
-| baseball-scoreboard | monorepo | 71 | 0 |
-| basketball-scoreboard | monorepo | 51 | 2 |
-| birdnet-go | monorepo | 3 | 0 |
-| blackjack | monorepo | 7 | 0 |
-| calendar | monorepo | 5 | 0 |
-| christmas-countdown | monorepo | 3 | 0 |
-| clock-simple | monorepo | 2 | 0 |
-| countdown | monorepo | 5 | 0 |
-| cricket-scoreboard | monorepo | 8 | 1 |
-| f1-scoreboard | monorepo | 15 | 0 |
-| fantasy-blitz | monorepo | 13 | 0 |
-| football-scoreboard | monorepo | 78 | 4 |
-| geochron | monorepo | 10 | 0 |
-| hello-world | monorepo | 2 | 0 |
-| hockey-scoreboard | monorepo | 57 | 3 |
-| incoming-packages | monorepo | 8 | 0 |
-| jellyfin-now-playing | monorepo | 4 | 0 |
-| lacrosse-scoreboard | monorepo | 41 | 0 |
-| ledmatrix-elections | monorepo | 12 | 0 |
-| ledmatrix-flights | monorepo | 48 | 0 |
-| ledmatrix-leaderboard | monorepo | 10 | 0 |
-| ledmatrix-music | monorepo | 12 | 0 |
-| ledmatrix-stocks | monorepo | 7 | 0 |
-| ledmatrix-weather | monorepo | 15 | 0 |
-| march-madness | monorepo | 4 | 0 |
-| masters-tournament | monorepo | 10 | 0 |
-| mqtt-notifications | monorepo | 4 | 0 |
-| news | monorepo | 7 | 0 |
-| nfl-draft | monorepo | 3 | 0 |
-| nfl-stat-leaders | monorepo | 8 | 0 |
-| nrl-scoreboard | monorepo | 31 | 1 |
-| odds-ticker | monorepo | 10 | 0 |
-| of-the-day | monorepo | 14 | 0 |
-| olympics | monorepo | 16 | 0 |
-| on-air | monorepo | 3 | 0 |
-| pomodoro-timer | monorepo | 3 | 0 |
-| soccer-scoreboard | monorepo | 50 | 0 |
-| static-image | monorepo | 4 | 0 |
-| stock-news | monorepo | 4 | 0 |
-| text-display | monorepo | 4 | 0 |
-| tide-display | monorepo | 3 | 0 |
-| ufc-scoreboard | monorepo | 40 | 3 |
-| web-ui-info | monorepo | 2 | 0 |
-| youtube-stats | monorepo | 5 | 0 |
-| f1-live | third-party | 10 | 0 |
-| gif-player | third-party | 1 | 0 |
-| pga-tour-leaderboard | third-party | 2 | 0 |
-| plex-marquee | third-party | 1 | 0 |
-| ledmatrix-dresden-departures | third-party | 1 | 0 |
-| tidbyt-baseball-scoreboard | third-party | 2 | 0 |
-| sleeper-fantasy | third-party | 1 | 0 |
-| ledmatrix-nascar | third-party | 1 | 0 |
-
-## How to re-run
-
-```bash
-# Clones the monorepo and each third-party plugin (depth 1) into a temp cache:
-python3 scripts/plugin_api_usage.py --output docs/DEPRECATIONS_3.8.md
-# Or scan a local monorepo checkout (read only) instead of cloning it:
-python3 scripts/plugin_api_usage.py --monorepo ../ledmatrix-plugins
-```
-
-Before removing a method in its release, re-run the scan against the current monorepo and registry: a plugin added since this file was generated may have started calling it. Remove only methods the fresh scan reports unused; move the rest to a later release (the test in `test/test_deprecation.py` fails while a marker names a release at or below `src.__version__`).

docs/DEVELOPER_QUICK_REFERENCE.md

@@ -31,7 +31,7 @@ POST /api/v3/system/action
 
 **Base URL**: `http://your-pi-ip:5000/api/v3`
 
-See [REST_API_REFERENCE.md](REST_API_REFERENCE.md) for complete documentation.
+See [API_REFERENCE.md](API_REFERENCE.md) for complete documentation.
 
 ## Display Manager Quick Methods
 
@@ -48,14 +48,8 @@ display_manager.draw_text("Centered", centered=True)  # Auto-center
 width = display_manager.get_text_width("Text", font)
 height = display_manager.get_font_height(font)
 
-# Adaptive layout (recommended for multi-size support — text and images
-# that scale to any panel; see docs/ADAPTIVE_LAYOUT.md)
-rows = self.layout.bounds.inset(1).split_v(3, 1, gap=1)
-self.draw_fit("12:34", rows[0])                 # largest crisp font that fits
-self.draw_image(logo, rows[1], mode="fill_height", crop_to_ink=True)
-
-# Weather icons: draw_weather_icon() was removed in 3.8.0 — draw your
-# own icons (the weather plugin ships WeatherIcons)
+# Weather icons
+display_manager.draw_weather_icon("rain", x=10, y=10, size=16)
 
 # Scrolling state
 display_manager.set_scrolling_state(True)
@@ -72,23 +66,20 @@ cache_manager.delete("key")       # alias for clear_cache(key)
 
 # Advanced caching
 data = cache_manager.get_cached_data_with_strategy("key", data_type="weather")
+data = cache_manager.get_background_cached_data("key", sport_key="nhl")
 
 # Strategy
 strategy = cache_manager.get_cache_strategy("weather")
+interval = cache_manager.get_sport_live_interval("nhl")
 ```
 
-`get_background_cached_data()` (use `get()`) and `get_sport_live_interval()`
-were removed in 3.8.0. See
-[Deprecated APIs](PLUGIN_API_REFERENCE.md#deprecated-apis).
-
 ## Plugin Manager Quick Methods
 
 ```python
 # Get plugins
 plugin = plugin_manager.get_plugin("plugin-id")
 all_plugins = plugin_manager.get_all_plugins()
-# get_enabled_plugins() was removed in 3.8.0 — check `enabled` on the
-# entries in plugin_manager.plugins
+enabled = plugin_manager.get_enabled_plugins()
 
 # Get info
 info = plugin_manager.get_plugin_info("plugin-id")
@@ -171,7 +162,7 @@ def display(self, force_clear=False):
 
 - [ ] Plugin inherits from `BasePlugin`
 - [ ] Implements `update()` and `display()` methods
-- [ ] `manifest.json` with the [required fields](PLUGIN_API_REFERENCE.md#manifest-required-fields)
+- [ ] `manifest.json` with required fields
 - [ ] `config_schema.json` for web UI (recommended)
 - [ ] `README.md` with documentation
 - [ ] Error handling implemented
@@ -193,13 +184,12 @@ def display(self, force_clear=False):
 
 ```
 LEDMatrix/
-├── plugin-repos/         # Installed plugins (default; plugins/ is only
-│                         #   for dev symlinks via scripts/dev/dev_plugin_setup.sh)
+├── plugins/              # Installed plugins
 ├── config/
 │   ├── config.json      # Main configuration
 │   └── config_secrets.json  # API keys and secrets
 ├── docs/                 # Documentation
-│   ├── REST_API_REFERENCE.md
+│   ├── API_REFERENCE.md
 │   ├── PLUGIN_API_REFERENCE.md
 │   └── ...
 └── src/
@@ -211,7 +201,7 @@ LEDMatrix/
 
 ## Quick Links
 
-- [Complete REST API Reference](REST_API_REFERENCE.md)
+- [Complete API Reference](API_REFERENCE.md)
 - [Plugin API Reference](PLUGIN_API_REFERENCE.md)
 - [Plugin Development Guide](PLUGIN_DEVELOPMENT_GUIDE.md)
 - [Advanced Patterns](ADVANCED_PLUGIN_DEVELOPMENT.md)

docs/DEVELOPMENT.md

@@ -43,21 +43,16 @@ git submodule update --init --recursive rpi-rgb-led-matrix-master
 
 #### Building the Submodule
 
-After initializing the submodule, build and install the `rgbmatrix` Python
-package from the submodule root. Upstream's `pyproject.toml` builds it with
-scikit-build-core, CMake and Ninja; there is no separate `make` step:
+After initializing the submodule, you need to build the Python bindings:
 
 ```bash
 cd rpi-rgb-led-matrix-master
+make build-python
+cd bindings/python
 python3 -m pip install --break-system-packages .
 ```
 
-On a board with 1 GB of RAM or less, cap the compile so it doesn't run out of
-memory: `CMAKE_BUILD_PARALLEL_LEVEL=1 python3 -m pip install --break-system-packages .`
-
-**Note:** The `first_time_install.sh` script automates this process during
-installation, including the parallelism cap and a temporary swapfile on
-low-memory boards.
+**Note:** The `first_time_install.sh` script automates this process during installation.
 
 #### Troubleshooting
 
@@ -74,7 +69,7 @@ git submodule update --init --recursive rpi-rgb-led-matrix-master
 **Build fails:**
 Ensure you have the required build dependencies installed:
 ```bash
-sudo apt install -y build-essential python-dev-is-python3 cmake ninja-build
+sudo apt install -y build-essential python3-dev cython3 scons
 ```
 
 **Import error for `rgbmatrix` module:**
@@ -102,6 +97,8 @@ When setting up CI/CD pipelines, ensure submodules are initialized before buildi
 - name: Build rpi-rgb-led-matrix
   run: |
     cd rpi-rgb-led-matrix-master
+    make build-python
+    cd bindings/python
     pip install .
 ```
 
@@ -113,6 +110,8 @@ variables:
 build:
   script:
     - cd rpi-rgb-led-matrix-master
+    - make build-python
+    - cd bindings/python
     - pip install .
 ```
 

docs/DEV_PREVIEW.md

@@ -6,12 +6,6 @@ Tools for rapid plugin development without deploying to the RPi.
 
 Interactive web UI for tweaking plugin configs and seeing the rendered display in real time.
 
-The size inputs have a preset dropdown with the harness's standard panel
-sizes, and the **All Sizes** button renders the current config at every
-harness size in a side-by-side gallery (`POST /api/render-matrix`) — the
-quickest way to eyeball adaptive-layout behavior across panels
-(see [ADAPTIVE_LAYOUT.md](ADAPTIVE_LAYOUT.md)).
-
 ### Quick Start
 
 ```bash

docs/EMULATOR_SETUP_GUIDE.md

@@ -17,13 +17,13 @@ The LEDMatrix emulator allows you to run and test LEDMatrix displays on your com
 ## Prerequisites
 
 ### System Requirements
-- Python 3.11 or higher (3.11 and 3.13 are tested)
+- Python 3.7 or higher
 - Windows, macOS, or Linux
 - At least 2GB RAM (4GB recommended)
 - Internet connection for plugin downloads
 
 ### Required Software
-- Python 3.11+
+- Python 3.7+
 - pip (Python package manager)
 - Git (for plugin management)
 
@@ -50,7 +50,8 @@ pip install -r requirements-emulator.txt
 ```
 
 This installs:
-- `RGBMatrixEmulator` - the emulation library (and whatever it depends on)
+- `RGBMatrixEmulator` - The core emulation library
+- Additional dependencies for display adapters
 
 ### 3. Install Standard Dependencies
 
@@ -62,31 +63,29 @@ pip install -r requirements.txt
 
 ### 1. Emulator Configuration File
 
-The emulator uses `emulator_config.json` for configuration. It isn't in
-the repo (it's gitignored): RGBMatrixEmulator writes it on first run.
-A typical file looks like this:
+The emulator uses `emulator_config.json` for configuration. Here's the
+default configuration as it ships in the repo:
 
 ```json
 {
     "pixel_outline": 0,
-    "pixel_size": 16,
+    "pixel_size": 5,
     "pixel_style": "square",
     "pixel_glow": 6,
-    "display_adapter": "browser",
-    "allow_adapter_fallback": true,
+    "display_adapter": "pygame",
     "icon_path": null,
     "emulator_title": null,
     "suppress_font_warnings": false,
+    "suppress_adapter_load_errors": false,
     "browser": {
         "_comment": "For use with the browser adapter only.",
         "port": 8888,
-        "target_fps": 60,
+        "target_fps": 24,
         "fps_display": false,
         "quality": 70,
         "image_border": true,
         "debug_text": false,
-        "image_format": "JPEG",
-        "open_immediately": false
+        "image_format": "JPEG"
     },
     "log_level": "info"
 }
@@ -97,13 +96,13 @@ A typical file looks like this:
 | Option | Description | Default | Values |
 |--------|-------------|---------|--------|
 | `pixel_outline` | Pixel border thickness | 0 | 0-5 |
-| `pixel_size` | Size of each pixel | 16 | 1-64 (8–16 is typical for testing) |
+| `pixel_size` | Size of each pixel | 5 | 1-64 (8–16 is typical for testing) |
 | `pixel_style` | Pixel shape | "square" | "square", "circle" |
 | `pixel_glow` | Glow effect intensity | 6 | 0-20 |
-| `display_adapter` | Display backend | "browser" | "browser", "pygame" |
-| `allow_adapter_fallback` | Fall back to another adapter if the configured one fails to load | true | true/false |
+| `display_adapter` | Display backend | "pygame" | "pygame", "browser" |
 | `emulator_title` | Window title | null | Any string |
 | `suppress_font_warnings` | Hide font warnings | false | true/false |
+| `suppress_adapter_load_errors` | Hide adapter errors | false | true/false |
 
 ### 3. Browser Adapter Configuration
 
@@ -112,32 +111,18 @@ When using the browser adapter, additional options are available:
 | Option | Description | Default |
 |--------|-------------|---------|
 | `port` | Web server port | 8888 |
-| `target_fps` | Target frames per second | 60 |
+| `target_fps` | Target frames per second | 24 |
 | `fps_display` | Show FPS counter | false |
 | `quality` | Image compression quality | 70 |
 | `image_border` | Show image border | true |
 | `debug_text` | Show debug information | false |
 | `image_format` | Image format | "JPEG" |
-| `open_immediately` | Open the browser page automatically on start | false |
 
 ## Running the Emulator
 
-### 1. Use the `-e` Flag (Recommended)
+### 1. Set Environment Variable
 
-`run.py` accepts exactly two flags: `-e`/`--emulator` and
-`-d`/`--debug`.
-
-```bash
-python3 run.py -e
-
-# With verbose logging
-python3 run.py -e -d
-```
-
-### 2. Alternative: Set the Environment Variable
-
-You can also enable emulator mode via the `EMULATOR` environment
-variable:
+Enable emulator mode by setting the `EMULATOR` environment variable:
 
 **Windows (Command Prompt):**
 ```cmd
@@ -152,6 +137,15 @@ python run.py
 ```
 
 **Linux/macOS:**
+```bash
+export EMULATOR=true
+python3 run.py
+```
+
+### 2. Alternative: Direct Python Execution
+
+You can also run the emulator directly:
+
 ```bash
 EMULATOR=true python3 run.py
 ```
@@ -159,8 +153,7 @@ EMULATOR=true python3 run.py
 ### 3. Verify Emulator Mode
 
 When running in emulator mode, you should see:
-- The emulated matrix — a web page at `http://localhost:8888` with the
-  default browser adapter, or a desktop window with the pygame adapter
+- A window displaying the LED matrix simulation
 - Console output indicating emulator mode
 - No hardware initialization errors
 
@@ -168,36 +161,7 @@ When running in emulator mode, you should see:
 
 LEDMatrix supports two display adapters for the emulator:
 
-### 1. Browser Adapter (Default)
-
-The browser adapter runs a web server and displays the matrix as a web
-page at `http://localhost:8888`. This is the adapter the shipped
-`emulator_config.json` uses.
-
-**Features:**
-- Web-based interface
-- Remote access capability
-- Mobile-friendly
-- Screenshot capture
-
-**Configuration:**
-```json
-{
-    "display_adapter": "browser",
-    "browser": {
-        "port": 8888,
-        "target_fps": 60,
-        "quality": 70
-    }
-}
-```
-
-**Usage:**
-1. Start the emulator (`python3 run.py -e`)
-2. Open browser to `http://localhost:8888`
-3. View the LED matrix display
-
-### 2. Pygame Adapter (Alternative)
+### 1. Pygame Adapter (Default)
 
 The pygame adapter provides a native desktop window with real-time display.
 
@@ -222,6 +186,33 @@ The pygame adapter provides a native desktop window with real-time display.
 - `+/-` - Zoom in/out
 - `R` - Reset zoom
 
+### 2. Browser Adapter
+
+The browser adapter runs a web server and displays the matrix in a web browser.
+
+**Features:**
+- Web-based interface
+- Remote access capability
+- Mobile-friendly
+- Screenshot capture
+
+**Configuration:**
+```json
+{
+    "display_adapter": "browser",
+    "browser": {
+        "port": 8888,
+        "target_fps": 24,
+        "quality": 70
+    }
+}
+```
+
+**Usage:**
+1. Start the emulator with browser adapter
+2. Open browser to `http://localhost:8888`
+3. View the LED matrix display
+
 ## Troubleshooting
 
 ### Common Issues
@@ -283,7 +274,8 @@ Enable debug logging:
 ```json
 {
     "log_level": "debug",
-    "suppress_font_warnings": false
+    "suppress_font_warnings": false,
+    "suppress_adapter_load_errors": false
 }
 ```
 
@@ -307,18 +299,17 @@ Modify the display dimensions in your main config:
 
 ### 2. Plugin Development
 
-`run.py` always runs the full rotation — it has no single-plugin flag.
-To preview or check one plugin in isolation, use the dev tools:
+For plugin development with the emulator:
 
 ```bash
-# Run the full display in emulator mode (optionally with debug logging)
-python3 run.py -e -d
+# Enable emulator mode
+export EMULATOR=true
 
-# Live single-plugin preview in the browser (port 5001)
-python3 scripts/dev_server.py
+# Run with specific plugin
+python run.py --plugin my-plugin
 
-# Headless render/validation of one plugin
-python3 scripts/check_plugin.py --plugin my-plugin
+# Debug mode
+python run.py --debug
 ```
 
 ### 3. Performance Tuning
@@ -353,10 +344,11 @@ The emulator can work alongside the web interface:
 
 ```bash
 # Terminal 1: Start emulator
-python3 run.py -e
+export EMULATOR=true
+python run.py
 
-# Terminal 2: Start web interface (supported entry point)
-python3 web_interface/start.py
+# Terminal 2: Start web interface
+python web_interface/app.py
 ```
 
 Access the web interface at `http://localhost:5000` while the emulator runs.
@@ -373,14 +365,13 @@ Access the web interface at `http://localhost:5000` while the emulator runs.
 ### 2. Plugin Testing
 
 ```bash
-# Test a specific plugin (headless check)
-python3 scripts/check_plugin.py --plugin clock-simple
+# Test specific plugin
+export EMULATOR=true
+python run.py --plugin clock-simple
 
-# Preview a single plugin live in the browser (port 5001)
-python3 scripts/dev_server.py
-
-# Test the full rotation in the emulator
-python3 run.py -e
+# Test all plugins
+export EMULATOR=true
+python run.py --test-plugins
 ```
 
 ### 3. Configuration Management
@@ -394,8 +385,9 @@ python3 run.py -e
 ### Basic Clock Display
 
 ```bash
-# Start emulator with clock enabled in config.json
-python3 run.py -e
+# Start emulator with clock
+export EMULATOR=true
+python run.py
 ```
 
 ### Sports Scores
@@ -403,16 +395,16 @@ python3 run.py -e
 ```bash
 # Configure for sports display
 # Edit config/config.json to enable sports plugins
-python3 run.py -e
+export EMULATOR=true
+python run.py
 ```
 
 ### Custom Text Display
 
 ```bash
-# Preview the text display plugin on its own
-python3 scripts/check_plugin.py --plugin text-display
-# or use the live dev preview server
-python3 scripts/dev_server.py
+# Use text display plugin
+export EMULATOR=true
+python run.py --plugin text-display --text "Hello World"
 ```
 
 ## Support

docs/FONT_MANAGER.md

@@ -1,94 +1,167 @@
 # FontManager Usage Guide
 
-> **Picking a size automatically:** if you want the *largest font that fits
-> a given area* rather than a fixed size, use the adaptive layout system's
-> font ladders, which resolve through this FontManager. `BasePlugin`
-> subclasses get this as `self.layout.fit_text(...)`; other code can build
-> a `LayoutContext(width, height, font_manager)` directly — see
-> [ADAPTIVE_LAYOUT.md](ADAPTIVE_LAYOUT.md).
-
 ## Overview
 
-[`src/font_manager.py`](../src/font_manager.py) loads and caches the TTF and
-BDF fonts in `assets/fonts/`, registers fonts that plugins ship, and records
-which plugin uses which font so the web UI can show it.
+The enhanced FontManager provides comprehensive font management for the LEDMatrix application with support for:
+- Manager font registration and detection
+- Plugin font management
+- Manual font overrides via web interface
+- Performance monitoring and caching
+- Dynamic font discovery
 
-Several methods were removed in LEDMatrix 3.8.0 after a release of
-deprecation warnings; [Removed methods](#removed-methods) below lists them
-with what to use instead.
+## Architecture
 
-## Getting the FontManager
+### Manager-Centric Design
 
-There is one shared FontManager per display process. The display controller
-creates it and hands it to the `PluginManager`, so a plugin reaches it
-through its `plugin_manager`:
+Managers define their own fonts, but the FontManager:
+1. **Loads and caches fonts** for performance
+2. **Detects font usage** for visibility
+3. **Allows manual overrides** when needed
+4. **Supports plugin fonts** with namespacing
 
-```python
-class MyPlugin(BasePlugin):
-    def __init__(self, plugin_id, config, display_manager, cache_manager, plugin_manager):
-        super().__init__(plugin_id, config, display_manager, cache_manager, plugin_manager)
-        self.font_manager = self._get_font_manager()
+### Font Resolution Flow
+
+```
+Manager requests font → Check manual overrides → Apply manager choice → Cache & return
 ```
 
-`BasePlugin._get_font_manager()` returns `plugin_manager.font_manager`, or a
-standalone FontManager when none is available (test harnesses, mocks).
-`DisplayManager` has **no** `font_manager` attribute —
-`display_manager.font_manager` raises `AttributeError`.
+## For Manager Developers
 
-## Resolving a font
+### Basic Font Usage
 
 ```python
-element_key = f"{self.plugin_id}.title"
+from src.font_manager import FontManager
 
-# Register the choice so the web UI's Fonts tab can list it.
-self.font_manager.register_manager_font(
-    manager_id=self.plugin_id,
-    element_key=element_key,
-    family="press_start",
-    size_px=10,
-    color=(255, 255, 255),
-)
+class MyManager:
+    def __init__(self, config, display_manager, cache_manager):
+        self.font_manager = display_manager.font_manager  # Access shared FontManager
+        self.manager_id = "my_manager"
+        
+    def display(self):
+        # Define your font choices
+        element_key = "my_manager.title"
+        font_family = "press_start"
+        font_size_px = 10
+        color = (255, 255, 255)  # RGB white
+        
+        # Register your font choice (for detection and future overrides)
+        self.font_manager.register_manager_font(
+            manager_id=self.manager_id,
+            element_key=element_key,
+            family=font_family,
+            size_px=font_size_px,
+            color=color
+        )
+        
+        # Get the font (checks for manual overrides automatically)
+        font = self.font_manager.resolve_font(
+            element_key=element_key,
+            family=font_family,
+            size_px=font_size_px
+        )
+        
+        # Use the font for rendering
+        self.display_manager.draw_text(
+            "Hello World",
+            x=10, y=10,
+            color=color,
+            font=font
+        )
+```
 
+### Advanced Font Usage
+
+```python
+class AdvancedManager:
+    def __init__(self, config, display_manager, cache_manager):
+        self.font_manager = display_manager.font_manager
+        self.manager_id = "advanced_manager"
+        
+        # Define your font specifications
+        self.font_specs = {
+            "title": {"family": "press_start", "size_px": 12, "color": (255, 255, 0)},
+            "body": {"family": "four_by_six", "size_px": 8, "color": (255, 255, 255)},
+            "footer": {"family": "five_by_seven", "size_px": 7, "color": (128, 128, 128)}
+        }
+        
+        # Register all font specs
+        for element_type, spec in self.font_specs.items():
+            element_key = f"{self.manager_id}.{element_type}"
+            self.font_manager.register_manager_font(
+                manager_id=self.manager_id,
+                element_key=element_key,
+                family=spec["family"],
+                size_px=spec["size_px"],
+                color=spec["color"]
+            )
+    
+    def get_font(self, element_type: str):
+        """Helper method to get fonts with override support."""
+        spec = self.font_specs[element_type]
+        element_key = f"{self.manager_id}.{element_type}"
+        
+        return self.font_manager.resolve_font(
+            element_key=element_key,
+            family=spec["family"],
+            size_px=spec["size_px"]
+        )
+    
+    def display(self):
+        # Get fonts (automatically checks for overrides)
+        title_font = self.get_font("title")
+        body_font = self.get_font("body")
+        footer_font = self.get_font("footer")
+        
+        # Render with fonts
+        self.display_manager.draw_text("Title", font=title_font, color=self.font_specs["title"]["color"])
+        self.display_manager.draw_text("Body Text", font=body_font, color=self.font_specs["body"]["color"])
+        self.display_manager.draw_text("Footer", font=footer_font, color=self.font_specs["footer"]["color"])
+```
+
+### Using Size Tokens
+
+```python
+# Get available size tokens
+tokens = self.font_manager.get_size_tokens()
+# Returns: {'xs': 6, 'sm': 8, 'md': 10, 'lg': 12, 'xl': 14, 'xxl': 16}
+
+# Use token to get size
+size_px = tokens.get('md', 10)  # 10px
+
+# Then use in font resolution
 font = self.font_manager.resolve_font(
-    element_key=element_key,
+    element_key="my_manager.text",
     family="press_start",
-    size_px=10,
+    size_px=size_px
 )
-self.display_manager.draw_text("Hello", x=10, y=10, font=font)
 ```
 
-`resolve_font()` applies any entry for `element_key` in
-`config/font_overrides.json`, maps a plugin-local family to its namespaced
-name when `plugin_id` is passed, and then calls `get_font(family, size_px)`.
-On error it returns a fallback font rather than raising.
+## For Plugin Developers
 
-`get_font(family, size_px)` looks the family up in `font_catalog` and loads
-it (cached per family and size).
+> **Note**: plugins that ship their own fonts via a `"fonts"` block
+> in `manifest.json` are registered automatically during plugin load
+> (`src/plugin_system/plugin_manager.py` calls
+> `FontManager.register_plugin_fonts()`). The `plugin://…` source
+> URIs documented below are resolved relative to the plugin's
+> install directory.
+>
+> The **Fonts** tab in the web UI that lists detected
+> manager-registered fonts is still a **placeholder
+> implementation** — fonts that managers register through
+> `register_manager_font()` do not yet appear there. The
+> programmatic per-element override workflow described in
+> [Manual Font Overrides](#manual-font-overrides) below
+> (`set_override()` / `remove_override()` / the
+> `config/font_overrides.json` store) **does** work today and is
+> the supported way to override a font for an element until the
+> Fonts tab is wired up. If you can't wait and need a workaround
+> right now, you can also just load the font directly with PIL
+> (or `freetype-py` for BDF) inside your plugin's `manager.py`
+> and skip the override system entirely.
 
-## Font families
+### Plugin Font Registration
 
-At start-up the FontManager scans `assets/fonts/` for `.ttf` and `.bdf`
-files. Each becomes a family named after the file, lower-cased and without
-the extension (`PressStart2P-Regular.ttf` → `pressstart2p-regular`). Four
-aliases are added on top:
-
-| Alias | File |
-|---|---|
-| `press_start` | `assets/fonts/PressStart2P-Regular.ttf` |
-| `four_by_six` | `assets/fonts/4x6-font.ttf` |
-| `five_by_seven` | `assets/fonts/5x7.bdf` |
-| `tom_thumb` | `assets/fonts/tom-thumb.bdf` |
-
-Read the catalog directly: `font_manager.font_catalog` is a dict of family
-name to file path. Files added later are picked up on the next start of the
-display service.
-
-## Plugin fonts
-
-Plugins that ship their own fonts declare them in a `"fonts"` block in
-`manifest.json`. The plugin manager calls
-`FontManager.register_plugin_fonts()` during plugin load. `plugin://…`
-sources are resolved relative to the plugin's install directory.
+In your plugin's `manifest.json`:
 
 ```json
 {
@@ -99,126 +172,216 @@ sources are resolved relative to the plugin's install directory.
       {
         "family": "custom_font",
         "source": "plugin://fonts/custom.ttf",
-        "metadata": {"description": "Custom plugin font", "license": "MIT"}
+        "metadata": {
+          "description": "Custom plugin font",
+          "license": "MIT"
+        }
       },
       {
         "family": "web_font",
         "source": "https://example.com/fonts/font.ttf",
-        "metadata": {"checksum": "sha256:abc123..."}
+        "metadata": {
+          "description": "Downloaded font",
+          "checksum": "sha256:abc123..."
+        }
       }
     ]
   }
 }
 ```
 
-Registered families are namespaced as `<plugin_id>::<family>`. Pass
-`plugin_id` to `resolve_font()` to use the short name:
+### Using Plugin Fonts
 
 ```python
-font = self.font_manager.resolve_font(
-    element_key=f"{self.plugin_id}.text",
-    family="custom_font",          # resolved as "my-plugin::custom_font"
-    size_px=10,
-    plugin_id=self.plugin_id,
-)
+class PluginManager:
+    def __init__(self, config, display_manager, cache_manager, plugin_id):
+        self.font_manager = display_manager.font_manager
+        self.plugin_id = plugin_id
+        
+    def display(self):
+        # Use plugin font (automatically namespaced)
+        font = self.font_manager.resolve_font(
+            element_key=f"{self.plugin_id}.text",
+            family="custom_font",  # Will be resolved as "my-plugin::custom_font"
+            size_px=10,
+            plugin_id=self.plugin_id
+        )
+        
+        self.display_manager.draw_text("Plugin Text", font=font)
 ```
 
-## Overrides
+## Manual Font Overrides
 
-`resolve_font()` still honours `config/font_overrides.json` (a map of
-element key to `family` and/or `size_px`), which is read once at start-up.
-The methods that edited it — `set_override()`, `remove_override()`,
-`get_overrides()` — were removed in 3.8.0, and there is no web UI or REST endpoint
-for overrides (the override editor and `/api/v3/fonts/overrides` were
-removed). To let users choose a font, add a field to your plugin's config
-schema.
+Users can override any font through the web interface:
 
-## Font usage in the web UI
+1. Navigate to **Fonts** tab
+2. View **Detected Manager Fonts** to see what's currently in use
+3. In **Element Overrides** section:
+   - Select the element (e.g., "nfl.live.score")
+   - Choose a different font family
+   - Choose a different size
+   - Click **Add Override**
 
-The web UI's **Fonts** tab lists, uploads, previews and deletes the font
-files in `assets/fonts/`. The web interface runs in its own process and has
-no FontManager, so the display service publishes which plugin uses which
-font ([`src/font_usage.py`](../src/font_usage.py)), and the tab's **Used by**
-column reads it:
+Overrides are stored in `config/font_overrides.json` and persist across restarts.
 
-- **Source**: `register_manager_font()` registrations of the loaded
-  plugins. `get_font()` and `resolve_font()` do not know the calling plugin
-  and are not counted, and neither is a plugin that opens a font file
-  directly with PIL — register the fonts your plugin draws with if you want
-  them listed.
-- **Names**: a family, alias or path is resolved through `font_catalog` to
-  the file it loads and reported under that file's name without extension
-  (`PressStart2P-Regular`, `4x6-font`, `5x7`, `tom-thumb`), which is how the
-  Fonts tab keys its rows. Fonts outside `assets/fonts/` (a plugin's own
-  `plugin_id::family` fonts) and families that resolve to nothing are left
-  out.
-- **When**: a daemon thread started once plugins have loaded checks every
-  10 seconds and writes the `font_usage_snapshot` cache key only when the
-  usage changed (and once a day, so the cache's cleanup never expires it).
-  Unloading a plugin drops its registrations (`forget_manager_fonts`).
-- **Unknown**: until the display service has published, the column reads
-  "unknown" and `GET /api/v3/fonts/catalog` returns `used_by: null`.
-- The tab warns before deleting a font that a loaded plugin registered.
-
-## Text measurement
+### Programmatic Overrides
 
 ```python
+# Set override
+font_manager.set_override(
+    element_key="nfl.live.score",
+    family="four_by_six",
+    size_px=8
+)
+
+# Remove override
+font_manager.remove_override("nfl.live.score")
+
+# Get all overrides
+overrides = font_manager.get_overrides()
+```
+
+## Font Discovery
+
+### Available Fonts
+
+The FontManager automatically scans `assets/fonts/` for TTF and BDF fonts:
+
+```python
+# Get all available fonts
+fonts = font_manager.get_available_fonts()
+# Returns: {'press_start': 'assets/fonts/PressStart2P-Regular.ttf', ...}
+
+# Check if font exists
+if "my_font" in fonts:
+    font = font_manager.get_font("my_font", 10)
+```
+
+### Adding Custom Fonts
+
+Place font files in `assets/fonts/` directory:
+- Supported formats: `.ttf`, `.bdf`
+- Font family name is derived from filename (without extension)
+- Will be automatically discovered on next initialization
+
+## Performance Monitoring
+
+```python
+# Get performance stats
+stats = font_manager.get_performance_stats()
+
+print(f"Cache hit rate: {stats['cache_hit_rate']*100:.1f}%")
+print(f"Total fonts cached: {stats['total_fonts_cached']}")
+print(f"Failed loads: {stats['failed_loads']}")
+print(f"Manager fonts: {stats['manager_fonts']}")
+print(f"Plugin fonts: {stats['plugin_fonts']}")
+```
+
+## Text Measurement
+
+```python
+# Measure text dimensions
 width, height, baseline = font_manager.measure_text("Hello", font)
+
+# Get font height
 font_height = font_manager.get_font_height(font)
 ```
 
-## Tips
+## Best Practices
 
-- BDF fonts usually look better than TTF at small sizes on LED panels.
-- Use `{plugin_id}.{element}` element keys.
-- Register the fonts you draw with, so the Fonts tab can warn before one is
-  deleted.
-- Replace direct `ImageFont.truetype("assets/fonts/...", 8)` calls with
-  `resolve_font()`: it caches, resolves paths against the install directory,
-  and handles BDF files.
+### For Managers
+
+1. **Register all fonts** you use for visibility
+2. **Use consistent element keys** (e.g., `{manager_id}.{element_type}`)
+3. **Cache font references** if using same font multiple times
+4. **Use `resolve_font()`** not `get_font()` directly to support overrides
+5. **Define sensible defaults** that work well on LED matrix
+
+### For Plugins
+
+1. **Use plugin-relative paths** (`plugin://fonts/...`)
+2. **Include font metadata** (license, description)
+3. **Provide fallback** fonts if custom fonts fail to load
+4. **Test with different display sizes**
+
+### General
+
+1. **BDF fonts** are often better for small sizes on LED matrices
+2. **TTF fonts** work well for larger sizes
+3. **Monospace fonts** are easier to align
+4. **Test on actual hardware** - what looks good on screen may not work on LED matrix
+
+## Migration from Old System
+
+### Old Way (Direct Font Loading)
+```python
+self.font = ImageFont.truetype("assets/fonts/PressStart2P-Regular.ttf", 8)
+```
+
+### New Way (FontManager)
+```python
+element_key = f"{self.manager_id}.text"
+self.font_manager.register_manager_font(
+    manager_id=self.manager_id,
+    element_key=element_key,
+    family="pressstart2p-regular",
+    size_px=8
+)
+self.font = self.font_manager.resolve_font(
+    element_key=element_key,
+    family="pressstart2p-regular",
+    size_px=8
+)
+```
 
 ## Troubleshooting
 
-**Font not found**
-- Check the file exists in `assets/fonts/`.
-- The family name is the filename without extension, lower-cased.
-- Check the display service log for font discovery errors.
+### Font Not Found
+- Check font file exists in `assets/fonts/`
+- Verify font family name matches filename (without extension, lowercase)
+- Check logs for font discovery errors
 
-**Plugin fonts not loading**
-- Check the manifest's `"fonts"` block.
-- Check the log for download or registration errors, and that font URLs are
-  reachable.
+### Override Not Working
+- Verify element key matches exactly what manager registered
+- Check `config/font_overrides.json` for correct syntax
+- Restart application to ensure overrides are loaded
 
-## API reference
+### Performance Issues
+- Check cache hit rate in performance stats
+- Reduce number of unique font/size combinations
+- Clear cache if it grows too large: `font_manager.clear_cache()`
 
-Current methods:
+### Plugin Fonts Not Loading
+- Verify plugin manifest syntax
+- Check plugin directory structure
+- Review logs for download/registration errors
+- Ensure font URLs are accessible
 
-| Method | Purpose |
-|---|---|
-| `register_manager_font(manager_id, element_key, family, size_px, color=None)` | Record a font choice (feeds the Fonts tab) |
-| `forget_manager_fonts(manager_id)` | Drop a manager's registrations (core calls it when a plugin unloads) |
-| `resolve_font(element_key, family, size_px, plugin_id=None)` | Get a font, applying overrides and plugin namespacing |
-| `get_font(family, size_px)` | Get a font directly |
-| `get_native_bdf_size(family)` | Native pixel size of a BDF family, or `None` |
-| `measure_text(text, font)` | `(width, height, baseline)` |
-| `get_font_height(font)` | Line height |
-| `register_plugin_fonts(plugin_id, font_manifest)` | Register a plugin's fonts (core calls it at load) |
-| `forget_plugin_fonts(plugin_id)` | Drop a plugin's manifest fonts and their cached objects (core calls it when a plugin unloads) |
-| `clear_cache()` | Drop cached fonts and metrics |
-| `font_catalog` (attribute) | Family name → file path |
+## API Reference
 
-### Removed methods
+### FontManager Methods
 
-Removed in 3.8.0, after logging a deprecation warning on first call since
-3.5.0.
+- `register_manager_font(manager_id, element_key, family, size_px, color=None)` - Register font usage
+- `resolve_font(element_key, family, size_px, plugin_id=None)` - Get font with override support
+- `get_font(family, size_px)` - Get font directly (bypasses overrides)
+- `measure_text(text, font)` - Measure text dimensions
+- `get_font_height(font)` - Get font height
+- `set_override(element_key, family=None, size_px=None)` - Set manual override
+- `remove_override(element_key)` - Remove override
+- `get_overrides()` - Get all overrides
+- `get_detected_fonts()` - Get all detected font usage
+- `get_manager_fonts(manager_id=None)` - Get fonts by manager
+- `get_available_fonts()` - Get font catalog
+- `get_size_tokens()` - Get size token definitions
+- `get_performance_stats()` - Get performance metrics
+- `clear_cache()` - Clear font cache
+- `register_plugin_fonts(plugin_id, font_manifest)` - Register plugin fonts
+- `unregister_plugin_fonts(plugin_id)` - Unregister plugin fonts
+
+## Example: Complete Manager Implementation
+
+For a working example of the font manager API in use, see
+`src/font_manager.py` itself and the bundled scoreboard base classes
+in `src/base_classes/` (e.g., `hockey.py`, `football.py`) which
+register and resolve fonts via the patterns documented above.
 
-| Method | Use instead |
-|---|---|
-| `get_available_fonts()`, `get_font_catalog()` | read `font_catalog` |
-| `get_size_tokens()` | pass a pixel size |
-| `get_performance_stats()` | — |
-| `set_override()`, `remove_override()`, `get_overrides()` | a font field in your plugin's config schema |
-| `get_manager_fonts()`, `get_detected_fonts()` | — |
-| `get_plugin_fonts()` | — |
-| `unregister_plugin_fonts()` | `forget_plugin_fonts()` (core calls it on unload) |
-| `add_font()`, `remove_font()`, `validate_font()` | the web UI's Fonts tab |

docs/GETTING_STARTED.md

@@ -15,54 +15,24 @@ This guide will help you set up your LEDMatrix display for the first time and ge
 - Power supply (5V, 4A minimum recommended)
 - MicroSD card (16GB minimum)
 
-**Software:**
-- Raspberry Pi OS Lite, Trixie (Debian 13) or Bookworm (Debian 12). Trixie
-  is the current release; Bookworm is listed as Legacy in Raspberry Pi
-  Imager. No other system is supported, and the installer says so up front.
-- The OS's own Python: 3.13 on Trixie, 3.11 on Bookworm
-
 **Network:**
 - WiFi network (or Ethernet cable)
 - Computer with web browser on same network
 
 ---
 
-## Quick Start
+## Quick Start (5 Minutes)
 
-### 1. Install LEDMatrix
+### 1. First Boot
 
-There is no prebuilt SD card image — you install LEDMatrix onto stock
-Raspberry Pi OS Lite yourself:
+1. Insert the MicroSD card with LEDMatrix installed
+2. Connect the LED matrix to your Raspberry Pi
+3. Plug in the power supply
+4. Wait for the Pi to boot (about 60 seconds)
 
-1. Flash Raspberry Pi OS Lite (Trixie, or Bookworm) to the MicroSD card
-   (Raspberry Pi Imager)
-2. Connect the LED matrix to your Raspberry Pi, insert the card, and
-   power on
-3. SSH into the Pi and run the one-shot installer:
-   ```bash
-   curl -fsSL https://raw.githubusercontent.com/ChuckBuilds/LEDMatrix/main/scripts/install/one-shot-install.sh | bash
-   ```
-   or clone the repo and run `sudo ./first_time_install.sh` — see the
-   [README Installation Steps / Quick Install](../README.md#installation-steps)
-   for full details
-
-   The one-shot installer installs the newest release (the **stable** update
-   channel). To run the newest, unreleased code from `main` instead (the
-   **beta** channel), put `LEDMATRIX_CHANNEL=beta` in front of `bash`:
-   ```bash
-   curl -fsSL https://raw.githubusercontent.com/ChuckBuilds/LEDMatrix/main/scripts/install/one-shot-install.sh | LEDMATRIX_CHANNEL=beta bash
-   ```
-   A manual clone starts on `main`; add `--beta` to `first_time_install.sh`
-   to stay on it, or leave it off and the first update after the next
-   release moves the device onto releases. You can switch channels later on
-   the General tab.
-
-**Expected Behavior after install:**
+**Expected Behavior:**
 - LED matrix will light up
-- A fresh install ships only the bundled `starlark-apps` and
-  `web-ui-info` plugins — clock, weather, sports, etc. must be
-  installed from the Plugin Store (web UI → Plugin Manager) before
-  anything else displays
+- Display will show default plugins (clock, weather, etc.)
 - Pi creates WiFi network "LEDMatrix-Setup" if not connected
 
 ### 2. Connect to WiFi
@@ -101,10 +71,10 @@ You should see:
 
 1. Open the **Display** tab
 2. Set your matrix configuration:
-   - **Rows**: match your panel — commonly 32 or 64; any even number
-     from 8 to 64
-   - **Columns**: match your panel — commonly 64 or 96; at least 16,
-     with no upper limit
+   - **Rows**: 32 or 64 (match your hardware)
+   - **Columns**: commonly 64 or 96; the web UI accepts any integer
+     in the 16–128 range, but 64 and 96 are the values the bundled
+     panel hardware ships with
    - **Chain Length**: Number of panels chained horizontally
    - **Hardware Mapping**: usually `adafruit-hat-pwm` (with the PWM jumper
      mod) or `adafruit-hat` (without). See the root README for the full list.
@@ -134,8 +104,8 @@ weather and other location-aware plugins.
 4. Wait for installation to finish — installed plugins appear in the
    **Installed Plugins** section above and get their own tab in the second
    nav row
-5. Toggle the plugin to enabled. The running display loads it within a
-   few seconds; no restart is needed
+5. Toggle the plugin to enabled
+6. From **Overview**, click **Restart Display Service**
 
 You can also install community plugins straight from a GitHub URL using the
 **Install from GitHub** section further down the same tab — see
@@ -145,15 +115,10 @@ You can also install community plugins straight from a GitHub URL using the
 
 1. Each installed plugin gets its own tab in the second navigation row
 2. Open that plugin's tab to edit its settings (favorite teams, API keys,
-   update intervals, etc.)
-3. Click **Save**. The display service watches `config.json` and hands the
-   new settings to the running plugin, so no restart is needed. If a plugin
-   still shows old settings, restart the display service from **Overview**
-
-**Note:** how long each plugin stays on screen is not set in the
-plugin's own tab — use the **Rotation** tab's **Screen Durations**
-section instead (saved to `display.display_durations` in
-`config.json`).
+   update intervals, display duration, etc.)
+3. Click **Save**
+4. Restart the display service from **Overview** so the new settings take
+   effect
 
 **Example: Weather Plugin**
 - Set your location (city, state, country)
@@ -215,15 +180,14 @@ The fastest way to verify a plugin works without waiting for the rotation:
 
 **Check:**
 1. Plugin is enabled (toggle on the **Plugin Manager** tab)
-2. Plugin's display duration is non-zero
-3. No errors in the **Logs** tab for that plugin. A plugin whose
-   `validate_config()` fails is not loaded until its settings are fixed
+2. Display service was restarted after enabling
+3. Plugin's display duration is non-zero
+4. No errors in the **Logs** tab for that plugin
 
 **Fix:**
 1. Enable the plugin from **Plugin Manager**
-2. Check the **Logs** tab for plugin-specific errors
-3. If it still does not appear, click **Restart Display Service** on
-   **Overview**
+2. Click **Restart Display Service** on **Overview**
+3. Check the **Logs** tab for plugin-specific errors
 
 ### Weather Plugin Shows "No Data"
 
@@ -244,36 +208,18 @@ The fastest way to verify a plugin works without waiting for the rotation:
 ### Customize Your Display
 
 **Adjust display durations:**
-- Open the **Rotation** tab and use the **Screen Durations** section to
-  set how long each plugin stays on screen per rotation (saved to
-  `display.display_durations`).
+- Each plugin's tab has a **Display Duration (seconds)** field — set how
+  long that plugin stays on screen each rotation.
 
 **Organize plugin order:**
-- The **Rotation** tab also has a drag-and-drop **Rotation Order** list
-  (saved to `display.plugin_rotation_order`). Enable/disable plugins
-  from the **Plugin Manager** tab.
+- Use the **Plugin Manager** tab to enable/disable plugins. The display
+  cycles through enabled plugins in the order they appear.
 
 **Add more plugins:**
 - Check the **Plugin Store** section of **Plugin Manager** for new plugins.
 - Install community plugins straight from a GitHub URL via
   **Install from GitHub** on the same tab.
 
-### Keep LEDMatrix Up to Date
-
-- **Update Code** on the **Overview** tab installs the newest version, and a
-  banner at the top of the page says when one is available.
-- **General → Automatic Updates** does it once a week, overnight, with a
-  health check that undoes an update that breaks the device.
-- **General → Update Channel** picks which version that is. **Stable** (the
-  default) installs releases, which have been tested and have release
-  notes. **Beta** installs the newest code as soon as it is written, before
-  it is released: fixes arrive sooner, and so do new problems.
-- Switching to Stable never installs an older version than the one you
-  have. If your device is already newer than the latest release (which is
-  normal if it was set up or updated from the newest code), it keeps
-  getting the newest code until the next release includes it, then follows
-  releases from there. The General tab says when this is the case.
-
 ### Enable Advanced Features
 
 **Vegas Scroll Mode:**
@@ -334,14 +280,10 @@ sudo journalctl -u ledmatrix-web -f
 │   ├── config_secrets.json   # API keys and secrets
 │   └── wifi_config.json      # WiFi settings
 ├── plugin-repos/             # Installed plugins (default location)
+├── cache/                    # Cached data
 └── web_interface/            # Web interface files
 ```
 
-> Cached data does not live in the project directory — the cache manager
-> uses the first writable location among `/var/cache/ledmatrix`,
-> `~/.ledmatrix_cache`, `/opt/ledmatrix/cache`, and
-> `$TMPDIR/ledmatrix_cache`.
->
 > The plugin install location is configurable via
 > `plugin_system.plugins_directory` in `config.json`. The default is
 > `plugin-repos/`. Plugin discovery (`PluginManager.discover_plugins()`)
@@ -361,14 +303,11 @@ System tabs:
 - WiFi              Network selection and AP-mode setup
 - Schedule          Power and dim schedules
 - Display           Matrix hardware configuration
-- Rotation          Rotation order (drag-and-drop) and screen durations
 - Config Editor     Raw config.json editor
-- Backup & Restore  Config backup and restore
 - Fonts             Upload and manage fonts
 - Logs              Real-time log viewing
 - Cache             Cached data inspection and cleanup
 - Operation History Recent service operations
-- Tools             System diagnostics, updates, dependencies, maintenance
 
 Plugin tabs (second row):
 - Plugin Manager    Browse the Plugin Store, install/enable plugins

docs/HOW_TO_RUN_TESTS.md

@@ -10,7 +10,10 @@ Make sure you have the testing packages installed:
 
 ```bash
 # Install all dependencies including test packages
-pip install -r requirements.txt -r requirements-test.txt
+pip install -r requirements.txt
+
+# Or install just the test dependencies
+pip install pytest pytest-cov pytest-mock
 ```
 
 ### 2. Set Environment Variables
@@ -52,26 +55,28 @@ pytest test/test_display_controller.py test/test_plugin_system.py
 
 ```bash
 # Run a specific test class
-pytest test/test_display_controller.py::TestDisplayControllerLivePriority
+pytest test/test_display_controller.py::TestDisplayControllerModeRotation
 
 # Run a specific test function
-pytest test/test_display_controller.py::TestDisplayControllerSchedule::test_active_hours
+pytest test/test_display_controller.py::TestDisplayControllerModeRotation::test_basic_rotation
 ```
 
 ### Run Tests by Marker
 
-`pytest.ini` declares the markers `unit`, `integration`, `hardware`, `slow`
-and `plugin` (with `--strict-markers`, so a typo in a marker name is an
-error). Few tests are marked: only a handful carry `unit`, and none currently
-carry `integration`, `slow` or `hardware`, so `-m integration` and `-m slow`
-select nothing. Select tests by file, directory or `-k` instead.
+The tests use markers to categorize them:
 
 ```bash
-# What CI runs for the core suites (excludes anything marked hardware)
-pytest -m "not hardware" test/ --ignore=test/plugins
+# Run only unit tests (fast, isolated)
+pytest -m unit
 
-# Tests whose name matches an expression
-pytest -k "config and not secrets"
+# Run only integration tests
+pytest -m integration
+
+# Run tests that don't require hardware
+pytest -m "not hardware"
+
+# Run slow tests
+pytest -m slow
 ```
 
 ### Run Tests in a Directory
@@ -98,7 +103,7 @@ When you run `pytest`, you'll see:
 
 ```
 test/test_display_controller.py::TestDisplayControllerInitialization::test_init_success PASSED
-test/test_display_controller.py::TestDisplayControllerOnDemand::test_activate_on_demand PASSED
+test/test_display_controller.py::TestDisplayControllerModeRotation::test_basic_rotation PASSED
 ...
 ```
 
@@ -136,73 +141,71 @@ pytest -sv
 
 ## Coverage Reports
 
-Coverage is not collected by a plain `pytest` run: `pytest.ini` deliberately
-has no coverage flags, so local runs stay fast. Ask for it explicitly
-(needs `pytest-cov`, which is in `requirements-test.txt`):
+The test suite is configured to generate coverage reports.
+
+### View Coverage in Terminal
 
 ```bash
-# Terminal summary
-pytest --cov=src --cov=web_interface --cov-report=term test/ --ignore=test/plugins
+# Coverage is automatically shown when running pytest
+pytest
 
-# HTML report in htmlcov/
-pytest --cov=src --cov=web_interface --cov-report=html test/ --ignore=test/plugins
+# The output will show something like:
+# ----------- coverage: platform linux, python 3.11.5 -----------
+# Name                                    Stmts   Miss  Cover   Missing
+# ---------------------------------------------------------------------
+# src/display_controller.py                 450     120    73%   45-67, 89-102
 ```
 
-Then open `htmlcov/index.html` in your browser (`xdg-open` on Linux, `open`
-on macOS, `start` on Windows).
+### Generate HTML Coverage Report
+
+```bash
+# HTML report is automatically generated in htmlcov/
+pytest
+
+# Then open the report in your browser
+# On Linux:
+xdg-open htmlcov/index.html
+
+# On macOS:
+open htmlcov/index.html
+
+# On Windows:
+start htmlcov/index.html
+```
+
+The HTML report shows:
+- Line-by-line coverage
+- Files with low coverage highlighted
+- Interactive navigation
 
 ### Coverage Threshold
 
-The only threshold is in CI: the core unit-test job in
-[`.github/workflows/test.yml`](../.github/workflows/test.yml) runs with
-`--cov-fail-under=52`. To check it locally, add that flag to the command
-above.
+The tests are configured to fail if coverage drops below 30%. To change this, edit `pytest.ini`:
+
+```ini
+--cov-fail-under=30  # Change this value
+```
 
 ## Common Test Scenarios
 
 ### Run Tests After Making Changes
 
 ```bash
-# Quick run: just the tests for the area you changed
-pytest test/test_config_manager.py
+# Quick test run (just unit tests)
+pytest -m unit
 
 # Full test suite
 pytest
 ```
 
-### Web UI JavaScript Tests
-
-The suites in `test/js` need node; the DOM ones also need jsdom and a running
-web interface (details in [`test/js/README.md`](../test/js/README.md)):
-
-```bash
-npm install --no-audit --no-fund --prefix test/js   # jsdom; node_modules is gitignored
-EMULATOR=true python3 web_interface/app.py           # in another shell
-BASE=http://localhost:5000 REQUIRE_DOM=1 node test/js/run_all.js
-```
-
-`pytest test/test_js_unit_suites.py` runs just the unit suites.
-
-### Plugin Config Form Parity
-
-`test/test_field_model_parity.py` checks `build_field_model` against the
-`render_field` macro for every plugin schema it finds
-([WEB_FRONTEND_ARCHITECTURE.md](WEB_FRONTEND_ARCHITECTURE.md)). It always
-covers `plugin-repos/` and the test fixtures; point it at a checkout of the
-official plugins to cover those too:
-
-```bash
-LEDMATRIX_MONOREPO_PLUGINS=../ledmatrix-plugins/plugins pytest test/test_field_model_parity.py
-```
-
 ### Debug a Failing Test
 
 ```bash
 # Run with maximum verbosity and show print statements
-pytest -vv -s test/test_display_controller.py::TestDisplayControllerSchedule::test_active_hours
+pytest -vv -s test/test_display_controller.py::TestDisplayControllerModeRotation::test_basic_rotation
 
 # Run with Python debugger (pdb)
-pytest --pdb test/test_display_controller.py::TestDisplayControllerSchedule::test_active_hours
+pytest --pdb test/test_display_controller.py::TestDisplayControllerModeRotation::test_basic_rotation
 ```
 
 ### Run Tests in Parallel (Faster)
@@ -245,15 +248,22 @@ test/
 ├── test_config_service.py               # Config service tests
 ├── test_config_validation_edge_cases.py # Config edge cases
 ├── test_font_manager.py                 # Font manager tests
+├── test_layout_manager.py               # Layout manager tests
 ├── test_text_helper.py                  # Text helper tests
 ├── test_error_handling.py               # Error handling tests
 ├── test_error_aggregator.py             # Error aggregation tests
 ├── test_schema_manager.py               # Schema manager tests
 ├── test_web_api.py                      # Web API tests
-├── plugins/                             # Plugin rendering suites
-│   ├── test_plugin_matrix.py            # Every discovered plugin, across panel sizes
-│   ├── test_harness.py
-│   └── test_visual_rendering.py
+├── test_nba_*.py                        # NBA-specific test suites
+├── plugins/                             # Per-plugin test suites
+│   ├── test_clock_simple.py
+│   ├── test_calendar.py
+│   ├── test_basketball_scoreboard.py
+│   ├── test_soccer_scoreboard.py
+│   ├── test_odds_ticker.py
+│   ├── test_text_display.py
+│   ├── test_visual_rendering.py
+│   └── test_plugin_base.py
 └── web_interface/
     ├── test_config_manager_atomic.py
     ├── test_state_reconciliation.py
@@ -278,8 +288,8 @@ test/
 If you see import errors:
 
 ```bash
-# Make sure you're in the project root (wherever you cloned it)
-cd ~/LEDMatrix
+# Make sure you're in the project root
+cd /home/chuck/Github/LEDMatrix
 
 # Check Python path
 python -c "import sys; print(sys.path)"
@@ -294,7 +304,7 @@ If tests fail due to missing packages:
 
 ```bash
 # Install all dependencies
-pip install -r requirements.txt -r requirements-test.txt
+pip install -r requirements.txt
 
 # Or install specific missing package
 pip install <package-name>
@@ -320,37 +330,37 @@ If coverage reports aren't generating:
 # Make sure pytest-cov is installed
 pip install pytest-cov
 
-# Coverage is opt-in; ask for it explicitly
-pytest --cov=src --cov=web_interface --cov-report=html
+# Run with explicit coverage
+pytest --cov=src --cov-report=html
 ```
 
 ## Continuous Integration
 
-The repo runs the pytest suite via
-[`.github/workflows/test.yml`](../.github/workflows/test.yml) on every
-push and pull request: a plugin-safety job that runs `test/plugins/`, and a
-core unit-test job that runs the whole `test/` tree except `test/plugins/`
-with `-m "not hardware"` and enforces coverage (`--cov-fail-under=52`). New
-test files are picked up automatically. Release version consistency is checked by
-[`.github/workflows/release-version-check.yml`](../.github/workflows/release-version-check.yml).
-Bandit, flake8, mypy and gitleaks run as pre-commit hooks (see
-`.pre-commit-config.yaml`), not in CI.
+The repo runs
+[`.github/workflows/security-audit.yml`](../.github/workflows/security-audit.yml)
+(bandit + semgrep) on every push. A pytest CI workflow at
+`.github/workflows/tests.yml` is queued to land alongside this
+PR ([ChuckBuilds/LEDMatrix#307](https://github.com/ChuckBuilds/LEDMatrix/pull/307));
+the workflow file itself was held back from that PR because the
+push token lacked the GitHub `workflow` scope, so it needs to be
+committed separately by a maintainer. Once it's in, this section
+will be updated to describe what the job runs.
 
 ## Best Practices
 
 1. **Run tests before committing**:
    ```bash
-   pytest test/test_<area>.py  # Quick check of what you touched
+   pytest -m unit  # Quick check
    ```
 
 2. **Run full suite before pushing**:
    ```bash
-   pytest  # Full test suite (add --cov flags for coverage)
+   pytest  # Full test suite with coverage
    ```
 
 3. **Fix failing tests immediately** - Don't let them accumulate
 
-4. **Keep coverage above threshold** - CI fails below 52%
+4. **Keep coverage above threshold** - Aim for 70%+ coverage
 
 5. **Write tests for new features** - Add tests when adding new functionality
 
@@ -358,9 +368,9 @@ Bandit, flake8, mypy and gitleaks run as pre-commit hooks (see
 
 ```bash
 # Most common commands
-pytest                    # Run all tests (no coverage)
+pytest                    # Run all tests with coverage
 pytest -v                 # Verbose output
-pytest test/test_x.py     # Run one file
+pytest -m unit           # Run only unit tests
 pytest -k "test_name"    # Run tests matching pattern
 pytest --cov=src         # Generate coverage report
 pytest -x                # Stop on first failure

docs/IPC_CONTROL_SOCKET.md

@@ -1,742 +0,0 @@
-# Control socket (web → display)
-
-The display process serves a Unix socket that the web interface uses to send
-it commands and get an answer back. It replaces the cache-file "mailboxes" on
-the SD card one command at a time. Stage 1 carries on-demand start, stop and
-status. Stage 2 makes those commands land within a frame on every kind of
-screen, and adds `brightness.set` and `plugin.reload`. Stage 3 adds a state
-stream (`state.get`, `state.subscribe`), so the web interface reads what the
-display is doing from the socket instead of from cache files the display
-wrote to the SD card. Stage 4 makes the socket the only way a command goes
-while it works: the web interface writes a mailbox only when the socket
-cannot carry the request, `errors.clear` replaces the last command that
-always went through a mailbox, and the display looks at the mailboxes once
-a second, with a `stat()`. The file mailboxes and the cache keys stay as a
-fallback for one release.
-
-| | |
-|---|---|
-| Socket | `/run/ledmatrix/control.sock` (tmpfs) |
-| Served by | the display process ([`src/ipc/server.py`](../src/ipc/server.py)), started by `DisplayController.run()` |
-| Used by | the web interface ([`src/ipc/client.py`](../src/ipc/client.py)): `POST /api/v3/display/on-demand/start` and `/stop`, `POST /api/v3/plugins/update` (reload), `POST /api/v3/config/main` (brightness), `POST /api/v3/errors/clear`; and through [`web_interface/display_state.py`](../web_interface/display_state.py) (the state stream), `GET /api/v3/display/current-status`, `/display/on-demand/status`, `/plugins/installed` (`runtime`), `/plugins/state` and the reconciliations, `/health` (`display_loop`) |
-| Contract | [`src/ipc/contract.py`](../src/ipc/contract.py): messages, versions, framing and the socket path; both sides import it |
-| Override | `LEDMATRIX_CONTROL_SOCKET=/some/path.sock` for both processes, or `=off` to disable it |
-
-## Why
-
-Before the socket, the web interface sent commands by writing a cache key
-(`display_on_demand_request`) that the display read every 0.25 s.
-
-- **No acknowledgement.** The route answered "success" once the file was
-  written, whether or not a display was running to read it.
-- **Lost requests.** The display had to read the request and then delete it.
-  A request written between those two steps could be thrown away (see
-  `_consume_on_demand_request`). The cache has no atomic claim to prevent it.
-- **Fragile.** Each channel repeated its own permission, atomic-write,
-  staleness and in-memory-cache rules. Two of them caused bugs: a `memory_ttl`
-  bug ignored every on-demand request after the first for an hour, and a
-  stopped display was still reported as "active" for two minutes.
-
-The socket answers every command, carries one request per message (so nothing
-can overwrite it), and belongs to the display process. If the display is not
-running, the socket does not exist, and the web interface knows right away.
-
-## Protocol (version 1)
-
-Stage 3 is still version 1: `state.get` and `state.subscribe` are new
-commands, and a stage-2 display answers them `unknown_command`, which the
-web interface treats as "no socket" and falls back from.
-
-
-**Framing.** One JSON object per line (newline-delimited JSON), UTF-8, at
-most 64 KiB per line (`MAX_MESSAGE_BYTES`). Senders encode with
-`ensure_ascii`, so a newline never appears inside a message. A connection
-can carry several requests. Each request gets exactly one response, in order.
-
-**Request**
-
-```json
-{"v": 1, "id": "5f0c…", "cmd": "on_demand.start",
- "args": {"plugin_id": "clock", "mode": null, "duration": 30, "pinned": false}}
-```
-
-- `v` is the protocol version.
-- `id` is a printable string of 1-128 characters. It is echoed back in the
-  response, and for on-demand commands it is also the on-demand `request_id`.
-- `cmd` is a command name.
-- `args` is an object. It may be omitted when a command takes no arguments.
-
-**Response**
-
-```json
-{"v": 1, "id": "5f0c…", "ok": true,  "result": {"accepted": true, "request_id": "5f0c…", "queued": 1}}
-{"v": 1, "id": "5f0c…", "ok": false, "error": {"code": "busy", "message": "…"}}
-```
-
-`id` is `null` only when the request could not be parsed far enough to have
-one. Clients branch on `error.code`, never on the message text.
-
-**Commands**
-
-| `cmd` | `args` | `result` | Kind |
-|---|---|---|---|
-| `hello` | `{versions: [int], client?: str}` | `{version, versions, commands, max_message_bytes, server}` | answered directly |
-| `ping` | — | `{pong: true}` | answered directly |
-| `on_demand.start` | `{plugin_id?, mode?, duration?, pinned?}` (at least one of `plugin_id` and `mode`) | ack | queued |
-| `on_demand.stop` | — | ack | queued |
-| `on_demand.status` | — | `{on_demand: {...}, current_mode, display_active}` | answered directly |
-| `brightness.set` | `{brightness: int 0-100}` | `{brightness, panel_brightness, dimmed, display_active}` | queued, awaited (2 s) |
-| `plugin.reload` | `{plugin_id}` | `{plugin_id, reloaded: true, version, modes}` | queued, awaited (10 s) |
-| `state.get` | `{since?, epoch?}` | a state snapshot (see "The state stream") | answered directly |
-| `state.subscribe` | — | a state snapshot, then pushed `state` / `tick` events | answered directly, then a stream |
-| `errors.clear` | `{cutoff: number}` (epoch seconds, finite, ≥ 0) | `{request_id, cutoff, cleared}` | answered directly, once applied |
-
-`errors.clear` (stage 4) forgets the plugin errors the display recorded at
-or before `cutoff` and rewrites its error snapshot (`plugin_error_snapshot`)
-before it answers, so the web interface's next read already has it. The
-request `id` is the clear's id, which the snapshot reports as
-`applied_clear_id`. It is answered on the connection thread by a handler the
-display registers (`ControlServer(handlers=...)`, the contract's
-`DIRECT_COMMANDS`): the error aggregator and its publisher have their own
-locks, and nothing the render thread owns is touched. A display that has no
-handler answers `unknown_command`, as an older display does.
-
-`duration` is a number of seconds, or a numeric string. `0`, `null` or `""`
-mean "until stopped". `pinned` must be a real boolean: the REST route has
-already converted strings like `"false"` before it sends the command. The
-`on_demand` object in `on_demand.status` is the same dict the display
-publishes to `display_on_demand_state`.
-
-`brightness.set` sets the panel's normal brightness. It is transient: it
-writes nothing to `config.json`, and the next config the display's watcher
-loads (or a restart) puts the configured value back. The web interface
-sends it after it has saved the setting, so the two agree. The dim schedule
-still applies on top, so `panel_brightness` is the dim level while the
-schedule dims. While the schedule has the display off, the new level is
-kept for when it comes back on.
-
-`plugin.reload` loads a plugin the display is running again from disk,
-manifest included: the steps of disabling it live and enabling it again,
-with its modes kept in their place in the rotation. Only a running plugin
-can be reloaded (`not_loaded` otherwise), so the id never makes the display
-import anything new. A plugin loaded only for an on-demand session gets
-`busy`. A new version that fails to load gets `failed` and stays out of the
-rotation, as it would after a restart. The load runs off the render thread,
-so the panel keeps scrolling while it happens (see below).
-
-**Acknowledgements.** A queued on-demand command is *accepted*, not *done*.
-`{"accepted": true, "request_id": …}` means the command is waiting in the
-render thread's queue. Since stage 2 the render thread waits on that queue
-instead of sleeping, so it applies the command within one frame on every
-kind of screen (see below). Any outcome is published as before
-(`display_on_demand_state`, and `status`/`error` for a bad plugin or mode),
-and it can be read with `on_demand.status`.
-
-**Awaited commands.** `brightness.set` and `plugin.reload` are answered only
-once the render thread has applied them, with their result or their error.
-The connection thread waits for that (2 s and 10 s, `AWAIT_SECONDS` in the
-contract); the render thread never waits for a client. When the render thread
-has not got to the command in time, the answer is `pending`: the command
-stays queued and is still applied, so a client treats `pending` as "not known
-to be done", not as a refusal. The client's own timeout is one second longer
-than the display's wait, so `pending` arrives before the client gives up.
-
-**Versions.** Every request carries `v`. For any command except `hello`, a
-`v` the display does not speak gets `unsupported_version`. `hello` is checked
-by its `versions` list instead, and its result names the highest version both
-sides share, so a client can find out what a display supports before it
-relies on anything newer. The client sends `v: 1` and falls back to the
-mailbox when the display refuses it. It does not send `hello` first, which
-saves a round trip.
-
-New commands are added within a version, so stage 2 is still version 1. A
-display that does not know a command answers `unknown_command`, which the
-web interface treats like any other socket failure and falls back from, and
-`hello` lists the commands a display knows. The version changes only when the
-envelope or the meaning of an existing command changes.
-
-**Events.** `state.subscribe` is the one command with more than one message
-in reply. After its response, the display pushes events on the same
-connection until either side hangs up:
-
-```json
-{"v": 1, "id": "<the subscribe id>", "event": "state", "result": {...a state snapshot...}}
-{"v": 1, "id": "<the subscribe id>", "event": "tick",  "result": {"version": 7, "epoch": "…", "pid": 812, "served_at": 1790000000.1, "changed": false, "loop": {...}, "volatile": {"display": {"last_updated": 1790000000.0}, "...": "..."}}}
-```
-
-An event has `event` where a response has `ok`, which is how a reader tells
-them apart. The client sends nothing after the subscribe; anything it does
-send is ignored.
-
-**Error codes:** `bad_json`, `bad_request`, `message_too_large`,
-`unsupported_version`, `unknown_command`, `invalid_args`, `busy` (queue full,
-or too many connections), `forbidden` (peer credentials refused), `internal`.
-Stage 2 adds `pending` (accepted, not applied in time, still queued),
-`not_loaded` (`plugin.reload` of a plugin the display is not running) and
-`failed` (the render thread tried, and it did not work).
-
-Try it on a device:
-
-```bash
-python3 - <<'EOF'
-from src.ipc import client          # run from the project directory
-print(client.on_demand_status())
-print(client.brightness_set(60))
-EOF
-```
-
-## The state stream (stage 3)
-
-Before stage 3 the web interface learned what the display was doing by
-reading files the display kept writing:
-
-| What | Written by the display | How often | Medium |
-|---|---|---|---|
-| current mode, plugin, `is_display_active`, `on_demand_active` | `display_current_state` | every mode change, every flag change, and every 30 s | cache (SD card) |
-| on-demand session | `display_on_demand_state` | on each on-demand event | cache (SD card) |
-| plugin runtime snapshot (#690) | `plugin_runtime_snapshot` | on a change (at most every 10 s), else every 60 s | cache (SD card) |
-| render-loop liveness (#687) | `display-heartbeat.json` | every 5 s | tmpfs |
-
-Now the display also keeps the same state in memory and serves it on the
-socket.
-
-**The snapshot.** `state.get` and `state.subscribe` answer with one object:
-
-```json
-{"schema": 1, "version": 42, "epoch": "3f9c0d1e2a4b5c6d", "pid": 812,
- "served_at": 1790000000.1, "changed": true,
- "loop": {"heartbeat_age_seconds": 1.8, "armed": true, "stale_after": 60.0},
- "state": {
-   "display":    {"mode": "nfl_live", "plugin_id": "football-scoreboard", "mode_index": 3,
-                  "total_modes": 9, "on_demand_active": false, "is_display_active": true,
-                  "last_updated": 1790000000.0},
-   "on_demand":  {"active": false, "status": "idle", "...": "as display_on_demand_state"},
-   "brightness": {"brightness": 80, "panel_brightness": 40, "dimmed": true},
-   "plugins":    {"schema": 1, "running": true, "published_at": 1789999998.5, "...": "as plugin_runtime_snapshot"},
-   "loop":       {"heartbeat_age_seconds": 1.8, "armed": true, "stale_after": 60.0}
- }}
-```
-
-- `display` and `on_demand` are the dicts the cache keys hold, `plugins` is
-  the runtime snapshot (`build_runtime_snapshot`), and `brightness` is the
-  configured level, what the panel shows now, and whether the dim schedule
-  has it dimmed. A section not published yet is `null`.
-- `loop` is not published: the display measures it when it answers, from
-  the render thread's last beat in memory (`RenderWatchdog.liveness()`),
-  the same beat that writes the heartbeat file. So it keeps ageing while the
-  render thread is stuck, and the socket's connection threads still answer.
-  `heartbeat_age_seconds` is `null` until the loop has drawn its first frame.
-- `version` goes up whenever a section changes, ignoring the timestamps that
-  move on every publish (`last_updated`, `remaining`, `published_at`). It
-  counts within an `epoch`, one run of the display process, so a reader that
-  sees a new `epoch` has a restarted display.
-- `state.get` with `since` and `epoch` from an earlier answer gets just
-  `{changed: false, version, epoch, pid, served_at, loop, volatile}` while
-  nothing has changed. `volatile` is `{section: {key: value}}`: the current
-  values of those ignored timestamps, which the reader merges into the copy
-  it has. They don't make a new version, but they are still news:
-  `display.last_updated` is how a reader knows the render thread is still
-  publishing, and `plugins.published_at` the runtime publisher. Without
-  them a reader's copy kept the timestamps of the last real change, so a
-  mode on screen for over 120 s read as unknown.
-- A snapshot that would not fit in a message (hundreds of plugins) is sent
-  without `plugins`, and `truncated: ["plugins"]` says so. Readers then use
-  the cache for that section only.
-
-**The stream.** `state.subscribe` answers with the snapshot, then:
-
-- a `state` event (a full snapshot) whenever the version changes, and
-- a `tick` at least every 5 s (`SUBSCRIBE_KEEPALIVE_SECONDS`) when nothing
-  changed. It is the short `changed: false` answer, so it carries `loop`
-  (a stalled render loop shows up within one tick) and `volatile` (the
-  timestamps stay as fresh as the writers keep them), and it tells the
-  reader the connection is alive.
-
-A slow reader is never sent a backlog: each event is the latest version, so
-one that falls behind skips the versions in between. A reader that has heard
-nothing for 15 s (three keepalives) stops trusting its copy.
-
-**Who publishes, and when.** All of it is in memory, with no disk writes:
-
-- the render thread, at the places it already published the cache keys:
-  `display` and `brightness` on every pass of
-  `_publish_current_mode_state_if_changed()` (every loop pass, and every
-  `_service_pending_changes()` in a dwell, a scrolling screen or Vegas), and
-  `on_demand` in `_publish_on_demand_state()`. Every pass refreshes
-  `display.last_updated`, so a reader can tell when the render thread has
-  stopped publishing, just as the cache key's 120 s `max_age` does.
-- the plugin runtime publisher's thread, on every 5 s tick: the snapshot is
-  rebuilt when the state machine changed, otherwise only its `published_at`
-  moves. A change reaches subscribers within a tick, without the cache's
-  10 s throttle.
-
-Publishing is a hand-off, as the command queue is in the other direction.
-The hub (`StateHub` in [`src/ipc/server.py`](../src/ipc/server.py)) holds a
-lock only to swap a dict reference, compare it with the last one and bump the
-version. Every socket write happens on the subscriber's own connection
-thread. The render thread never waits for a reader.
-
-### Readers in the web interface
-
-[`web_interface/display_state.py`](../web_interface/display_state.py) holds
-one `state.subscribe` connection per web process
-(`src.ipc.client.StateSubscription`, a daemon thread, started on the first
-read and reconnecting with a backoff of 1 s up to 30 s). A route answers
-from the latest pushed snapshot in memory. Before the subscription has one,
-the route asks once with `state.get` (0.5 s timeout). When neither works, it
-reads the cache keys and the heartbeat file as before:
-
-| Route | From the socket | Fallback |
-|---|---|---|
-| `GET /api/v3/display/current-status` | `state.display` | `display_current_state` |
-| `GET /api/v3/display/on-demand/status` | `state.on_demand`, with `remaining` worked out from `expires_at` now | `display_on_demand_state` |
-| `GET /api/v3/plugins/installed` (`runtime`), `/plugins/state`, `POST /plugins/state/reconcile` and the startup reconciliation | `state.plugins` + `state.loop` | `plugin_runtime_snapshot` + `display-heartbeat.json` |
-| `GET /api/v3/health` (`checks.display_loop`) | `state.loop` | `display-heartbeat.json` |
-
-Each answer says where it came from: `source: "socket" | "cache"` (or
-`"heartbeat_file"` for the health check).
-
-The SSE display stream (`/api/v3/stream/display`) reads the preview frame
-file, not a cache key, so it does not change.
-
-**The same verdicts either way.** The socket's answers are judged by the
-rules the cache readers apply (#726):
-
-- the runtime view is `stalled` when the render loop's heartbeat age is at
-  least `HEARTBEAT_STALE_SECONDS` (60 s, the health check's threshold), and
-  then reports no per-plugin facts;
-- it is `stale` when the snapshot is older than its `stale_after` (the
-  publisher thread stopped);
-- with no beat yet, the snapshot is judged on its own;
-- there is no pid check, because the display that answered is alive;
-- a `display` section the render thread has not refreshed for 120 s reads
-  as unknown, as the cache key does once it ages out.
-
-The age a reader uses is the age the display measured, plus the time since
-the snapshot arrived.
-
-### Fewer SD writes
-
-The cache keys are still written, for one release, as the fallback. While
-the socket serves the readers, the display writes two of them less often.
-"Serves the readers" means a subscriber is connected, or a `state.get` came
-within the last 60 s (`StateHub.readers_active()`):
-
-- `display_current_state` is no longer written on every mode change: once
-  every 60 s (`CURRENT_STATE_RELAXED_REFRESH_SECONDS`, inside the readers'
-  120 s `max_age`), and at once when `is_display_active` or
-  `on_demand_active` changes.
-- `plugin_runtime_snapshot`'s refresh goes from 60 s to 120 s
-  (`RELAXED_REFRESH_INTERVAL`), and the snapshot says so in its own
-  `refresh_interval` and `stale_after` (360 s). Changes are still written at
-  once, at most every 10 s.
-
-`display_on_demand_state` is written only on events, so it is unchanged.
-The heartbeat file is on tmpfs, so it costs no SD writes, and it stays: the
-automatic update's health check reads it.
-
-This is safe because the relaxed rate only applies while readers are using
-the socket. If they stop (the web interface loses the socket, or is stopped),
-the next publish after the reader window writes a changed mode at once, and
-the runtime refresh goes back to 60 s. A fallback reader in that window sees
-a mode up to 60 s old, never one older than its `max_age`.
-
-Measured with fake clocks (`test_cache_writes_per_minute_with_and_without_socket_readers`
-in `test/test_state_stream_readers.py`), for a rotation of 15 s screens:
-
-| Key | Writes/min, no socket readers | Writes/min, socket readers |
-|---|---|---|
-| `display_current_state` | 4.0 | 1.0 |
-| `plugin_runtime_snapshot` | 1.0 | 0.5 |
-| Total | 5.0 | 1.5 |
-
-That is 70% fewer writes for these keys: about 2,200 a day instead of 7,200.
-Shorter screens save more, because the old rate followed the mode changes.
-A display that rarely changes mode (one plugin, a long live game) saves less. Plugin
-data caches, the error snapshot and font usage are written by other code
-and are not affected.
-
-## How the display applies a command
-
-The server's threads never touch rendering. A connection thread parses the
-request, validates it against the contract, and then does one of two things:
-
-- For a command that changes the panel, it puts a `QueuedCommand` on a
-  bounded queue (16 entries) and answers with the ack, or, for an awaited
-  command, with the outcome the render thread reports back through the
-  command's `CommandOutcome`.
-- For a query, it answers from a status snapshot the display provides
-  (`DisplayController._control_status`). The snapshot only reads attributes.
-
-The render thread drains the queue in `_poll_on_demand_requests()`, the same
-place it reads the mailbox:
-
-- An on-demand command goes to `_handle_on_demand_request()`, which is the
-  mailbox's own handler. The two paths share all of their code: activation,
-  the processed-id guard, error publishing, and resuming the rotation
-  afterwards.
-- `brightness.set` is applied there and then (`_apply_control_brightness`),
-  and the current frame is pushed again so the panel shows it.
-- `plugin.reload` starts at the top of the next loop pass, the place where
-  plugins are enabled and disabled live, because there no `display()` and no
-  Vegas iteration is on the stack (`_apply_pending_plugin_reloads`). Until
-  then the current screen ends early, as it does for a WiFi notice: the
-  frame loops, the dwell and Vegas's interrupt check all treat a pending
-  reload as a reason to stop (the frame loops through the Arbiter's
-  mid-screen check, `Source.RELOAD`; the dwell through
-  `_plugin_reload_pending`).
-- Only the quick half of the reload runs on the render thread
-  (`_start_plugin_reload`): the plugin's modes leave the rotation, its
-  config subscription is dropped, and `PluginManager.detach_plugin` takes
-  the instance out of `plugins`. After that nothing new calls the old
-  instance: no `update()`, and no Vegas fetch. The rotation then advances
-  (Vegas resumes its strip), and frames keep coming.
-- The slow half runs on a `plugin-reload-<id>` thread (`_PluginReloadJob`).
-  It waits for the plugin's lock, then tears the old instance down
-  (`unload_detached_plugin`) and loads the new one (`reload_plugin`). The
-  lock can be held for seconds by a Vegas render of the old instance. On
-  ledpi the render thread used to wait for it here, and a football reload
-  froze the panel for 3.0 s.
-- The new instance joins the rotation between two frames
-  (`_finish_plugin_reloads`, from `_service_pending_changes` or the top of
-  the loop). Its modes go back to their old places, Vegas is told to fetch
-  it again, and the command is answered.
-- While the plugin reloads, it is out of the rotation. Vegas scrolls what
-  its strip already holds of it. An on-demand request for it gets
-  `plugin-reloading`. A config reconcile neither loads it a second time nor
-  unloads it mid-load; a disable saved meanwhile is applied once the
-  reload is done. A second reload of the same plugin runs after the first.
-
-The floor on the mailbox read (0.25 s, 1 s since stage 4) does not apply to the queue, because
-draining it costs no disk read. A queued command also lets
-`_service_pending_changes()` skip its own floor.
-
-### Waking the render thread (stage 2)
-
-Stage 1 made the socket answer, but not land sooner: a queued command waited
-for the same polls the mailbox does. Measured on ledpi (Pi 4, 24 fps Vegas),
-a start took 1.02 s on a static screen and about 0.4 s in Vegas either way.
-Now the queue wakes the render thread:
-
-- **The waits.** The server sets a `threading.Event` whenever it queues a
-  command. The render thread waits on it (`ControlServer.wait_for_command`)
-  where it used to sleep: the static screen's 1 s frame sleep
-  (`_wait_frame_interval`) and the dwell's 0.25 s ticks
-  (`_sleep_with_plugin_updates`, which also covers scheduled-off and the
-  empty-rotation pause). On a wake it applies the command at once. A command
-  that does not end the screen, such as a brightness, does not cut the frame
-  short: the wait carries on to the end of the interval, so the plugin is
-  still drawn once a second.
-- **Vegas.** The coordinator still runs its interrupt check every 10 frames,
-  and now also at any frame where `urgent()` is true. The display passes
-  "a control socket command is queued", which is one `Event.is_set()` per
-  frame.
-- **Scrolling screens** already service pending changes every frame.
-
-So a command lands within a millisecond or so on a static screen and in a
-dwell, and within one frame in Vegas and on a scrolling screen. The mailbox
-is slower on purpose (see "The mailboxes now"). Commands still run only on the render thread: the
-connection threads only queue them and set the event. The one exception is
-the slow half of `plugin.reload` (tearing down and loading the plugin),
-which runs on its own thread. Every change to the display's state still
-happens on the render thread.
-
-The waits are timed `Event.wait()` calls: no polling, and no more wake-ups
-than the sleeps they replace when nothing arrives. Measured under WSL
-(Python 3.12, 20 s runs in the order before, after, after, before, with the
-socket's accept thread up), the idle process used 0.015–0.018% of a core
-before and 0.019–0.021% after on a static screen, and 0.035–0.037% before and
-0.047% after in a dwell: about 25 µs more per wait, from `Event.wait`'s own
-bookkeeping. A client's send to the render thread waking took 0.72 ms median
-(1.04 ms max), and a whole `brightness.set` round trip 0.64 ms median.
-
-Without a socket (Windows, `LEDMATRIX_CONTROL_SOCKET=off`) the waits are the
-plain sleeps they were.
-
-**Exactly once.** Since stage 4 the web interface writes the mailbox only
-when the display never had the request (see "When the web interface falls
-back"), so a request goes one way or the other, never both. A command and a
-mailbox write for the same request still share one `request_id`, and the
-`on_demand_request_id` and processed-id checks still drop a second copy: an
-older web interface (before stage 4) wrote the mailbox after a reply timed
-out, too. The display takes such a copy out of the mailbox when it drops it.
-
-## When the web interface falls back (stage 4)
-
-The client tells a request the display never had from one it had and then
-failed. `ControlError.sent` is True once the whole request was written to a
-connected display; a refusal the display sends before reading anything
-(`forbidden`, too many connections) carries no request id, and leaves it
-False. `src.ipc.client.should_fall_back()` is the one rule every route uses:
-
-| What happened | Example reasons | Mailbox? | The route answers |
-|---|---|---|---|
-| The display never had it | `no_socket`, `refused`, `disabled`, `unsupported`, a connect or send that timed out, `forbidden` / `busy` at the door, `invalid_request` (refused by the client itself) | yes | success, `transport: "mailbox"`, `socket_error` |
-| A display too old to know it (the upgrade case) | `unknown_command`, `unsupported_version` | yes | as above |
-| The display had it and failed | `busy` (queue full), `invalid_args`, `internal`, a timeout or hang-up after the send, `bad_response` | no | `503` (`400` for `invalid_args`), `socket_error` |
-
-A display that had the request may have applied it (a reply that timed out),
-or would refuse the mailbox copy as well (bad arguments), or is stuck and
-would not read the mailbox either (a full queue). Writing the copy anyway
-only turned that into a "success". An on-demand stop with `stop_service`
-still stops the service, which ends on-demand whatever happened.
-
-Brightness and plugin reload never had a mailbox: without the socket, the
-config watcher applies the saved brightness and a reload becomes the
-restart banner, as before.
-
-### The mailboxes now
-
-| Mailbox | Written by | Read by the display | While the socket is up |
-|---|---|---|---|
-| `display_on_demand_request` | the web interface, only on fallback; plugins that predate `BasePlugin.request_on_demand()`, or run on a core without it | the render thread, `_poll_on_demand_requests()` | looked at every 1 s (`MAILBOX_POLL_INTERVAL_WITH_SOCKET`), 0.25 s without a socket |
-| `plugin_error_clear_request` | the web interface, only on fallback | the error publisher's thread, every 5 s tick | unchanged rate |
-
-A look is one `stat()` of the mailbox file (`CacheManager.file_signature`):
-`(inode, mtime, size)`, and every write renames a new file into place, so a
-new write always looks different. `MailboxWatch` reads the file only when
-that changed since the last look, so a mailbox that holds nothing new, or
-nothing at all, costs no open and no parse. A socket command never reads or
-deletes the on-demand mailbox. A start already processed is taken out of
-the mailbox instead of being re-read until it expires.
-
-A request that comes through the on-demand mailbox while the socket is up
-is logged once per writer (`came through the file mailbox although the
-control socket is up`), which names the plugins that still write it.
-
-### Plugins in the display process
-
-A plugin asks for the screen with `BasePlugin.request_on_demand()` and gives
-it back with `end_on_demand()` (see "On-demand display" in
-[PLUGIN_API_REFERENCE.md](PLUGIN_API_REFERENCE.md)). Neither goes through
-the socket or a file: `PluginManager` hands the mailbox-shaped request,
-marked `source: 'plugin'`, to `DisplayController.submit_plugin_on_demand`,
-which queues it in memory (at most `PLUGIN_ON_DEMAND_QUEUE_SIZE`, 32) from
-whatever thread the plugin called on, and wakes the render thread through
-the socket's queue flag (`ControlServer.wake()`). The render thread applies
-it in `_drain_control_commands`, after the socket's commands, through the
-same `_handle_on_demand_request`, so it lands within a frame like a socket
-command. Without a socket it lands on the next pending-changes pass (typically
-within 0.25 s). A plugin's stop ends only a session that plugin owns. The four
-plugins that wrote the mailbox (birdnet-go, mqtt-notifications, on-air,
-pomodoro-timer) use it where the core has it and write the mailbox
-otherwise.
-
-## Robustness
-
-All of this runs inside the display process, so nothing a client does may
-block the render loop or crash it:
-
-- **Bounded connections.** Each connection gets its own daemon thread, with
-  at most 8 at once. One more is answered `busy` and closed.
-- **Timeouts.** Each read and write times out after 2 s. A message must
-  arrive whole within 5 s of its first byte. An idle connection is closed
-  after 10 s. A slow or stuck client costs one thread for a few seconds.
-- **Malformed input.** A line that is not JSON gets `bad_json`, and the
-  connection carries on. A line longer than 64 KiB gets `message_too_large`,
-  and the connection is closed, because the next message boundary cannot be
-  found. A client that disconnects mid-message is dropped silently. No
-  exception from a handler leaves the connection thread.
-- **Full queue.** When the queue is full, the client gets `busy`, and the web
-  interface answers `503` rather than write the mailbox, which the stuck
-  render thread would not read either. A full queue means the render thread
-  is stuck, and the systemd watchdog deals with that.
-- **Awaited commands.** The wait for an awaited command's outcome happens on
-  its connection thread and is bounded (`AWAIT_SECONDS`), so a stuck render
-  thread costs that client `pending` and one connection slot for at most
-  10 s. The render thread settles an outcome without blocking; one nobody is
-  waiting for any more is simply dropped.
-- **Startup.** The server binds under a temporary name, sets the mode and the
-  group, then renames the socket into place, so it never appears with the
-  umask's permissions. It removes a stale socket (a file that nothing is
-  listening on). It never removes a live socket or a file that is not a
-  socket. `close()` removes the socket only if it is still the one this
-  process created.
-- **Never fatal.** If the server cannot start (Windows, no `AF_UNIX`, a bind
-  failure, `LEDMATRIX_CONTROL_SOCKET=off`), it logs that and the display runs
-  as before. The web interface then uses the mailbox, and reads the cache
-  keys and the heartbeat file.
-- **Subscribers (stage 3).** A `state.subscribe` connection gives its request
-  slot back and takes one of 4 subscriber slots (`MAX_SUBSCRIBERS`). A fifth
-  gets `busy`. So a few browsers' web processes holding streams can never
-  use up the 8 slots that commands need. Each subscriber has its own thread.
-  A send that cannot finish within the 2 s IO timeout (a reader that stopped
-  reading) drops that subscriber. Nothing else waits for it, and the render
-  thread only publishes to the hub. `close()` wakes every subscriber, so
-  they end at once.
-
-## Security model
-
-The display runs as root and the web interface as the installing user (see
-[PERMISSIONS.md](PERMISSIONS.md)). The socket admits exactly those two, plus
-anything else in the group they share:
-
-1. **The directory.** `/run/ledmatrix` is created by `RuntimeDirectory=ledmatrix`
-   in `ledmatrix.service` (#687): root-owned, `0755`, on tmpfs, and removed
-   when the display stops. Under an older unit, the display creates the
-   directory itself as root, as it does for the heartbeat. No installer
-   change is needed.
-2. **The socket file.** The file is `root:<shared group>` with mode `0660`,
-   and the kernel refuses `connect()` to anyone without write permission on
-   it. The shared group is the cache directory's group whenever that
-   directory is group-writable. That is `ledmatrix` on an installed device
-   (`/var/cache/ledmatrix` is `root:ledmatrix 2775`), and it is the same rule
-   DiskCache uses for every file the two services share. Otherwise the group
-   is the project directory's (`get_shared_group_gid()`, which config files
-   use). With neither, the mode is `0600` and only root can connect.
-3. **Peer credentials.** Where the kernel reports them (`SO_PEERCRED`, on
-   Linux), the server checks every connection again. It accepts root, the
-   display's own user, or a member of the shared group: the peer's primary
-   gid, or a supplementary group read from `/proc/<pid>/status`. If `/proc`
-   is unreadable, it uses the group database. Any other peer gets `forbidden`
-   and is disconnected. This covers a socket mode that someone loosened by
-   hand.
-
-The commands are deliberately narrow. They start or stop on-demand display,
-read its state, set the brightness, and reload a plugin the display is
-already running, all of which anyone who can reach the web UI can already do
-(the last by restarting the display). Nothing on the socket runs a shell,
-writes a file, or names a path, and `plugin.reload` cannot make the display
-import a plugin it was not running. Stages 2 and 3 changed none of the
-access rules above. The state stream carries what the cache keys already
-held, and those are readable by the same group. A subscriber goes through
-the same connect-time and peer-credential checks as any other connection.
-
-**Development.** A display that is not root and cannot write to
-`/run/ledmatrix`, such as `python3 run.py -e` from a checkout, serves the
-socket at `$TMPDIR/ledmatrix-<uid>/control.sock`. That directory is private
-(`0700`), and the server refuses it if another user owns it. The web
-interface, run by the same user, looks there after `/run/ledmatrix`. The test
-suite sets `LEDMATRIX_CONTROL_SOCKET=off` (`test/conftest.py`), so a run on a
-device never touches the live display.
-
-## Stage plan
-
-1. **On-demand, with acks (done, #706).** Contract, server, client.
-   `on_demand.start`/`stop`/`status`, `hello`, `ping`. The REST routes try the
-   socket first and report `transport: "socket" | "mailbox"` (plus
-   `socket_error` on fallback). The mailbox is unchanged, and the plugins that
-   write it directly (birdnet-go, mqtt-notifications, on-air, pomodoro-timer)
-   keep working.
-2. **Commands that were restarts or polls (done).**
-   - The render thread waits on the queue instead of sleeping, and Vegas
-     checks it every frame, so a command lands within a frame on every kind
-     of screen (see "Waking the render thread").
-   - `brightness.set`, transient and with no `config.json` write. `POST
-     /api/v3/config/main` sends it after saving a brightness and reports
-     `brightness_transport`; without the socket the config watcher applies
-     the saved value, as before.
-   - `plugin.reload`, which replaces the `restart_required` answer from #688
-     for a store update of an enabled plugin. `POST /api/v3/plugins/update`
-     answers `restart_required: false, reloaded: true` once the new code
-     runs, and falls back to the restart banner (with `reload_error`)
-     otherwise.
-   - `config.reload` was left out. Its only gain over the config watcher
-     would be skipping the watcher's 2 s mtime poll, and the one setting
-     where those seconds show, brightness, now has its own command. Plugin
-     settings already reach the running plugin through the watcher, and the
-     "which sections changed" ack had no reader: the web interface knows
-     what it saved. A reload from the socket thread would also run every
-     config subscriber on a second thread beside the watcher's.
-3. **A state stream (done).** `state.get` (a versioned snapshot) and
-   `state.subscribe` (the snapshot, then pushed changes and keepalive ticks)
-   carry the current mode, the on-demand state (including the outcome of an
-   acked on-demand command), the brightness, the plugin runtime snapshot and
-   the render loop's liveness, all served from memory (see "The state
-   stream"). The web interface's readers use it and fall back to the cache
-   keys and the heartbeat file. `display_current_state` and
-   `plugin_runtime_snapshot` are written less often while it serves them.
-   The keys remain for one release.
-   - Left for later: the outcome of a `plugin.reload` that answered
-     `pending` is visible only as the plugin's new `loaded_version` in
-     `state.plugins`, not as an event of its own.
-   - Left for later: the SSE display stream reads the preview frame, not
-     state, so nothing relays the stream to the browser yet. A browser still
-     polls the REST routes, which now answer from memory.
-   - Left for later: the store's install of an already-enabled plugin, and
-     an uninstall that keeps its config, still answer `restart_required`.
-     They can now use a load/unload command and report the result the same
-     way the update route does.
-4. **The mailboxes become a fallback (done).**
-   - The web interface writes a mailbox only when the socket could not carry
-     the request (`should_fall_back`); a display that had it and failed is
-     answered as that (see "When the web interface falls back").
-   - `errors.clear` replaces `plugin_error_clear_request` as the way a clear
-     reaches the display.
-   - The display looks at the on-demand mailbox once a second while the
-     socket is up, reads either mailbox only when its file changed, and logs
-     who still writes the on-demand one (see "The mailboxes now").
-   - Not changed, deliberately: config saves (the schedule, the dim
-     schedule, plugin settings) still reach the display through
-     `config.json` and its watcher, which is the setting itself rather than
-     a message; see `config.reload` under stage 2. The preview viewer marker
-     (`/tmp/led_matrix_preview_viewer`) is a presence signal the display
-     already stats at most once a second. Plugin health and metrics resets
-     write the persisted record the display publishes and do not reach the
-     running display (their routes say so); they are not mailboxes.
-5. **Remove the mailboxes (next release).** Once every device has run a
-   display with stage 4, the web interface stops writing both mailboxes and
-   the display stops reading them. The four plugins that wrote
-   `display_on_demand_request` now have an in-process way to ask for the
-   screen (`BasePlugin.request_on_demand()` / `end_on_demand()`, see
-   "Plugins in the display process"); they keep the mailbox write only as
-   their fallback on older cores. The display also stops writing `display_current_state`,
-   `display_on_demand_state` and `plugin_runtime_snapshot` once the web
-   interface no longer falls back to them.
-
-## Checking it on a device
-
-```bash
-ls -l /run/ledmatrix/control.sock                 # srw-rw---- root ledmatrix
-sudo journalctl -u ledmatrix | grep "Control socket"
-curl -s -X POST localhost:5000/api/v3/display/on-demand/start \
-  -H 'Content-Type: application/json' -d '{"plugin_id":"clock","duration":20}'
-# ... "transport": "socket"
-```
-
-If the response says `"transport": "mailbox"`, `socket_error` gives the
-reason. `no_socket` means the display is stopped or predates the socket.
-`refused` usually means the web user is not in the socket's group, which
-takes effect when the web service restarts after the user is added. A `503`
-with `"transport": "socket"` means the display had the request and did not
-take it (`busy`, `timeout`, ...): nothing was written to the mailbox.
-
-An error clear:
-
-```bash
-curl -s -X POST localhost:5000/api/v3/errors/clear \
-  -H 'Content-Type: application/json' -d '{"all":true}'
-# ... "applied": true, "transport": "socket"
-sudo journalctl -u ledmatrix | grep -E "Cleared .* plugin error|file mailbox"
-```
-
-Brightness and a plugin reload:
-
-```bash
-curl -s -X POST localhost:5000/api/v3/config/main \
-  -H 'Content-Type: application/json' -d '{"brightness":40}'
-# ... "brightness_transport": "socket"
-curl -s -X POST localhost:5000/api/v3/plugins/update \
-  -H 'Content-Type: application/json' -d '{"plugin_id":"clock-simple"}'
-# after a real update of an enabled plugin: "restart_required": false, "reloaded": true
-sudo journalctl -u ledmatrix | grep -E "Brightness set|Reload(ing|ed) plugin"
-```
-
-`unknown_command` in `brightness_socket_error` or `reload_error` means the
-display runs a stage-1 build: restart it once to pick up this one.
-
-The state stream:
-
-```bash
-curl -s localhost:5000/api/v3/display/current-status    # ... "source": "socket"
-curl -s localhost:5000/api/v3/health | python3 -m json.tool | grep -A3 display_loop
-python3 - <<'EOF'
-from src.ipc import client          # run from the project directory
-snap = client.state_get()
-print(snap['version'], snap['epoch'], snap['loop'], snap['state']['display'])
-EOF
-```
-
-`"source": "cache"` means the web interface could not use the socket: the
-display is stopped, predates stage 3, or the web user is not in the
-socket's group.

docs/LOW_MEMORY_BOARDS.md

@@ -1,115 +0,0 @@
-# Running on Low-Memory Boards
-
-Applies to the Pi Zero 2 W (512 MB), Pi 3 / 3B+ (1 GB), and the 1 GB Pi 4.
-If your board has 2 GB or more you can skip this document.
-
-## The failure this prevents
-
-The display process is the largest thing on the board. On a 1 GB Pi 3B+ with
-around 20 plugins enabled it settles near **600 MB of 905 MB usable**, leaving
-under 200 MB of headroom for everything else.
-
-When that headroom runs out, the board does not crash cleanly. `fork()` starts
-failing, and because a new process is needed to do almost anything, the
-symptoms look nothing like "out of memory":
-
-| What you see | Why |
-|---|---|
-| SSH accepts the connection then closes it instantly, before any banner | `sshd` forks a session per connection; the fork fails |
-| The web UI still responds quickly | Already running, serves from existing threads, forks nothing |
-| Ping is perfect, 0% loss | Handled entirely in the kernel |
-| The panel is dark | The display process was killed and cannot be respawned |
-| The clock is wrong after the next boot | `fake-hwclock`'s periodic save is a scheduled job, and it cannot fork either |
-
-The board looks healthy from the outside and cannot be logged into. Only a
-power cycle clears it. If you are here because SSH stopped working, also see
-[SSH_UNAVAILABLE_AFTER_INSTALL.md](SSH_UNAVAILABLE_AFTER_INSTALL.md), which
-covers the more common cause (AP mode).
-
-## Check your headroom
-
-```bash
-free -m
-ps -eo rss,comm --sort=-rss | head -5
-```
-
-If `MemAvailable` is under ~150 MB while the display is running, you are close
-to the edge. To watch it over time:
-
-```bash
-watch -n 30 'free -m | head -2'
-```
-
-Available memory that falls steadily rather than holding flat means you will
-reach the wall; it is a question of when.
-
-## What to do
-
-**1. Enable the memory cgroup controller.** Without it, the `MemoryMax=85%` in
-`systemd/ledmatrix.service` is accepted by systemd and silently ignored, so the
-service has no ceiling and a runaway takes the whole board down instead of just
-restarting. Raspberry Pi firmware disables this controller by default.
-
-`first_time_install.sh` does this for you. To check it took effect:
-
-```bash
-grep memory /sys/fs/cgroup/cgroup.controllers
-```
-
-If that prints nothing, add `cgroup_enable=memory cgroup_memory=1` to the
-kernel command line and reboot. Edit whichever file your image uses —
-`/boot/firmware/cmdline.txt` on current Raspberry Pi OS, `/boot/cmdline.txt` on
-older layouts (the installer checks the first and falls back to the second).
-Everything must stay on a single line.
-
-This changes the failure mode from "the board becomes unreachable" to "the
-display service restarts". It is a safety net, not a fix.
-
-**2. Run fewer plugins.** This is the actual remedy. Every enabled plugin costs
-memory permanently — its module, its parsed config, and its cached API
-responses. On a 512 MB or 1 GB board, keep the enabled set small and prefer
-plugins that poll infrequently.
-
-**3. Lower the cache ceiling.** The in-memory cache is sized from total RAM
-(150 entries at 1 GB and below, up to 1500 at 8 GB). To go lower still:
-
-```ini
-# /etc/systemd/system/ledmatrix.service.d/override.conf
-[Service]
-Environment=LEDMATRIX_CACHE_MAX_ENTRIES=75
-```
-
-Writing the file does not change the running service. Reload systemd and
-restart it:
-
-```bash
-sudo systemctl daemon-reload
-sudo systemctl restart ledmatrix
-```
-
-Fewer entries means more API calls, so lower this only while you are actually
-short of memory.
-
-**4. Consider `MemoryHigh`.** `MemoryMax` kills and restarts. `MemoryHigh`
-throttles and reclaims instead, which is gentler — but on a board where the
-process genuinely wants more than the limit, sustained reclaim can stall the
-render loop and show as visible stutter on the panel. Add it only if you prefer
-degraded output to a restart:
-
-```ini
-[Service]
-MemoryHigh=70%
-```
-
-## Keep your logs
-
-These images default to volatile journald storage, so every reboot destroys the
-logs — including the ones explaining why the board rebooted. `first_time_install.sh`
-enables persistent storage capped at 64 MB. To confirm:
-
-```bash
-journalctl --list-boots
-```
-
-More than one boot listed means logs are surviving reboots. If only one is
-listed, journald is still writing to `/run` (tmpfs).

docs/MIGRATION_GUIDE.md

@@ -19,6 +19,7 @@ All installation scripts have been moved from the project root to `scripts/insta
 | `install_wifi_monitor.sh` | `scripts/install/install_wifi_monitor.sh` |
 | `setup_cache.sh` | `scripts/install/setup_cache.sh` |
 | `configure_web_sudo.sh` | `scripts/install/configure_web_sudo.sh` |
+| `migrate_config.sh` | `scripts/install/migrate_config.sh` |
 
 #### Permission Fix Scripts
 
@@ -58,12 +59,9 @@ sudo ./scripts/install/install_service.sh
 After updating your scripts, verify they still work:
 
 ```bash
-# Check the installation scripts are at their new paths
+# Test installation scripts (if needed)
 ls scripts/install/*.sh
-./scripts/install/install_service.sh --help   # prints usage only
-# Note: running install_service.sh for real (with sudo, no --help)
-# reinstalls, enables and restarts ledmatrix.service, ledmatrix-web.service
-# and the update-verify units.
+sudo ./scripts/install/install_service.sh --help
 
 # Test permission scripts
 ls scripts/fix_perms/*.sh
@@ -88,7 +86,7 @@ The plugin system has been enhanced but remains backward compatible with existin
 
 If you encounter issues during migration:
 
-1. Check the [project root README](../README.md) for current installation and usage instructions
+1. Check the [README.md](README.md) for current installation and usage instructions
 2. Review script README files:
    - [`scripts/install/README.md`](../scripts/install/README.md) - Installation scripts documentation
    - [`scripts/fix_perms/README.md`](../scripts/fix_perms/README.md) - Permission scripts documentation

docs/MULTI_ROOT_WORKSPACE_SETUP.md

@@ -1,149 +1,169 @@
 # Multi-Root Workspace Setup Guide
 
-This document explains how to work on LEDMatrix and the official plugins side
-by side, with one editor workspace and the plugins loaded straight from your
-plugin checkout.
+This document explains how the LEDMatrix project uses a multi-root workspace to manage plugins as separate Git repositories.
 
 ## Overview
 
-Official plugins live in a single repository,
-[ledmatrix-plugins](https://github.com/ChuckBuilds/ledmatrix-plugins), with one
-directory per plugin under `plugins/`. There are no separate per-plugin
-repositories. For development you clone that monorepo **next to** LEDMatrix
-and symlink the plugin directories you are working on into LEDMatrix's
-`plugins/` directory with `scripts/dev/dev_plugin_setup.sh`.
+The LEDMatrix project has been migrated from a git submodule implementation to a **multi-root workspace** implementation for managing plugins. This allows:
 
-- ✅ Plugin code stays in the monorepo checkout, with its own git history
-- ✅ LEDMatrix discovers the plugins through symlinks in `plugins/`
-  (git-ignored), so the production `plugin-repos/` directory is untouched
-- ✅ `LEDMatrix.code-workspace` opens both repositories in VS Code/Cursor
+- ✅ Plugins to exist as independent Git repositories
+- ✅ Updates to plugins without modifying the LEDMatrix project
+- ✅ Easy development workflow with all repos in one workspace
+- ✅ Plugin system discovers plugins via symlinks in `plugin-repos/`
 
 ## Directory Structure
 
 ```text
-~/Github/
-├── LEDMatrix/                        # Main project
-│   ├── plugins/                      # Dev plugin directory (git-ignored)
-│   │   ├── clock-simple -> ~/Github/ledmatrix-plugins/plugins/clock-simple
-│   │   ├── ledmatrix-weather -> ~/Github/ledmatrix-plugins/plugins/ledmatrix-weather
+/home/chuck/Github/
+├── LEDMatrix/                    # Main project
+│   ├── plugin-repos/             # Symlinks to actual repos (managed automatically)
+│   │   ├── ledmatrix-clock-simple -> ../../ledmatrix-clock-simple
+│   │   ├── ledmatrix-weather -> ../../ledmatrix-weather
 │   │   └── ...
-│   ├── plugin-repos/                 # Default (Plugin Store) plugin directory
-│   ├── LEDMatrix.code-workspace      # Opens LEDMatrix and ../ledmatrix-plugins
+│   ├── LEDMatrix.code-workspace  # Multi-root workspace configuration
 │   └── ...
-└── ledmatrix-plugins/                # Plugin monorepo (git repo)
-    ├── plugins/
-    │   ├── clock-simple/
-    │   ├── ledmatrix-weather/
-    │   └── ...
-    ├── plugins.json                  # Store registry
-    └── update_registry.py
+├── ledmatrix-clock-simple/       # Plugin repository (actual git repo)
+├── ledmatrix-weather/            # Plugin repository (actual git repo)
+├── ledmatrix-football-scoreboard/ # Plugin repository (actual git repo)
+└── ...                           # Other plugin repos
 ```
 
 ## How It Works
 
-### 1. The plugin monorepo
+### 1. Plugin Repositories
 
-Clone ledmatrix-plugins into the same parent directory as LEDMatrix (the
-workspace file looks for `../ledmatrix-plugins` relative to the LEDMatrix
-root):
+All plugin repositories are cloned to `/home/chuck/Github/` (parent directory of LEDMatrix) as regular Git repositories:
+
+- `ledmatrix-clock-simple/`
+- `ledmatrix-weather/`
+- `ledmatrix-football-scoreboard/`
+- etc.
+
+### 2. Symlinks in plugin-repos/
+
+The `LEDMatrix/plugin-repos/` directory contains symlinks pointing to the actual repositories in the parent directory. This allows the plugin system to discover plugins without modifying the project structure.
+
+### 3. Multi-Root Workspace
+
+The `LEDMatrix.code-workspace` file configures VS Code/Cursor to open all plugin repositories as separate workspace roots, allowing easy development across all repos.
+
+## Setup Scripts
+
+### Initial Setup
+
+If you already have plugin repositories cloned, use the setup script:
 
 ```bash
-cd ~/Github
-git clone https://github.com/ChuckBuilds/ledmatrix-plugins.git
+cd /home/chuck/Github/LEDMatrix
+python3 scripts/setup_plugin_repos.py
 ```
 
-### 2. Symlinks in plugins/
-
-`scripts/dev/dev_plugin_setup.sh link <name> <path>` creates
-`LEDMatrix/plugins/<name>` as a symlink to a plugin directory. Use the
-plugin's manifest `id` as the name: that is the name the loader and
-`config.json` use, and the script warns when the two differ.
-
-### 3. Multi-root workspace
-
-`LEDMatrix.code-workspace` has two roots: LEDMatrix itself and
-`../ledmatrix-plugins`.
-
-## Setup
-
-### Link plugins
-
-```bash
-cd ~/Github/LEDMatrix
-./scripts/dev/dev_plugin_setup.sh link clock-simple ../ledmatrix-plugins/plugins/clock-simple
-./scripts/dev/dev_plugin_setup.sh list      # show what is linked
-```
-
-If a real (non-symlink) directory of the same name already exists in
-`plugins/`, the script offers to back it up and replace it.
-
-Without a sibling checkout, `./scripts/dev/dev_plugin_setup.sh link-github
-<name>` clones the monorepo into `~/.ledmatrix-dev-plugins/` instead and links
-the plugin from there. See the
-[Plugin Development Guide](PLUGIN_DEVELOPMENT_GUIDE.md).
+This script:
+- Reads the workspace configuration
+- Creates symlinks in `plugin-repos/` pointing to actual repos
+- Verifies all links are created correctly
 
 ### Updating Plugins
 
+To update all plugin repositories:
+
 ```bash
-cd ~/Github/LEDMatrix
-git -C ../ledmatrix-plugins pull            # the sibling monorepo checkout
-# or
-./scripts/dev/dev_plugin_setup.sh update    # git pull in every linked checkout
+cd /home/chuck/Github/LEDMatrix
+python3 scripts/update_plugin_repos.py
 ```
 
-The symlinks pick up the new code; restart the display to load it.
+This script:
+- Finds all plugins in the workspace
+- Runs `git pull` on each repository
+- Reports which plugins were updated
 
 ## Configuration
 
-The loader scans only `plugin_system.plugins_directory` in
-`config/config.json` (default `plugin-repos`). Point it at `plugins` so it
-finds the links:
+The plugin system is configured in `config/config.json`:
 
 ```json
 {
   "plugin_system": {
-    "plugins_directory": "plugins"
+    "plugins_directory": "plugin-repos",
+    "auto_discover": true,
+    "auto_load_enabled": true
   }
 }
 ```
 
+The `plugins_directory` points to `plugin-repos/`, which contains symlinks to the actual repositories.
+
 ## Workflow
 
 ### Daily Development
 
 1. **Open Workspace**: Open `LEDMatrix.code-workspace` in VS Code/Cursor
-2. **Edit Plugins**: Edit code under `ledmatrix-plugins/plugins/<plugin>/`
-3. **Test**: `python3 run.py -e` (emulator) or
-   `python3 scripts/check_plugin.py --plugin <id>` from LEDMatrix
-4. **Ship**: Bump `version` in the plugin's `manifest.json`, run
-   `python update_registry.py` in ledmatrix-plugins, commit there
+2. **All Repos Available**: All plugin repos appear as separate folders in the workspace
+3. **Edit Plugins**: Edit plugin code directly in their repositories
+4. **Update Plugins**: Run `update_plugin_repos.py` to pull latest changes
 
 ### Adding New Plugins
 
-1. Create `plugins/<your-plugin-id>/` in the monorepo checkout
-2. Link it: `./scripts/dev/dev_plugin_setup.sh link <your-plugin-id> ../ledmatrix-plugins/plugins/<your-plugin-id>`
+1. **Clone Repository**: Clone the new plugin repo to `/home/chuck/Github/`
+2. **Add to Workspace**: Add the plugin folder to `LEDMatrix.code-workspace`
+3. **Create Symlink**: Run `setup_plugin_repos.py` to create the symlink
+
+### Updating Individual Plugins
+
+Since plugins are regular Git repositories, you can update them individually:
+
+```bash
+cd /home/chuck/Github/ledmatrix-weather
+git pull origin master
+```
+
+Or update all at once:
+
+```bash
+cd /home/chuck/Github/LEDMatrix
+python3 scripts/update_plugin_repos.py
+```
+
+## Benefits
+
+1. **No Submodule Hassle**: No need to update `.gitmodules` or run `git submodule update`
+2. **Independent Updates**: Update plugins independently without touching LEDMatrix
+3. **Clean Separation**: Each plugin is a separate repository with its own history
+4. **Easy Development**: Multi-root workspace makes it easy to work across repos
+5. **Automatic Discovery**: Plugin system automatically discovers plugins via symlinks
 
 ## Troubleshooting
 
-### Plugins not discovered
+### Symlinks Not Working
+
+If plugins aren't being discovered:
 
 ```bash
-cd ~/Github/LEDMatrix
-ls -la plugins/                           # links present and not broken?
-./scripts/dev/dev_plugin_setup.sh status  # link targets and git state
+cd /home/chuck/Github/LEDMatrix
+python3 scripts/setup_plugin_repos.py
 ```
 
-Also check that `plugin_system.plugins_directory` is `plugins`.
+This will recreate all symlinks.
 
-### Plugin updates not showing
+### Missing Plugins
 
-1. Verify the link target: `ls -la plugins/<id>`
-2. Check that you're editing the monorepo checkout, not a store-installed copy
-3. Restart the LEDMatrix service (or `run.py`)
+If a plugin is in the workspace but not found:
+
+1. Check if the repo exists in `/home/chuck/Github/`
+2. Check if the symlink exists in `plugin-repos/`
+3. Run `setup_plugin_repos.py` to recreate symlinks
+
+### Plugin Updates Not Showing
+
+If changes to plugins aren't appearing:
+
+1. Verify the symlink points to the correct directory: `ls -la plugin-repos/ledmatrix-weather`
+2. Check that you're editing in the actual repo, not a copy
+3. Restart the LEDMatrix service if running
 
 ## Notes
 
-- `plugins/` is git-ignored (except `plugins/.gitkeep`); the symlinks are
-  never committed.
-- When changing a plugin in the monorepo, bump its manifest `version` and run
-  `python update_registry.py`, or users won't receive the update.
+- The `plugin-repos/` directory is tracked in git, but only contains symlinks
+- Actual plugin code lives in `/home/chuck/Github/ledmatrix-*/`
+- Each plugin repo can be updated independently via `git pull`
+- The LEDMatrix project doesn't need to be updated when plugins change

docs/OFFSCREEN_RENDERING.md

@@ -1,354 +0,0 @@
-# Offscreen Rendering
-
-**Status (2026-09-30):** offscreen rendering is implemented
-(`DisplayManager.offscreen()`, the adapter on the prefetch thread, the plugin
-lock), and so are live elements, which grew out of steps 2 and 3 below: see
-*Live elements*. The segment strip proposed as step 2 was not needed; *Why not
-a SegmentStrip* says why.
-
-First soak of step 1 on hdpi (50 px/s, `pwm_bits` 7, preview open, 8-minute
-runs, A/B/B/A):
-
-| build | late | by 1 | 2 | 3–5 | 6+ | freezes | render-thread fetches |
-|---|---|---|---|---|---|---|---|
-| #628 | 0.53% | 82 | 2 | 3 | 2 | 3 | 6 |
-| step 1 | 0.63% | 78 | 63 | 17 | 2 | 1 | 0 |
-| step 1 | 0.42% | 77 | 23 | 10 | 0 | 0 | 0 |
-| #628 | 0.37% | 84 | 5 | 3 | 3 | 2 | 14 |
-
-It does what it was built to: no plugin is fetched on the render thread, and
-freezes fell from 5 to 1. But frames 2–5 refreshes late rose. The rendering
-moved to the prefetch thread still needs the GIL, and the render thread waits
-for it (risk 5 below). The late rate did not improve overall. The 1–2 s
-freezes appear in both builds and have a separate, not yet identified cause.
-
-The GIL fix, measured on hdpi (90 px/s, `pwm_bits` 8, preview open, 8-minute
-runs after a 2-minute warm-up, order A B C C B A, 2026-09-24). Each arm pools
-two runs, about 81,000 frames:
-
-| arm | late | by 1 | 2 | 3–5 | 6+ | 2+ late per 10k frames | freezes |
-|---|---|---|---|---|---|---|---|
-| A: step 1 as is | 0.90% | 575 | 64 | 91 | 9 | 20.1 | 0 |
-| B: `switch_interval_ms` 1 | 0.78% | 510 | 105 | 23 | 2 | 15.8 | 0 |
-| C: `prefetch_gate` | **0.60%** | 471 | 11 | 7 | 2 | **2.5** | 0 |
-
-The gate removes the frames the render thread spent waiting for the GIL, and
-it costs the prefetch nothing that shows: it parked the thread for 3–6 s per
-run, and the next group was ready at every strip extension in every arm.
-`prefetch_gate` is therefore on by default; `switch_interval_ms` stays an
-off-by-default experiment. What is left is almost all one refresh late, which
-is the per-frame budget (a 6.75 ms p50 blit in a refresh the panel holds at
-83–85 Hz while rendering), not contention.
-
-The runs restart the service, so the hourly sports refresh never fell inside
-one. That refresh is its own case: about twenty ESPN chunk-fetch threads at
-once, which the gate does not cover (it gates only the prefetch thread).
-
-## The problem
-
-Vegas mode builds its ticker from every plugin's content. Most of that work
-already happens on a background prefetch thread
-(`RenderPipeline.start_prefetch`). But any plugin whose content needs the
-**shared display canvas** is deferred to the render thread
-(`RenderPipeline.drain_deferred`), one plugin every two seconds. The code's
-own comments put each of those at 40–600 ms, and the render thread presents no
-frames while one runs.
-
-On hdpi (Pi 4, 512×64) most plugins take that path: geochron, tide-display,
-news, hockey-scoreboard, ledmatrix-stocks, incoming-packages, clock-simple,
-countdown, birdnet-go, ledmatrix-music and odds-ticker. They arrive in bursts
-("Whole group deferred; strip will extend as it drains") every minute or so,
-12 fetches in five minutes. That is the "occasional pause" a viewer sees.
-
-An 8-minute soak (`scripts/frame_soak.py --preview`) of the #628 build on
-hdpi:
-
-| late by | frames |
-|---|---|
-| 1 refresh | 238 |
-| 2 | 32 |
-| 3–5 | 30 |
-| 6+ | 5 |
-| freezes ≥ 250 ms | 2 (0.97 s total) |
-
-The 3+ rows and the freezes are the pauses. The single-refresh row is a
-separate problem: the blit is 6 ms of a 10 ms refresh, so there is little
-slack. It is covered under *What this does not fix*.
-
-## Why a plugin is canvas-bound
-
-The plugin-facing canvas is a set of shared attributes on `DisplayManager`:
-`image`, `draw`, `matrix`, and the `width`/`height` properties that read from
-`matrix`. Three adapter paths (`src/vegas_mode/plugin_adapter.py`) need them,
-and each returns `None` under `offscreen_only=True` so the plugin is queued for
-the render thread:
-
-1. **Display capture** (`_capture_display_content`): clear the canvas, call
-   `plugin.display()`, copy `display_manager.image`. Used by any plugin
-   without `get_vegas_content()` or a populated `scroll_helper`.
-2. **Scroll-content generation** (`_trigger_scroll_content_generation`): a
-   ticker plugin whose `scroll_helper.cached_image` is empty is made to build
-   it by calling `display(force_clear=True)` or `_create_scrolling_display()`.
-   Both draw on the canvas.
-3. **Narrowed rendering** (`DisplayManager.render_size`): swaps the shared
-   `matrix`, `image` and `draw` for a narrower set so the plugin lays out for
-   `render_width_pct`. The render thread would see the swap mid-frame.
-
-The render thread keeps the canvas coherent only because nothing else touches
-it at the same time. A background thread can't use it.
-
-## The design: a per-thread render target
-
-`capture_mode()` is already per-thread (#423 made its state a
-`threading.local`, so a background capture no longer suppresses the render
-loop's pushes). The same move applies to the canvas itself:
-
-```python
-with display_manager.offscreen(width=None, height=None) as surface:
-    plugin.display(force_clear=True)
-    content = surface.image.copy()
-```
-
-For the **calling thread only**, inside the block:
-
-| accessor | resolves to |
-|---|---|
-| `display_manager.image`, `.draw` | the surface's own image and draw: a fresh black canvas, `fontmode = "1"` |
-| `display_manager.matrix` | a logical proxy reporting the surface size, so `width`/`height` and plugins that read `matrix.width` follow it. Hardware calls through it (`SetImage`, `SwapOnVSync`, `Clear`, brightness writes) are inert. |
-| `update_display()`, `clear()` | canvas-only: the block implies capture mode, which is already per-thread |
-| `set_scrolling_state()`, `set_frame_hold()` | no-ops, so a plugin's `display()` cannot re-pace the live scroll. Today it can, when it is captured on the render thread. |
-
-Every other thread sees the real canvas, unchanged. The render loop in
-particular keeps presenting while a plugin draws elsewhere.
-
-### Implementation sketch
-
-- `image`, `draw` and `matrix` become properties over `_image`, `_draw` and
-  `_matrix`, plus a thread-local current surface. The getter returns the
-  surface's value when the calling thread has one, else the shared one; setters
-  mirror that. That costs about 0.1 µs per access, and `update_display()` reads
-  each a handful of times per frame. Every existing `self.image = ...` in
-  `DisplayManager` (`clear()`, setup, fallback) keeps working and becomes
-  thread-correct for free.
-- `render_size()` is rebuilt on `offscreen()`: it creates or narrows the
-  calling thread's surface instead of swapping shared state.
-- `offscreen()` nests and always restores on exit, including when the plugin
-  raises.
-- `VisualDisplayManager` (the plugin test harness) gets the same method, for
-  parity.
-
-### Adapter changes
-
-- `get_content(offscreen_only=True)` stops returning `None` for the three
-  paths above. Each runs inside `display_manager.offscreen(render_width)`.
-- `_capture_display_content` and `_trigger_scroll_content_generation` drop
-  their "copy the shared image, restore it afterwards" bookkeeping, since the
-  shared image is never touched.
-- **Take the plugin's lock.** `PluginManager.get_plugin_lock()` keeps
-  `update()` and `display()` mutually exclusive in normal rotation, but Vegas
-  never takes it, so today's render-thread captures already race
-  `update()`. Off the render thread the adapter can afford to wait: blocking
-  acquire with a timeout (proposed 2 s). On timeout it keeps the cached segment
-  and tries again next group.
-- `drain_deferred()` and the deferred queue are deleted. The only render-thread
-  fetch left is the inline fallback when no prepared group is ready, which in
-  practice is the first extension. Prefetching at start removes that too.
-
-## Live elements: content that changes while it scrolls
-
-Offscreen rendering is also what makes fresh content possible. A plugin's
-segment is drawn when its group is prefetched, and the strip carries
-7,000-10,000 px of content ahead of the viewport, so at ~100 px/s a score drawn
-then reaches the screen 70-100 seconds later -- and once in the strip it never
-changed: when a plugin reported new data, Vegas only dropped its caches, so the
-change appeared on the plugin's *next* turn, minutes later.
-
-A plugin can now hand Vegas **live elements** instead of pictures
-(`BasePlugin.get_vegas_elements()`, see "Live Vegas elements" in
-[PLUGIN_API_REFERENCE.md](PLUGIN_API_REFERENCE.md#live-vegas-elements)):
-named, fixed-width pieces of content -- one per game card, one for a map. Vegas
-records where each lands in the strip and, when the plugin's data changes,
-redraws just the changed ones off the render thread and copies their pixels
-over the old ones between two frames. A card already crossing the panel
-changes; nothing next to it moves.
-
-### Why not redraw every frame
-
-On a Pi the render thread has about 4 ms of slack per refresh at 512x64 after
-the ~6 ms blit, and a scoreboard card is ~29 ms of Pillow work that holds the
-GIL. Drawing on the render thread is out of the question at any rate, so the
-render thread only ever *copies* pixels that are already drawn. Measured on a
-Pi 4 (ledpi): writing a 35 KB card into a 20,000 px strip takes 8.5 µs, a
-101 KB map 17 µs, four cards (the per-frame cap) 34 µs -- against 124 µs for
-the viewport slice every frame already does.
-
-### How an update reaches the screen
-
-1. A plugin's `update()` completes. The update worker calls
-   `PluginManager._note_update_completed`, which calls the update listeners
-   (`add_update_listener`) there and then, with the plugin's lock still held.
-   Vegas's listener moves the plugin's **epoch** on
-   (`src/vegas_mode/elements.py`, `LiveEpochs`) and wakes the live worker.
-2. The **live worker** (`src/vegas_mode/live_worker.py`), the one background
-   thread that draws for the strip once it holds a live element, finds the
-   plugin's elements whose recorded epoch is older than its current one,
-   nearest the screen first, and calls `get_vegas_elements()` under the
-   plugin's lock (0.25 s wait, then a 1 s backoff). Elements whose `version`
-   is unchanged cost nothing; the rest are pinned and checksummed, and each
-   whose pixels changed becomes a patch in a one-per-element slot (the latest
-   wins).
-3. Between two frames the render thread
-   (`RenderPipeline.apply_live_patches`, from `coordinator.run_frame`) pops at
-   most four patches or two screens of bytes and copies each into the strip
-   with `ScrollHelper.patch_columns`. It takes no lock and draws nothing. A
-   patch made for an older strip, for an element trimmed away or already
-   behind the screen, or from older data than the strip shows, is dropped.
-
-End to end, a new score reaches a card already on screen within one poll of
-the data source (30 s for live games) plus about a second: the listener is
-immediate, and while live elements exist the update tick that schedules
-plugins runs every second instead of every four.
-
-Elements that change with **time** rather than data (an aircraft moving
-between position reports) ask for `refresh_hz`; the worker calls
-`redraw_vegas_element()` -- without the plugin's lock, from state the plugin
-publishes in one assignment -- that often while the element is on or within
-`live_lead_screens` of the screen, capped by `live_max_hz` (5), at 1 Hz
-without the render gate, and halved for an element whose redraws average over
-50 ms.
-
-### Geometry
-
-A live element is never trimmed to its ink: the adapter pads it with
-`content_padding` black columns either side and pins its width, and a redraw
-at any other width is refused (it shows the next time the plugin comes round).
-Records keep **absolute** strip columns -- the strip column plus everything
-trimmed off the front since the strip was composed -- so a trim moves one
-origin rather than every record. Nothing on screen is ever moved, inserted or
-resized; a game added to a slate appears on the plugin's next turn.
-
-### Why not a SegmentStrip
-
-The proposal here was to replace the single strip with a list of segments.
-In-place patching of the single strip meets every goal without that: the
-patch is O(element) and the strip layout never changes. What a segment list
-would still buy is cheaper extensions, and most of that came from making the
-strip's PIL copy lazy instead (`ScrollHelper.cached_image`: an extension used
-to rebuild it twice, 1.7-3.8 ms each on a Pi 4). The `extend` row of
-`frame_soak.py`'s "after work" table says whether the rest is worth it.
-
-### When it is off
-
-- `display.vegas_scroll.live_refresh: false` (the kill switch; also in the
-  web UI), or `vegas_live: false` in one plugin's section.
-- Always under multi-display sync: the follower mirrors whole strips only, so
-  a patch would never reach it. (Continuous-mode sync has a separate problem:
-  the follower is not sent extensions or trims at all.)
-- In swap mode (`continuous_scroll: false`) and with `offscreen_prefetch:
-  false`.
-- For plugins without the hook, which are drawn and placed exactly as before,
-  and on the paths that fetch without the plugin's lock (the first strip of a
-  run, the render thread's fallback fetch), which use `get_vegas_content()`.
-
-## Risks, and what was checked
-
-1. **Plugins holding their own reference to the shared `draw` or `image`.**
-   They would keep drawing into the shared canvas, and routing by thread can't
-   redirect them. A grep of the 49 plugins installed on hdpi found none storing
-   `display_manager.draw` or `.image` in an attribute (a pattern search, so
-   indirect aliasing would slip past it). A plugin that did would
-   draw into an image nobody displays, which trims to a blank segment. That is
-   not corruption, and it is no worse than today.
-2. **Plugins calling the matrix directly.** None in the audit. Inside
-   `offscreen()` the proxy makes it inert anyway.
-3. **Font thread-safety.** `FontManager` shares font objects across plugins.
-   Measured on Pillow 12.3, two threads rendering text take 1.94× as long as
-   one, so text rendering holds the GIL and FreeType is never entered
-   concurrently. Re-check if Pillow changes that.
-4. **Plugin thread-safety.** `display()` moves to the prefetch thread. The
-   plugin lock makes it exclusive with `update()`, which is more protection
-   than it has today. Threads a plugin starts itself are not covered, as today.
-5. **The GIL.** Moving 40–600 ms of plugin rendering off the render thread
-   removes the pauses, but the work still needs the GIL. Pillow drawing holds
-   it, and a waiting thread only gets it back after the switch interval
-   (default 5 ms). Expect some single-refresh late frames while a prefetch
-   runs. Measure with the soak. A render process separate from plugin work
-   is the structural answer (the "native presenter" step). Two experiments
-   get most of the way first (results under Status, above):
-   - `vegas_scroll.switch_interval_ms` lowers the switch interval for a Vegas
-     run (1 ms is the obvious try), so the render thread waits at most that
-     long behind bytecode. It does nothing for a C call that keeps the GIL.
-   - `vegas_scroll.prefetch_gate` (`src/common/render_gate.py`) lets the
-     prefetch thread run Python only while the render thread is blocked in
-     `SwapOnVSync`, up to just before the refresh the swap returns on, and
-     parks it the rest of the time. That covers C calls too, since the gate is
-     checked before each one starts. It never parks the thread while it holds
-     a lock the render thread takes, and never for more than 50 ms. It needs
-     the rebuilt binding, which releases the GIL during the swap. On by
-     default.
-
-## What this does not fix
-
-- **The blit.** Copying a 512×64 frame into the matrix (`SetImage`) is ~6 ms at
-  8 PWM bits on a Pi 4, leaving ~4 ms of slack per refresh. That is the main
-  source of the single-refresh late frames. Holding frames for two refreshes
-  (≈50 px/s) doubles the budget. Cutting the blit itself is the native-presenter
-  step.
-- **Multi-display sync in continuous mode.** The follower is sent the whole
-  strip only at a new cycle and on connect, never the extensions and trims of
-  continuous mode, so it drifts from the leader after the first extension.
-  Live elements stay off under sync for that reason.
-
-## Test plan
-
-- **Unit, `DisplayManager`:** one thread inside `offscreen()` draws while
-  another reads `image`/`draw`/`matrix`/`width`/`height` and sees the real
-  canvas. Also: `update_display()` and `set_scrolling_state()` are inert inside;
-  `render_size()` narrows only the calling thread; nesting and exceptions
-  restore state.
-- **Unit, adapter:** a stub display-capture plugin and a stub scroll-helper
-  plugin both return content with `offscreen_only=True`, and nothing is queued
-  for the render thread. The plugin lock is taken, and a timeout keeps the cached
-  segment.
-- **Emulator integration:** a stub canvas-bound plugin whose `display()` sleeps
-  300 ms. The Vegas render loop never goes a frame without presenting (frame
-  timing recorder: zero freezes).
-- **Live elements** (`test/test_vegas_live_*.py`,
-  `test/test_vegas_elements_*.py`, `test/test_scroll_helper_patch.py`): every
-  record points at exactly its element's pixels through any sequence of
-  compose, extend and trim; a patch changes only its element's columns (a
-  property test against a twin strip that is never patched); the render
-  thread's apply takes no lock and draws nothing; the worker's priorities,
-  floors, backoff and hand-over; and, end to end on the emulator with the stub
-  plugin (`test/fixtures/plugins/vegas-live-stub`), an update changes a card
-  already in the strip and an animated element moves with no update at all.
-- **Hardware:** an hdpi soak, A/B against the #628 build, alternating order.
-  Targets: no freezes, an empty 6+ bucket, the 3–5 bucket near zero, and the late
-  rate below 0.66%. Plus, for freshness: log each segment's age when it enters
-  the viewport, and compare the median and max before and after.
-
-## Rollout
-
-1. **Offscreen rendering** (shipped): `offscreen()`, the adapter on the
-   prefetch thread, and the plugin lock. Removed the render-thread pauses.
-2. **Measurement and the lazy strip image:** late frames attributed to the
-   render-thread work before them (`FrameTimingRecorder.note_op`, the "after
-   work" table), and extensions no longer rebuilding the strip's PIL copy.
-3. **Live elements:** the plugin API, the records, the worker and in-place
-   patches, with the sports scoreboards and the flight map adopting it.
-4. **Live games in the ticker by default:** `live_in_ticker` true, so a live
-   game's cards update in the marquee instead of the full-screen scoreboard
-   replacing it; existing configs are switched once (`ConfigManager`).
-
-`display.vegas_scroll.offscreen_prefetch` (default `true`) restores the
-deferred path when `false`, and `display.vegas_scroll.live_refresh` (default
-`true`) turns live elements off. Keep both for one release, then delete the
-old paths.
-
-## Open questions
-
-1. Multi-display sync: is there a two-Pi rig to test on? Replaying strip
-   operations to the follower (append, trim, patch, in absolute columns) would
-   fix continuous-mode sync and let live elements run under it.
-2. Is the `extend` cost worth a segment list after the lazy image? The soak's
-   "after work" table answers it per rig.