Strip plugin-baked scroll padding when capturing content for Vegas mode

Plugins that build their own ticker image via ScrollHelper.create_scrolling_image()
(or that manually pad both ends for a clean standalone loop) carry a solid-black
margin up to display_width wide on one or both edges. Vegas mode already adds its
own configurable gap around every item, so leaving that margin in place stacked an
extra, uncontrolled blank stretch on top of separator_width for whichever plugin
took the ScrollHelper-capture path — producing inconsistent transition gaps between
modules compared to plugins that provide content natively via get_vegas_content().

_get_scroll_helper_content() now detects and crops any such margin before handing
the image to the Vegas render pipeline, so every plugin's gap is governed solely by
vegas_scroll.separator_width regardless of which capture path produced its content.

.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/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`
+

.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.12"
-
-      # 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

@@ -5,10 +5,6 @@ on:
   push:
     branches: [main]
 
-# Both jobs only check out the repo and run pytest.
-permissions:
-  contents: read
-
 jobs:
   plugin-safety:
     name: Plugin safety harness + unit tests
@@ -35,55 +31,3 @@ jobs:
             test/plugins/test_harness.py \
             test/plugins/test_visual_rendering.py \
             test/plugins/test_plugin_matrix.py
-
-  unit-tests:
-    name: Core unit 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.12"
-          cache: pip
-
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install -r requirements.txt -r requirements-test.txt
-          pip install RGBMatrixEmulator
-
-      # Safety net for the shared sports/scroll/style infrastructure. These
-      # suites existed but were not enrolled in CI, so a refactor of
-      # src/base_classes or src/common could regress them silently. Enrolled
-      # explicitly (not `pytest test/`) so known hardware-only suites don't
-      # break CI; grow this list as more suites are made headless.
-      - name: Run core unit suites
-        run: |
-          pytest --no-cov \
-            test/test_skin_system.py \
-            test/test_font_manager.py \
-            test/test_data_sources.py \
-            test/test_api_extractors.py \
-            test/test_scroll_helper.py \
-            test/test_scroll_helper_continuous.py \
-            test/test_adaptive_layout.py \
-            test/test_loader_compat_warning.py \
-            test/test_sports_base_characterization.py \
-            test/test_element_style.py \
-            test/test_sports_core_promotions.py \
-            test/test_sports_modes_promotions.py \
-            test/test_sports_capabilities.py \
-            test/test_sports_scroll.py \
-            test/test_version_consistency.py \
-            test/test_plugin_compatibility_gate.py \
-            test/test_install_preserves_existing.py \
-            test/test_core_owned_config_keys.py \
-            test/test_async_plugin_updates.py \
-            test/test_plugin_update_reservation.py \
-            test/test_template_targets.py \
-            test/test_widget_scripts.py \
-            test/test_doc_links.py \
-            test/web_interface/test_cache.py

.gitignore

@@ -48,4 +48,3 @@ config/backups/
 
 # Starlark apps runtime storage (installed .star files and cached renders)
 /starlark-apps/
-skin_renders/

CHANGELOG.md

@@ -1,176 +0,0 @@
-# Changelog
-
-Notable changes to the LEDMatrix core. The version below is the value of
-`src.__version__`, which the plugin loader reports to compatibility checks and
-which plugin manifests reference via `ledmatrix_min_version`.
-
-**Why this file exists:** the plugin monorepo bundles fallback copies of several
-core modules (see `docs/plugin-development/08-shared-sports-code.md` in
-[ledmatrix-plugins](https://github.com/ChuckBuilds/ledmatrix-plugins)). A plugin
-may delete its bundled copy only when its manifest floors on the first core
-release that ships the module — which requires module additions to be recorded
-here, against a version number. When you add a module plugins will import via
-`src.*`, note it in the Unreleased section and bump `src/__init__.py` in the
-release that ships it.
-
-**Use `ledmatrix_min_version` in manifests, not `ledmatrix_min`.** The loader
-accepts both, but the store flags the old spelling as deprecated
-(`store_manager.py`) and only the new one is in `schema/manifest_schema.json`.
-
-## 3.2.0
-
-**The first release shipping the unified sports library.** This is the version
-a sports plugin floors `ledmatrix_min_version` at before deleting its bundled
-copy of `sports.py`, `scroll_display.py`, `data_sources.py` or
-`base_odds_manager.py` — the sunset rule in
-`docs/plugin-development/08-shared-sports-code.md` keys on exactly this number.
-
-Adoption is deliberately staged: the modules below ship here, plugins adopt them
-behind guarded imports, and only then do the bundled copies go away. Nothing in
-this release changes what an existing plugin loads.
-
-**This is also the first release that *enforces* `ledmatrix_min_version`.**
-Before it, the floor was advisory — the loader logged a warning and continued,
-and the plugin store never compared the core version at all, so an update could
-deliver a plugin that could not run. From 3.2.0 the store refuses such an
-install. That matters for the sunset rule: a plugin may only delete its bundled
-fallback once the cores in the field actually enforce the floor, which means
-waiting for 3.2.0 to be widely installed rather than merely released. See
-`docs/SPORTS_UNIFICATION.md`, phase B6.
-
-One deliberate exception: a core reporting a version below `2.0.0` is treated as
-*unknown* rather than old and is never blocked. The v3.1.0 release ships
-`__version__ = "1.0.0"` (the tag was cut before the string was bumped), and
-nearly every published manifest floors at `2.0.0` — so blocking on that number
-would lock those users out of the plugin store entirely.
-
-### Added
-- `src/element_style.py` — per-element style resolver backing the
-  `x-style-elements` config-schema extension. Already consumed (behind guarded
-  imports with classic fallbacks) by the `of-the-day`, `ledmatrix-music`, and
-  `football-scoreboard` plugins.
-- Core unit-test CI job enrolling the previously unenrolled suites (skin
-  system, data sources, API extractors, scroll helper, adaptive layout, loader
-  compatibility warning) plus new characterization tests for
-  `src/base_classes/sports.py` ahead of the shared sports-code unification.
-- `src/base_classes/sports/` — `sports.py` is now a package (`core.py` +
-  `modes.py`). The import path is unchanged: `from src.base_classes.sports
-  import SportsCore` still works.
-- Nine methods promoted onto the sports base classes from the plugins'
-  bundled copies, plus the override points `_favorite_key`,
-  `_config_schema_path` and `_font_root` and the class attributes
-  `FINAL_PERIOD` / `CLOCK_COUNTS_DOWN`. See `docs/SPORTS_UNIFICATION.md`.
-  A plugin may start calling these once its manifest floors
-  `ledmatrix_min_version` at the release that ships them.
-
-- `src/base_classes/sports/capabilities/` — opt-in capabilities for the sports
-  scoreboards, composed by inheritance rather than gated by config branches
-  inside the base classes:
-  - `CelebrationMixin` — the score/win takeover, merging the goal and score
-    dialects behind the `score_phrase()` / `win_phrase()` hooks, the
-    `COALESCE_SCORING_SEQUENCE` class attribute and the `_favorite_key` seam.
-    Reads both the `celebrate_opponent_goals` and `celebrate_opponent_scores`
-    config spellings. Sports that do not mix it in have none of this code in
-    their MRO.
-  - `RotationStrategy` + a name registry (`swrr`, `weighted`, `simple`,
-    plus `register_rotation_strategy` for plugin-supplied orderings). Each
-    built-in is verified against a verbatim transcription of the plugin
-    implementation it replaces. An unknown name degrades to `simple`.
-
-- `src/common/sports_scroll.py` — `SportsScrollDisplay` and
-  `SportsScrollDisplayManager`, the shared scroll **orchestration** layer for
-  the sports scoreboards, plus native support for
-  `global_config['target_fps']` (the bundled plugin copies hardcode ~100 FPS
-  via `scroll_delay` and never consult the global target). Content building
-  (`prepare_scroll_content`, `_load_separator_icons`) is per-sport and stays an
-  override point — see `docs/SPORTS_UNIFICATION.md` for where the line falls
-  and why.
-
-- `src/plugin_system/compatibility.py` — the single place that answers "can this
-  plugin run on this core?", shared by the loader (advisory, at load time) and
-  the store (blocking, at install/update time) so the two cannot drift. Reads
-  every spelling published manifests use, including the deprecated
-  `versions[].ledmatrix_min`. It does **not** yet evaluate `compatible_versions`,
-  which is the schema-required field and can express upper bounds; closing that
-  is tracked in `docs/SPORTS_UNIFICATION.md` before B6.
-- `scripts/check_release_version.py` and a `Release version check` workflow —
-  assert that a tag, the newest CHANGELOG heading and `src.__version__` agree,
-  on pushed `v*` tags and published releases. Runnable via `workflow_dispatch`
-  to check a tag *before* creating it. Added because `v3.1.0` was tagged six
-  weeks before `src/__init__.py` was bumped to match, which is why devices
-  installed from that release report `1.0.0`.
-
-### Changed
-- `src/__init__.py` bumped to **3.2.0** — the number the sunset rule keys on.
-- **The plugin store refuses an incompatible install.**
-  `StoreManager.install_plugin` now checks the downloaded manifest's declared
-  floor against `src.__version__` and refuses when the plugin needs a newer
-  core. The check sits in `install_plugin` because `_reinstall_with_rollback`
-  calls it, so a refused *update* restores the version the user already had.
-  Refusal requires evidence: an undeclared floor, an unparseable version on
-  either side, or an untrustworthy core version all allow the install.
-- **A failed install no longer destroys the plugin it replaced.**
-  `install_plugin` previously deleted the existing plugin directory before
-  downloading, so any later failure — a dropped connection, a malformed
-  manifest, or the new compatibility refusal — left the user with nothing. The
-  existing copy is now set aside and restored if the install fails, matching
-  the protection `_reinstall_with_rollback` already gave the update path.
-- `web_interface.__version__` re-exports `src.__version__` instead of carrying
-  its own hardcoded `"3.0.0"`, which had drifted two majors from the core.
-- **Live games are no longer dropped when the feed omits a game clock.**
-  `SportsLive._is_game_really_over` previously (in the baseball and UFC
-  plugin lineages) coerced a missing or non-string clock to the literal
-  `"0:00"` and then treated the game as finished once `period >= 4`. Baseball
-  has no game clock and `period` is the inning, so live MLB games disappeared
-  from the scoreboard from the 5th inning onward; UFC was affected the same
-  way. The clock check is now skipped when the clock is unusable, and the
-  period threshold is the per-sport `FINAL_PERIOD` (hockey ends in P3).
-  Sports whose clocks count up — soccer, AFL, NRL — set
-  `CLOCK_COUNTS_DOWN = False` and never run the check at all, since `0:00`
-  there means kickoff rather than expiry.
-
-### Fixed
-- **Plugin updates could hang the web request thread.** The per-plugin reinstall
-  locks were non-reentrant, and `_reinstall_with_rollback` holds one across its
-  call to `install_plugin` — which now takes the same lock to protect the
-  set-aside/restore above. That nesting deadlocked
-  `update_plugin → _reinstall_with_rollback → install_plugin`, the standard
-  path for every monorepo plugin update. The locks are now `RLock`s.
-- `FontManager` resolves `assets/fonts` against the core install root instead
-  of the process working directory, so font loading works when the process
-  starts elsewhere (e.g. the plugin safety harness on CI).
-- Hockey events whose competitors carry no `statistics` array are no longer
-  discarded. The extractor read `competitor["statistics"]` unguarded, so a
-  `KeyError` inside the generator dropped the entire event despite valid
-  scores and status; shot counts now fall back to `0`.
-- Live baseball events that populate status only at the competition level are
-  no longer discarded. The extractor read the event top-level
-  `game_event["status"]` for the inning; real ESPN events duplicate it, but
-  MiLB events synthesized from the MLB Stats API do not, so the lookup raised
-  a bare `KeyError`. It now reads the already-validated competition-level
-  status.
-- `SportsLive._is_game_really_over` no longer crashes the live-update pass when
-  a feed sends an explicit null `period`. `None >= FINAL_PERIOD` raised
-  `TypeError`, and the only caller (`_detect_stale_games`) has no `try/except`
-  — the same failure shape as the already-fixed null `period_text`.
-- An expired clock spelled `"00:00"` now ends the game. The check compared the
-  colon-stripped clock against a hand-listed set of literals, which `"0000"` is
-  not a member of, so a finished game with a two-digit-minute clock stayed on
-  the scoreboard indefinitely. The comparison is now numeric.
-- `SportsCore._load_fonts` resolves `assets/fonts` through the `_font_root()`
-  seam instead of the process working directory. Started outside the install
-  root, every scoreboard font silently degraded to PIL's default bitmap face.
-- `SportsCore._should_log` no longer raises `AttributeError` on the first
-  warning of a run; `_last_warning_time` is initialized in `__init__` rather
-  than lazily by an unrelated method.
-- `SportsCore._resolve_project_path` resolved relative logo directories
-  against `<root>/src` instead of the repo root after `sports.py` became a
-  package — the class bodies moved byte-identically but `__file__` gained a
-  directory. Both it and `_font_root` now derive from one `_INSTALL_ROOT`
-  constant.
-
-## 3.1.0
-
-Baseline for this changelog. Highlights already shipped at this version:
-skin system for sports scoreboards (#419), Vegas continuous-scroll overhaul
-(#423), plugin update surfacing (#421).

CLAUDE.md

@@ -6,16 +6,12 @@
 - `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:167`).
+  `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
-  (`StoreManager._find_plugin_path()` in `store_manager.py`) and schema
-  lookup (`SchemaManager.get_schema_path()` in `schema_manager.py`,
-  which probes `plugins/` *before* `plugin-repos/`).
+  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`
@@ -24,16 +20,6 @@
 - 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.matrix.width/height`
-- 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>` (or `link <name> <path>`); symlinks land in `plugins/` — set `plugin_system.plugins_directory` to `plugins` so discovery picks them up
-- 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>`
 
 ## Plugin Store Architecture
 - Official plugins live in the `ledmatrix-plugins` monorepo (not individual repos)
@@ -45,18 +31,7 @@
 - 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`
 
-## Skin System (visual overlays for sports scoreboards)
-- Skins live in `skins/<skin-id>/` (skin.json + skin.py), NOT in plugin dirs — plugin reinstall deletes plugin dirs
-- Core: `src/skin_system/` (ScoreboardSkin, SkinContext, runtime); hook: `SportsCore._render_game()` in `src/base_classes/sports/core.py`
-- Skins render onto `ctx.canvas` only; fallback to built-in renderer on `False`/exception (3 strikes disables for session)
-- View-model guaranteed keys are frozen (see `test/test_skin_system.py::TestViewModelContract`) — renaming keys in `_extract_game_details_common` or sport extractors breaks published skins
-- Validate skins headlessly: `python scripts/validate_skin.py --skin <id>`; docs: `docs/SKIN_SYSTEM.md`, `docs/CREATING_SKINS.md`
-- Skins are NOT monorepo plugins: no manifest bump / update_registry.py needed
-
 ## Common Pitfalls
 - 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

CONTRIBUTING.md

@@ -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,12 +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), `mypy` on
-   `src/`, `bandit`, and `gitleaks` — install them with
-   `pre-commit install` so they run on every commit; HTML/JS in
-   `web_interface/` follows the patterns already in `templates/v3/`
-   and `static/v3/`.
+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).

README.md

@@ -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)
@@ -149,7 +141,6 @@ The system supports live, recent, and upcoming game information for multiple spo
     sudo RPI_RGB_FORCE_REBUILD=1 ./first_time_install.sh
     ```
   - Pi 5 config: leave `rp1_rio` at `0` (PIO mode, default) and set `gpio_slowdown` to `1` or `2`.
-  - **1GB models (Pi 3B / 3B+) 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`.
 
 
 ### RGB Matrix Bonnet / HAT
@@ -323,12 +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
 
-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.
 
@@ -380,10 +371,6 @@ This single script installs services, dependencies, configures permissions and s
 
 ### 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 .
 
@@ -429,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.
@@ -453,16 +440,6 @@ See the [Plugin Store documentation](https://github.com/ChuckBuilds/ledmatrix-pl
 
 For plugin development, check out the [Hello World Plugin](https://github.com/ChuckBuilds/ledmatrix-hello-world) repository as a starter template.
 
-### Visual Skins for Scoreboards
-
-Want a different look for a sports scoreboard without forking the plugin?
-**Skins** restyle the live/recent/upcoming screens while the plugin keeps
-handling data, scheduling, caching, and vegas mode. Install one with
-`git clone <skin repo> skins/<skin-id>`, select it in the plugin's config,
-and you're done — see [docs/SKIN_SYSTEM.md](docs/SKIN_SYSTEM.md) (how it
-works) and [docs/CREATING_SKINS.md](docs/CREATING_SKINS.md) (build your own,
-including a ready-made Claude Code prompt).
-
 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>
 
@@ -622,7 +599,12 @@ These settings control runtime behavior and GPIO timing:
 
 ### 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

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

@@ -88,7 +88,6 @@
         }
     },
     "timezone": "America/New_York",
-    "target_fps": 100,
     "location": {
         "city": "Tampa",
         "state": "Florida",
@@ -110,11 +109,7 @@
             "inverse_colors": false,
             "show_refresh_rate": false,
             "led_rgb_sequence": "RGB",
-            "limit_refresh_rate_hz": 100,
-            "pixel_mapper_config": "",
-            "row_address_type": 0,
-            "multiplexing": 0,
-            "panel_type": ""
+            "limit_refresh_rate_hz": 100
         },
         "runtime": {
             "gpio_slowdown": 3,
@@ -126,7 +121,6 @@
             "axis": "horizontal"
         },
         "display_durations": {},
-        "plugin_rotation_order": [],
         "use_short_date_format": true,
         "vegas_scroll": {
             "enabled": false,
@@ -135,27 +129,7 @@
             "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": 3.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": {
@@ -166,8 +140,7 @@
     "plugin_system": {
         "plugins_directory": "plugin-repos",
         "auto_discover": true,
-        "auto_load_enabled": true,
-        "development_mode": false
+        "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"
     }
-}
+}

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-dir> --sizes 64x32,128x32,96x48,128x64,256x64
-python scripts/render_plugin.py <plugin-dir> --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

@@ -47,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 |
@@ -62,11 +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 26 keys in
-total. See the full list in
-[CONFIG_REFERENCE.md](CONFIG_REFERENCE.md#displayvegas_scroll--continuous-scroll-mode).
+| `buffer_ahead` | `2` | Number of panels to render ahead |
 
 ### Per-Plugin Configuration
 
@@ -88,13 +79,9 @@ Override Vegas behavior for specific plugins:
 | Setting | Values | Description |
 |---------|--------|-------------|
 | `vegas_mode` | `scroll`, `fixed`, `static` | Display mode for this plugin |
-| `vegas_panel_count` | any positive integer | Width in panels (1 panel = display width) |
+| `vegas_panel_count` | `1-10` | Width in panels (1 panel = display width) |
 | `display_duration` | seconds | Pause duration for STATIC mode |
 
-Plugins may also set `vegas_overflow` and `vegas_max_width_screens` in
-their config section to control how oversized content is handled (see
-`PluginManager` in `src/plugin_system/plugin_manager.py`).
-
 ### Plugin Integration (Developer Guide)
 
 **1. Implement Content Method:**
@@ -464,7 +451,7 @@ time when something is active.
 
 ### REST API Reference
 
-The API is mounted at `/api/v3` (`web_interface/app.py:199`).
+The API is mounted at `/api/v3` (`web_interface/app.py:144`).
 
 #### Start On-Demand Display
 
@@ -531,15 +518,13 @@ curl http://localhost:5000/api/v3/display/on-demand/status
 
 > 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.py`) write a request 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
 
@@ -661,13 +646,13 @@ keys helps troubleshoot stuck states.
 **When Set:** Every display loop iteration
 **Auto-Cleared:** Never (continuously updated)
 
-**4. display_on_demand_processed_id** (TTL: 1 hour)
+**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
 
@@ -700,9 +685,9 @@ keys helps troubleshoot stuck states.
 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
@@ -726,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
 
@@ -746,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
 
 ---
 
@@ -837,6 +821,9 @@ same shape as the example above.
 ### Testing
 
 ```bash
+# Run background service test
+python test_background_service.py
+
 # Check logs for background operations
 sudo journalctl -u ledmatrix -f | grep "background"
 ```
@@ -845,10 +832,9 @@ 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 tasks: {stats['active_tasks']}")
 print(f"Completed: {stats['completed']}")
@@ -889,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
 )
@@ -898,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
@@ -956,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**
@@ -1002,11 +984,8 @@ These core utilities **already handle permissions** - you don't need to call per
 If you encounter permission issues:
 
 ```bash
-# Targeted permission fixes (see scripts/fix_perms/README.md)
-sudo ./scripts/fix_perms/fix_assets_permissions.sh   # assets/ tree (logos, fonts)
-sudo ./scripts/fix_perms/fix_cache_permissions.sh    # all cache directories
-sudo ./scripts/fix_perms/fix_plugin_permissions.sh   # plugin directories
-sudo ./scripts/fix_perms/fix_web_permissions.sh      # web interface files
+# Fix all permissions at once
+sudo ./scripts/fix_permissions.sh
 
 # Fix specific directory
 sudo chown -R ledpi:ledpi /home/ledpi/LEDMatrix/config
@@ -1038,7 +1017,7 @@ stat -c "%a %n" 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,12 +2,6 @@
 
 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)

docs/CONFIG_REFERENCE.md

@@ -1,172 +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` |
-| `timezone` | string, `"America/New_York"` | IANA timezone for schedules and displays | `ConfigManager.get_timezone()` |
-| `target_fps` | int, `100` | Frame-rate ceiling for plugin rendering | `src/plugin_system/base_plugin.py`, `src/common/sports_scroll.py` |
-| `location` | object | `city` / `state` / `country`, offered to plugins that need a location (weather, etc.) | plugins via merged config |
-
-## `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 |
-
-Read by `DisplayController` (`src/display_controller.py`, `_check_schedule`
-around line 603). Managed in the web UI under Schedule.
-
-## `dim_schedule` — scheduled brightness dimming
-
-Same shape as `schedule`, plus:
-
-| Key | Type / default | Meaning |
-|---|---|---|
-| `dim_brightness` | int, `30` | Brightness percentage applied while the dim window is active |
-
-Read by `DisplayController` (`src/display_controller.py` around line 770;
-saved via `POST /api/v3/config/dim-schedule`). The display returns to
-`display.hardware.brightness` outside the window.
-
-## `display.hardware` — matrix panel hardware
-
-All keys map to the corresponding `rpi-rgb-led-matrix` options and are read
-in `DisplayManager` (`src/display_manager.py`, ~lines 270–295).
-
-| Key | Type / default |
-|---|---|
-| `rows` / `cols` | int, `32` / `64` |
-| `chain_length` | int, `2` |
-| `parallel` | int, `1` |
-| `brightness` | int, `90` |
-| `hardware_mapping` | string, `"adafruit-hat"` (code default `"adafruit-hat-pwm"`) |
-| `scan_mode` | int, `0` |
-| `pwm_bits` | int, `9` (code default 10) |
-| `pwm_dither_bits` | int, `1` |
-| `pwm_lsb_nanoseconds` | int, `130` (code default 150) |
-| `disable_hardware_pulsing` | bool, `false` |
-| `inverse_colors` | bool, `false` |
-| `show_refresh_rate` | bool, `false` |
-| `led_rgb_sequence` | string, `"RGB"` |
-| `limit_refresh_rate_hz` | int, `100` (code default 90) |
-| `pixel_mapper_config` | string, `""` — e.g. `"U-mapper"` / `"Rotate:90"` |
-| `row_address_type` | int, `0` — non-standard panel row addressing |
-| `multiplexing` | int, `0` — panel multiplexing scheme |
-| `panel_type` | string, `""` — set to `"FM6126A"` or `"FM6127"` for panels needing init |
-
-Where "code default" differs from the template value, the code default only
-applies if the key is missing entirely from your config.
-
-## `display.runtime`
-
-| Key | Type / default | Meaning |
-|---|---|---|
-| `gpio_slowdown` | int, `3` | GPIO timing slowdown for faster Pis |
-| `rp1_rio` | int, `0` | RP1 RIO mode on Pi 5 (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`) | `src/display_controller.py:1030` |
-| `plugin_rotation_order` | array, `[]` | Explicit rotation order of plugin ids; empty = all enabled plugins in discovery order | `src/display_controller.py:2894` |
-| `use_short_date_format` | bool, `true` | Compact date rendering in sports scoreboards | `src/base_classes/sports/core.py` |
-| `dynamic_duration.max_duration_seconds` | int, optional | Cap for plugins that request dynamic display time | `src/display_controller.py:405` |
-
-## `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.
-
-| 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` |
-| `smooth_scroll` | bool, `true` |
-| `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, `3.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` — frame-count-based scroll stepping |
-| `scroll_delay` | float, `0.02` — seconds between scroll updates (~50 FPS) |
-
-## `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:522`) |
-
-## `plugin_system`
-
-Read by the plugin loader/manager (`src/plugin_system/`).
-
-| Key | Type / default | Meaning |
-|---|---|---|
-| `plugins_directory` | string, `"plugin-repos"` | Where the Plugin Store installs plugins |
-| `auto_discover` | bool, `true` | Scan the plugins directory at startup |
-| `auto_load_enabled` | bool, `true` | Load discovered plugins automatically |
-| `development_mode` | bool, `false` | Development conveniences in the web UI (editable under General settings) |
-
-## 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_manager.py:348`) |
-| `<plugin-id>.*` | Secrets a plugin declares with `"x-secret": true` in its config schema; merged into that plugin's config at load time |

docs/CREATING_SKINS.md

@@ -1,242 +0,0 @@
-# Creating Skins
-
-A skin restyles a sports scoreboard (live / recent / upcoming) without
-forking the plugin: the plugin keeps fetching data, scheduling, caching, and
-doing vegas mode; your skin only draws. Architecture background:
-[SKIN_SYSTEM.md](SKIN_SYSTEM.md).
-
-## Quick start
-
-```bash
-cp -r skins/example-classic-baseball skins/my-skin
-# edit skins/my-skin/skin.json  -> set id ("my-skin"), name, author, class_name
-# edit skins/my-skin/skin.py    -> rename the class, start restyling
-python scripts/validate_skin.py --skin my-skin
-```
-
-The validator renders your skin against bundled fixture games at several
-panel sizes with **no hardware, no network, no running service**, saves PNGs
-(plus 4x previews) to `skin_renders/`, and fails loudly on errors. Iterate:
-edit → validate → look at the PNGs.
-
-To see it on your matrix, add to your plugin's section in `config/config.json`:
-
-```json
-"baseball-scoreboard": {
-  "skin": "my-skin",
-  "skin_options": { }
-}
-```
-
-or pick it from the **Visual Skin** dropdown in the web UI (it appears once a
-matching skin is installed). `"skin"` also accepts a per-mode mapping:
-`{"live": "my-skin", "recent": "built-in"}`.
-
-## The manifest (`skin.json`)
-
-```json
-{
-  "id": "my-skin",
-  "name": "My Skin",
-  "version": "1.0.0",
-  "author": "you",
-  "description": "What it looks like",
-  "skin_api_version": "1.0.0",
-  "targets": {
-    "sports": ["baseball"],
-    "sport_keys": ["mlb", "milb"],
-    "plugins": []
-  },
-  "entry_point": "skin.py",
-  "class_name": "MySkin",
-  "modes": ["live", "recent", "upcoming"],
-  "preview": "preview.png"
-}
-```
-
-Field notes: `id` must equal the directory name; `skin_api_version`'s major
-version must match the host's `SKIN_API_VERSION` or the skin is refused at
-load; `targets` takes sport families (`sports`), exact sport keys
-(`sport_keys`), and/or exact plugin ids (`plugins`) — any match applies.
-
-## The renderer (`skin.py`)
-
-```python
-from src.skin_system.skin_base import ScoreboardSkin, SkinContext
-
-class MySkin(ScoreboardSkin):
-    def render_live(self, ctx: SkinContext, game: dict) -> bool:
-        score = f"{game.get('away_score', '0')}-{game.get('home_score', '0')}"
-        fit = ctx.layout.fit_text(score, ctx.layout.bounds)
-        ctx.draw_fit(fit, ctx.layout.bounds)
-        return True   # True = "I drew it"; False = use the built-in layout
-```
-
-Implement only the modes you care about — anything else falls back to the
-plugin's built-in rendering. Return `False` to decline a specific game (e.g.
-a layout that only makes sense while a game is live).
-
-### The rules (they keep your skin from breaking the display)
-
-1. **Draw only onto `ctx.canvas`** (via the helpers or `ctx.draw`). Never
-   reassign `ctx.canvas`, never touch the display or call any update method.
-2. **No I/O in render paths.** No network, no file loads per frame —
-   `render_live` runs every display pass, and a slow render stalls the whole
-   matrix (the host warns at >150 ms). Use `ctx.load_logo` (cached) and
-   `cache_key=` for images.
-3. **Derive everything from `(ctx, game)`.** Skins must be stateless: the
-   live/recent/upcoming modes each get their own instance.
-4. **Always `.get()` optional keys.** Only the guaranteed keys below are
-   promised to exist.
-5. **Never hardcode pixel positions for the panel.** Use `ctx.width`/
-   `ctx.height`, `ctx.layout` regions and `fit_text` — your skin will be run
-   at sizes you didn't test (64x32, 128x64, vegas cards).
-6. **No third-party dependencies.** Stdlib + PIL + what `ctx` provides.
-
-A skin that raises 3 renders in a row is disabled until the service restarts
-(the built-in layout takes over), so a bug is cosmetic — but check your logs.
-
-## SkinContext reference
-
-| Member | What it is |
-|---|---|
-| `ctx.canvas` / `ctx.draw` | Fresh RGB `PIL.Image` at display size + its `ImageDraw` (raw-PIL escape hatch) |
-| `ctx.width`, `ctx.height` | Canvas size — the only size truth |
-| `ctx.layout` | `LayoutContext` (see [ADAPTIVE_LAYOUT.md](ADAPTIVE_LAYOUT.md)): `bounds`, `fit_text`, `fit_text_proportional`, `fit_image`, `px`, `by_tier` |
-| `ctx.draw_fit(fit, box, color, align, valign)` | Draw a `fit_text` result aligned in a `Region` (handles BDF fonts) |
-| `ctx.draw_text(text, x, y, color, font)` | Positioned text (handles BDF fonts) |
-| `ctx.draw_image(img, box, mode, align, valign, cache_key)` | Fit + paste an image with alpha; no-ops on `None` |
-| `ctx.load_logo("home" \| "away")` | Team logo as RGBA, or `None` (always handle `None`). Cached after first use; see note below |
-| `ctx.draw_text_outlined(text, (x, y), font, fill, outline_color)` | The classic scorebug outlined text (TTF fonts only) |
-| `ctx.fonts` | The host's font dict — keys `score`, `time`, `team`, `status`, `detail`, `rank` |
-| `ctx.options` | Your user's `skin_options` from config |
-| `ctx.sport`, `ctx.view_model_version`, `ctx.logger` | Context metadata + logger |
-
-**A note on `ctx.load_logo` vs the no-I/O rule:** `load_logo` is the one
-sanctioned exception. It goes through the host's logo cache — after the
-first call per team it's a pure in-memory lookup. If a logo file is missing
-on disk, the *first* call may download it, exactly like the built-in
-renderer does for the same game (a skin is never worse than built-in here).
-Always pass a stable `cache_key` when drawing it, never load image files
-yourself in a render path, and always handle `None`.
-
-The default layout idiom — carve regions, then fit text into them:
-
-```python
-from src.adaptive_layout import scoreboard_regions
-
-regions = scoreboard_regions(ctx.layout.bounds, ctx=ctx.layout)
-ctx.draw_image(ctx.load_logo("away"), regions.away_slot, cache_key=f"logo:{game.get('away_abbr')}")
-ctx.draw_image(ctx.load_logo("home"), regions.home_slot, cache_key=f"logo:{game.get('home_abbr')}")
-fit = ctx.layout.fit_text("3-5", regions.score_area)
-ctx.draw_fit(fit, regions.score_area)
-```
-
-`Region` supports `split_h`/`split_v`/`inset`/`top_band`/`bottom_band`/
-`left_col`/`right_col` for custom carves. Raw `ctx.draw.rectangle/polygon/
-ellipse/...` is always available for custom marks (see the bases diamond in
-the example skin).
-
-## The game view model
-
-Guaranteed for every sport (view model v1.0 — renaming these breaks skins and
-is treated as a breaking change upstream):
-
-| Key | Notes |
-|---|---|
-| `id` | Event id (string) |
-| `status_text` | Display-ready status, e.g. `"Final"`, `"7:30 PM"`, `"Bot 7th"` |
-| `is_live`, `is_final`, `is_upcoming`, `is_halftime` | Booleans |
-| `game_date`, `game_time` | Pre-formatted local date/time strings |
-| `start_time_utc` | UTC `datetime` |
-| `home_abbr`, `away_abbr` | Team abbreviations (can be 2–5 chars — fit, don't assume) |
-| `home_id`, `away_id` | Team ids |
-| `home_score`, `away_score` | **Strings**, not ints |
-| `home_record`, `away_record` | `"58-33"` or `""` (0-0 records are blanked) |
-| `home_logo_path`, `away_logo_path` | Prefer `ctx.load_logo` over touching these |
-
-Sport extras (present for that sport, still `.get()` defensively):
-
-- **baseball**: `inning` (int), `inning_half` (`"top"`/`"bottom"`), `balls`,
-  `strikes`, `outs` (ints), `bases_occupied` (`[first, second, third]`
-  booleans), `series_summary` (str)
-- **football**: `period`, `period_text`, `clock`, `home_timeouts`,
-  `away_timeouts`, `down_distance_text`, `down_distance_text_long`,
-  `is_redzone`, `possession`, `possession_indicator` (`"home"`/`"away"`),
-  `scoring_event`
-- **basketball**: `period`, `period_text`, `clock`
-- **hockey**: `period`, `period_text`, `clock`, `power_play`, `penalties`,
-  `home_shots`, `away_shots`
-
-Optional everywhere (only when the user enabled the feature): `odds` (dict),
-`series_summary`, rankings-related fields.
-
-Fixture copies of these dicts live in `src/skin_system/fixtures/` — that's
-exactly what the validator feeds your skin.
-
-## Vegas mode
-
-You get vegas support for free: vegas captures the normal display output,
-which is already your skin's rendering. Optionally implement
-`render_vegas_card(ctx, game)` to return a purpose-built card at
-`ctx.width x ctx.height` (sizes vary — never assume 128x32).
-
-## Building a skin with Claude Code
-
-Skins are ideal Claude Code projects: small, isolated, and verifiable with
-one command. Paste this to start:
-
-> You are building a **display skin** for LEDMatrix — a visual overlay for a
-> sports scoreboard on a small LED matrix (commonly 128x32 or 64x32 pixels).
-> First read `docs/CREATING_SKINS.md` and the reference skin in
-> `skins/example-classic-baseball/`.
->
-> Rules:
-> - Create/modify files ONLY under `skins/<my-skin-id>/`. Do NOT modify
->   anything in `src/`, `scripts/`, the plugins, or any other skin.
-> - Render only from the `game` dict and `ctx` helpers. No network calls, no
->   per-frame file I/O, no new pip dependencies, no touching the display —
->   draw onto `ctx.canvas` and return True.
-> - Use `ctx.layout` regions and `fit_text` for positioning so the skin works
->   at any panel size; use `.get()` for every optional game key.
-> - After every change run
->   `python scripts/validate_skin.py --skin <my-skin-id>` and LOOK at the
->   PNGs it writes to `skin_renders/` (the `_x4.png` files are easiest to
->   read). Iterate until it passes and looks right at both 128x32 and 64x32.
->
-> What I want it to look like: <describe your layout — where logos, score,
-> status go; colors; what shows during live vs upcoming vs final>
-
-Tips that keep Claude (and you) out of trouble:
-
-- One mode at a time: get `render_live` right before touching the others —
-  unimplemented modes automatically use the built-in look.
-- Ask for edge-case renders: long team abbreviations, missing logos
-  (`ctx.load_logo` returning `None`), 0-0 records, extra innings/OT.
-- If the render looks cramped at 64x32, ask Claude to use
-  `ctx.layout.by_tier(...)` to drop elements on small panels rather than
-  shrinking everything.
-- Never let it "fix" a problem by editing `src/` — if the skin can't do
-  something within its directory, that's a feature request, not a workaround.
-
-## Pre-publish checklist
-
-- [ ] `python scripts/validate_skin.py --skin <id> --size 128x32 --size 64x32 --size 128x64` passes
-- [ ] Looked at every PNG in `skin_renders/` — nothing clipped or overlapping
-- [ ] Handles a missing logo (`None`) without crashing — temporarily point a
-      fixture's logo path at a nonexistent file to test
-- [ ] Long abbreviations (`"TA&M"`, 4–5 chars) don't overflow
-- [ ] No render warning above the time budget
-- [ ] `skin.json`: `id` matches the directory, `version` set,
-      `skin_api_version` matches the host, targets correct
-- [ ] `preview.png` added (grab your favorite `_x4` render)
-- [ ] Tested on real hardware if you have it — a Pi is much slower than your
-      dev machine
-
-Distribute by publishing the directory as a git repo (users
-`git clone <repo> skins/<id>`), or submit it to the plugin registry as an
-entry with `"type": "skin"` (see [SKIN_SYSTEM.md](SKIN_SYSTEM.md) §Distribution).
-
-**Trust note:** a skin is Python running inside the display service — the
-same trust level as a plugin. Review code before installing skins from
-others.

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,12 +48,6 @@ 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
 display_manager.draw_weather_icon("rain", x=10, y=10, size=16)
 
@@ -190,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/
@@ -208,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/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

@@ -69,24 +69,23 @@ 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 @@ default configuration as it ships in the repo:
 | 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
@@ -308,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
@@ -354,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.
@@ -374,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
@@ -395,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
@@ -404,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,12 +1,5 @@
 # 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
 
 The enhanced FontManager provides comprehensive font management for the LEDMatrix application with support for:

docs/GETTING_STARTED.md

@@ -21,30 +21,18 @@ This guide will help you set up your LEDMatrix display for the first time and ge
 
 ---
 
-## 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 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
-
-**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
@@ -85,7 +73,7 @@ You should see:
 2. Set your matrix configuration:
    - **Rows**: 32 or 64 (match your hardware)
    - **Columns**: commonly 64 or 96; the web UI accepts any integer
-     in the 1–128 range, but 64 and 96 are the values the bundled
+     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
@@ -127,16 +115,11 @@ 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.)
+   update intervals, display duration, etc.)
 3. Click **Save**
 4. Restart the display service from **Overview** so the new settings take
    effect
 
-**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`).
-
 **Example: Weather Plugin**
 - Set your location (city, state, country)
 - Add an API key from OpenWeatherMap (free signup) to
@@ -225,14 +208,12 @@ 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.
@@ -299,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()`)
@@ -326,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
@@ -245,11 +248,13 @@ 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
+├── test_nba_*.py                        # NBA-specific test suites
 ├── plugins/                             # Per-plugin test suites
 │   ├── test_clock_simple.py
 │   ├── test_calendar.py
@@ -299,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>
@@ -331,15 +336,15 @@ 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 (harness, visual rendering
-and plugin-matrix tests) plus a unit-test job that runs an explicit
-allowlist of suites — new test files must be added to that list to run
-in CI. 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
 

docs/MIGRATION_GUIDE.md

@@ -86,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/PLUGIN_API_REFERENCE.md

@@ -2,11 +2,6 @@
 
 Complete API reference for plugin developers. This document describes all methods and properties available to plugins through the Display Manager, Cache Manager, and Plugin Manager.
 
-> **Adaptive layout:** every `BasePlugin` also exposes `self.layout`,
-> `self.draw_fit(text, region)` and `self.draw_image(img, region, ...)` —
-> the recommended way to render text and images that scale to any panel
-> size. See [ADAPTIVE_LAYOUT.md](ADAPTIVE_LAYOUT.md).
-
 ## Table of Contents
 
 - [BasePlugin](#baseplugin)
@@ -201,9 +196,8 @@ the mode selector for this plugin.
 
 #### `get_vegas_segment_width() -> Optional[int]`
 
-For `FIXED_SEGMENT` plugins, the number of *panels* the segment
-occupies in the scroll (pixel width = panels × `single_panel_width`,
-from `display.hardware.cols`). `None` uses the default of 1 panel.
+For `FIXED_SEGMENT` plugins, the width in pixels of the segment they
+occupy in the scroll. `None` lets the controller pick a default.
 
 > The full source for `BasePlugin` lives in
 > `src/plugin_system/base_plugin.py`. If a method here disagrees with the

docs/PLUGIN_ARCHITECTURE_SPEC.md

@@ -8,12 +8,9 @@
 > - Code paths reference `web_interface_v2.py`; the current web UI is
 >   `web_interface/app.py` with v3 Blueprint-based templates.
 > - The example Flask routes use `/api/plugins/*`; the real API
->   blueprint is mounted at `/api/v3` (`web_interface/app.py:199`).
+>   blueprint is mounted at `/api/v3` (`web_interface/app.py:144`).
 > - The default plugin location is `plugin-repos/` (configurable via
 >   `plugin_system.plugins_directory`), not `./plugins/`.
-> - Example imports use `src/plugin_system/base_classes/*_plugin.py`;
->   the shipped base classes live in `src/base_classes/` (e.g.
->   `src.base_classes.sports.SportsCore`, `src.base_classes.hockey.Hockey`).
 > - The "Migration Strategy" and "Implementation Roadmap" sections
 >   describe work that has now shipped.
 >

docs/PLUGIN_CONFIG_ARCHITECTURE.md

@@ -1,11 +1,5 @@
 # Plugin Configuration Tabs - Architecture
 
-> This page covers internals (how the config system works under the
-> hood). For designing a plugin's config schema, the canonical guide is
-> [PLUGIN_CONFIGURATION_GUIDE.md](PLUGIN_CONFIGURATION_GUIDE.md); for
-> the user-facing tabs feature, see
-> [PLUGIN_CONFIGURATION_TABS.md](PLUGIN_CONFIGURATION_TABS.md).
-
 ## System Architecture
 
 ### Component Overview

docs/PLUGIN_CUSTOM_ICONS.md

@@ -296,7 +296,7 @@ Want to change icons programmatically? While not officially supported, you could
 ## Related Documentation
 
 - [Plugin Configuration Tabs](PLUGIN_CONFIGURATION_TABS.md) - Main plugin tabs documentation
-- [Plugin Development Guide](PLUGIN_DEVELOPMENT_GUIDE.md) - How to create plugins
+- [Plugin Development Guide](plugin_docs/) - How to create plugins
 - [Font Awesome Icons](https://fontawesome.com/icons) - Browse all available icons
 - [Emoji Reference](https://unicode.org/emoji/charts/full-emoji-list.html) - All emoji options
 

docs/PLUGIN_DEPENDENCY_TROUBLESHOOTING.md

@@ -169,6 +169,6 @@ If you continue to experience issues:
 ## Related Documentation
 
 - [Plugin Dependency Guide](PLUGIN_DEPENDENCY_GUIDE.md)
-- [Plugin Development Guide](PLUGIN_DEVELOPMENT_GUIDE.md)
-- [Troubleshooting](TROUBLESHOOTING.md)
+- [Plugin Development Guide](docs/plugin_development.md)
+- [Troubleshooting Quick Start](TROUBLESHOOTING_QUICK_START.md)
 

docs/PLUGIN_DEVELOPMENT_GUIDE.md

@@ -2,20 +2,6 @@
 
 This guide explains how to set up a development workflow for plugins that are maintained in separate Git repositories while still being able to test them within the LEDMatrix project.
 
-> **Rendering guidance:** plugins should read the display size dynamically
-> (`self.display_manager.matrix.width/height`) rather than hardcoding one
-> panel. For plugins that want to *scale* their layout to any panel, the
-> opt-in adaptive layout system ([ADAPTIVE_LAYOUT.md](ADAPTIVE_LAYOUT.md))
-> provides the shared helpers — fonts, images, and composite layouts that
-> scale. Existing plugins keep their classic rendering unless they adopt
-> those APIs; nothing migrates automatically.
-
-> **Just want a different look for an existing sports scoreboard?** You may
-> not need a plugin at all — a **skin** restyles the live/recent/upcoming
-> rendering while the plugin keeps handling data, scheduling, caching, and
-> vegas mode, in ~100 lines of drawing code. See
-> [CREATING_SKINS.md](CREATING_SKINS.md).
-
 ## Overview
 
 When developing plugins in separate repositories, you need a way to:
@@ -589,24 +575,11 @@ Your plugin must:
 ### Versioning Best Practices
 
 - **Use semantic versioning**: `MAJOR.MINOR.PATCH` (e.g., `1.2.3`)
-- **GitHub as source of truth**: the plugin store resolves versions in this
-  order: GitHub Releases → GitHub Tags → manifest from branch → git commit hash
-- **Automatic version bumping**: install the self-contained pre-push hook in
-  your plugin repo and patch versions bump themselves on push (a git tag
-  `v{version}` is created and `manifest.json` staged automatically):
+- **Automatic version bumping**: Use the pre-push git hook for automatic patch version bumps
+- **Manual versioning**: Only needed for major/minor bumps or special cases
+- **GitHub as source of truth**: Plugin store fetches versions from GitHub releases/tags/manifest
 
-  ```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
-  ```
-
-  Set `SKIP_TAG=1` in the environment to skip auto-tagging for one push.
-- **Manual versioning**: only needed for major/minor bumps, CI pipelines that
-  bypass hooks, or forks without the hook — use
-  `scripts/bump_plugin_version.py`.
-- **Registry stores no versions**: `plugins.json` holds only metadata (name,
-  description, repo URL).
+See the [Git Workflow rules](../.cursorrules) for version management details.
 
 ### Submitting to Official Registry
 
@@ -680,5 +653,5 @@ For your plugin to work well in the plugin store:
 - [Advanced Plugin Development](ADVANCED_PLUGIN_DEVELOPMENT.md) - Advanced patterns and examples
 - [Plugin Quick Reference](PLUGIN_QUICK_REFERENCE.md) - Quick development reference
 - [Plugin Configuration Guide](PLUGIN_CONFIGURATION_GUIDE.md) - Configuration setup
-- [Plugin Store Guide](PLUGIN_STORE_GUIDE.md) - Using the plugin store
+- [Plugin Store User Guide](PLUGIN_STORE_USER_GUIDE.md) - Using the plugin store
 

docs/PLUGIN_QUICK_REFERENCE.md

@@ -14,10 +14,8 @@ and [PLUGIN_DEVELOPMENT_GUIDE.md](PLUGIN_DEVELOPMENT_GUIDE.md).
 ✅ **GitHub Store**: Discovery from `ledmatrix-plugins` registry plus
    any GitHub URL
 ✅ **Plugin Location**: configured by `plugin_system.plugins_directory`
-   in `config.json` (default `plugin-repos/`). Plugin discovery scans
-   only this directory — there is no loader fallback to `plugins/`
-   (only Plugin Store operations and schema lookup additionally probe
-   `plugins/`)
+   in `config.json` (default `plugin-repos/`; the loader also searches
+   `plugins/` as a fallback)
 
 ## File Structure
 
@@ -111,7 +109,7 @@ git push -u origin main
 git tag v1.0.0
 git push origin v1.0.0
 
-# Submit to registry (PR to ChuckBuilds/ledmatrix-plugins)
+# Submit to registry (PR to ChuckBuilds/ledmatrix-plugin-registry)
 ```
 
 ## Using Plugins
@@ -122,12 +120,12 @@ git push origin v1.0.0
 2. **Install**: Click **Install** in the plugin's row
 3. **Configure**: open the plugin's tab in the second nav row
 4. **Enable/Disable**: toggle switch in the **Installed Plugins** list
-5. **Reorder**: use the drag-and-drop **Rotation Order** list in the
-   **Rotation** tab (saved to `display.plugin_rotation_order`)
+5. **Reorder**: order is set by the position in `display_modes` /
+   plugin order; rearranging via drag-and-drop is not yet supported
 
 ### REST API
 
-The API is mounted at `/api/v3` (`web_interface/app.py:199`).
+The API is mounted at `/api/v3` (`web_interface/app.py:144`).
 
 ```bash
 # Install plugin from the registry

docs/PLUGIN_REGISTRY_SETUP_GUIDE.md

@@ -323,22 +323,16 @@ curl -X POST http://pi:5000/api/v3/plugins/install-from-url \
 ### Regular Updates
 
 ```bash
-# Refresh local clones of all plugin repos
-python3 scripts/update_plugin_repos.py
+# Update stars/downloads counts
+python3 scripts/update_stats.py
 
-# (Re-)create local plugin repo checkouts from the registry
-python3 scripts/setup_plugin_repos.py
+# Validate all plugin entries
+python3 scripts/validate_registry.py
 
-# Audit installed plugins for manifest/schema problems
-python3 scripts/audit_plugins.py
-
-# Validate a single plugin
-python3 scripts/check_plugin.py --plugin <plugin-id>
+# Check for plugin updates
+python3 scripts/check_updates.py
 ```
 
-Registry regeneration (`update_registry.py`) lives in the
-`ledmatrix-plugins` monorepo, not in this repo.
-
 ## Converting Existing Plugins
 
 To convert your existing plugins (hello-world, clock-simple) to this system:
@@ -406,7 +400,7 @@ print(f'Found {len(registry[\"plugins\"])} plugins')
 
 ## References
 
-- Plugin Store Implementation: See `PLUGIN_IMPLEMENTATION_SUMMARY.md`
-- User Guide: See `PLUGIN_STORE_GUIDE.md`
+- Plugin Store Implementation: See `PLUGIN_STORE_IMPLEMENTATION_SUMMARY.md`
+- User Guide: See `PLUGIN_STORE_USER_GUIDE.md`
 - Architecture: See `PLUGIN_ARCHITECTURE_SPEC.md`
 

docs/PLUGIN_STORE_GUIDE.md

@@ -481,13 +481,13 @@ A: Yes, if a plugin needs API keys, it can access them like core managers do.
 A: Most plugins are small (1-5MB). Check individual plugin documentation for specific requirements.
 
 **Q: Can I create my own plugin?**
-A: Yes! See [PLUGIN_DEVELOPMENT_GUIDE.md](PLUGIN_DEVELOPMENT_GUIDE.md) for instructions.
+A: Yes! See [PLUGIN_DEVELOPMENT.md](PLUGIN_DEVELOPMENT.md) for instructions.
 
 ---
 
 ## Related Documentation
 
-- [PLUGIN_DEVELOPMENT_GUIDE.md](PLUGIN_DEVELOPMENT_GUIDE.md) - Create your own plugins
+- [PLUGIN_DEVELOPMENT.md](PLUGIN_DEVELOPMENT.md) - Create your own plugins
 - [PLUGIN_API_REFERENCE.md](PLUGIN_API_REFERENCE.md) - Plugin API documentation
-- [PLUGIN_ARCHITECTURE_SPEC.md](PLUGIN_ARCHITECTURE_SPEC.md) - Plugin system architecture (historical)
+- [PLUGIN_ARCHITECTURE.md](PLUGIN_ARCHITECTURE.md) - Plugin system architecture
 - [REST_API_REFERENCE.md](REST_API_REFERENCE.md) - Complete REST API reference

docs/README.md

@@ -29,16 +29,15 @@ Start here:
 Going deeper:
 
 - [ADVANCED_PLUGIN_DEVELOPMENT.md](ADVANCED_PLUGIN_DEVELOPMENT.md) — advanced patterns
-- [PLUGIN_ARCHITECTURE_SPEC.md](PLUGIN_ARCHITECTURE_SPEC.md) — original plugin-system design spec (historical; see its banner for what has drifted)
+- [PLUGIN_ARCHITECTURE_SPEC.md](PLUGIN_ARCHITECTURE_SPEC.md) — full plugin-system spec
 - [PLUGIN_DEPENDENCY_GUIDE.md](PLUGIN_DEPENDENCY_GUIDE.md) /
   [PLUGIN_DEPENDENCY_TROUBLESHOOTING.md](PLUGIN_DEPENDENCY_TROUBLESHOOTING.md)
 - [PLUGIN_WEB_UI_ACTIONS.md](PLUGIN_WEB_UI_ACTIONS.md) (+ [example JSON](PLUGIN_WEB_UI_ACTIONS_EXAMPLE.json))
-- [PLUGIN_CUSTOM_ICONS.md](PLUGIN_CUSTOM_ICONS.md)
+- [PLUGIN_CUSTOM_ICONS.md](PLUGIN_CUSTOM_ICONS.md) /
+  [PLUGIN_CUSTOM_ICONS_FEATURE.md](PLUGIN_CUSTOM_ICONS_FEATURE.md)
 - [PLUGIN_REGISTRY_SETUP_GUIDE.md](PLUGIN_REGISTRY_SETUP_GUIDE.md) (+ [registry template](plugin_registry_template.json))
 - [STARLARK_APPS_GUIDE.md](STARLARK_APPS_GUIDE.md) — Starlark-based mini-apps
 - [widget-guide.md](widget-guide.md) — widget development
-- [ADAPTIVE_LAYOUT.md](ADAPTIVE_LAYOUT.md) — render legibly on any panel size (opt-in font/layout scaling)
-- [plugin-safety-harness.md](plugin-safety-harness.md) — test a plugin across every screen and matrix size
 
 ## Configuring plugins
 
@@ -53,12 +52,9 @@ Going deeper:
 - [ADVANCED_FEATURES.md](ADVANCED_FEATURES.md) — Vegas scroll, on-demand display,
   cache management, background services, permissions
 - [FONT_MANAGER.md](FONT_MANAGER.md) — font system
-- [SKIN_SYSTEM.md](SKIN_SYSTEM.md) — skin architecture for sports scoreboards
-- [CREATING_SKINS.md](CREATING_SKINS.md) — writing and validating a skin
 
 ## Reference
 
-- [CONFIG_REFERENCE.md](CONFIG_REFERENCE.md) — every key in config.json and config_secrets.json
 - [REST_API_REFERENCE.md](REST_API_REFERENCE.md) — all web-interface HTTP endpoints
 - [PLUGIN_API_REFERENCE.md](PLUGIN_API_REFERENCE.md) — Python APIs available to plugins
 - [DEVELOPER_QUICK_REFERENCE.md](DEVELOPER_QUICK_REFERENCE.md) — common dev tasks
@@ -70,7 +66,6 @@ Going deeper:
 - [HOW_TO_RUN_TESTS.md](HOW_TO_RUN_TESTS.md) — running the test suite
 - [MULTI_ROOT_WORKSPACE_SETUP.md](MULTI_ROOT_WORKSPACE_SETUP.md) — multi-repo workspace
 - [MIGRATION_GUIDE.md](MIGRATION_GUIDE.md) — breaking changes between releases
-- [SPORTS_UNIFICATION.md](SPORTS_UNIFICATION.md) — how the sports scoreboard base classes are organized
 
 ## Archive
 

docs/REST_API_REFERENCE.md

@@ -31,9 +31,9 @@ All endpoints return JSON responses with a standard format:
 - [Plugin-specific endpoints](#plugin-specific-endpoints)
 - [Starlark Apps](#starlark-apps)
 
-> The API blueprint is mounted at `/api/v3` (`web_interface/app.py:199`).
+> The API blueprint is mounted at `/api/v3` (`web_interface/app.py:144`).
 > SSE stream endpoints (`/api/v3/stream/*`) are defined directly on the
-> Flask app at `app.py:799-809`. There are 94 routes total — see
+> Flask app at `app.py:607-615`. There are about 92 routes total — see
 > `web_interface/blueprints/api_v3.py` for the canonical list.
 
 ---

docs/SKIN_SYSTEM.md

@@ -1,170 +0,0 @@
-# Skin System Architecture
-
-Skins are user-installable **visual overlays** for the sports scoreboards.
-A skin replaces only the *look* of a scoreboard — the host plugin keeps doing
-data fetching, scheduling, caching, dedup, live-priority takeover, and vegas
-mode. If you only want to **build** a skin, read
-[CREATING_SKINS.md](CREATING_SKINS.md); this document explains how the system
-works and why it is shaped this way.
-
-## Why skins instead of forks
-
-Before skins, changing a scoreboard's layout meant forking the whole plugin
-(e.g. the community MLB scoreboard fork). The fork gets the new look but loses
-everything the maintained plugin keeps earning: duration/scheduling behavior,
-vegas mode support, caching and background-fetch improvements, bug fixes. It
-also silently drifts: every upstream improvement now has to be re-ported by
-hand.
-
-A skin inverts that trade. The plugin remains stock and keeps updating through
-the store; the skin is ~100 lines of pure rendering code that receives the
-plugin's already-fetched data each frame. Uninstalling the skin (or the skin
-crashing) simply restores the built-in look.
-
-```text
-              (unchanged)                        (the skin seam)
- ESPN API ──► update() ──► game view model ──► _render_game() ──► display
-              fetching        (a dict)          │         │
-              caching                           │         └─ built-in
-              scheduling                        └─ skin.render_<mode>(ctx, game)
-              live priority                        draws onto ctx.canvas
-```
-
-## The render funnel
-
-Every sports scoreboard (baseball, football, basketball, hockey — anything
-built on the `src/base_classes/sports/` package, `core.py`) renders through exactly one seam:
-`SportsCore._render_game(game, force_clear)`.
-
-1. The mode class's `display()` (live, `SportsUpcoming`, `SportsRecent`)
-   picks `self.current_game` and calls `_render_game`.
-2. `_render_game` lazily loads the configured skin (once, on first render —
-   a broken skin can never block plugin startup).
-3. If a skin is active, the host builds a `SkinContext` — a fresh black
-   canvas at the current display size plus layout/font/logo helpers — and
-   calls the skin's `render_live` / `render_recent` / `render_upcoming`
-   with a **copy** of the game dict.
-4. If the skin returns `True`, the canvas is composited onto the display.
-   If it returns `False`, isn't implemented for that mode, or raises, the
-   built-in `_draw_scorebug_layout` runs instead.
-
-Key properties that fall out of this design:
-
-- **Per-mode fallback.** A skin that only implements `render_live` gets the
-  stock recent/upcoming screens for free.
-- **Three strikes.** A skin that raises 3 times in a row is disabled for the
-  rest of the session (one loud error log per failure); the display never
-  goes dark. Restarting the service re-arms it.
-- **Copies, not references.** Skins receive a shallow copy of the game dict,
-  so a buggy skin cannot corrupt the plugin's scheduling state.
-- **Vegas mode works untouched.** Vegas capture falls back to grabbing the
-  regular `display()` output, which is already skin-rendered. Skins can
-  additionally implement `render_vegas_card` for purpose-built scroll cards,
-  and hosts can call `SportsCore.render_skin_card(game, size)` to use it.
-- **Hot-loop caution.** `render_live` runs every display-loop pass during a
-  live game. The host logs a warning when a skin render exceeds 150 ms, and
-  `scripts/validate_skin.py` enforces a budget at development time — but
-  Python cannot forcibly time-out a stuck render, so a skin that blocks
-  (network I/O, giant image ops) stalls the display. This is why the rules
-  in CREATING_SKINS.md ban I/O in render paths.
-
-## The view model contract
-
-The `game` dict a skin receives is the plugin's already-extracted view model
-(`SportsCore._extract_game_details_common` plus per-sport extras from
-`src/base_classes/{baseball,basketball,football,hockey}.py`).
-
-- **Guaranteed keys (view model v1.0)** — always present for every sport:
-  `id`, `game_time`, `game_date`, `start_time_utc` (a UTC `datetime`),
-  `status_text`, `is_live`, `is_final`, `is_upcoming`, `is_halftime`,
-  `home_abbr`/`away_abbr`, `home_id`/`away_id`, `home_score`/`away_score`
-  (**strings**), `home_logo_path`/`away_logo_path`, `home_record`/`away_record`.
-- **Sport extras** — documented per sport in CREATING_SKINS.md (e.g. baseball
-  adds `inning`, `inning_half`, `balls`, `strikes`, `outs`, `bases_occupied`).
-- **Optional keys** (`odds`, rankings, `series_summary`, …) are present only
-  when the feature is enabled — skins must always use `.get()`.
-
-Versioning policy: additive changes bump the minor version
-(`VIEW_MODEL_VERSION` in `src/skin_system/skin_base.py`, surfaced to skins as
-`ctx.view_model_version`); renaming or removing a guaranteed key requires a
-major bump plus a compat shim. `test/test_skin_system.py::TestViewModelContract`
-fails CI if a guaranteed key disappears from the extractor.
-
-Separately, `SKIN_API_VERSION` versions the Python API (`ScoreboardSkin`,
-`SkinContext`). The loader refuses a skin whose manifest declares a different
-major version and falls back to the built-in renderer with a clear
-"skin needs an update" log line.
-
-## Package layout and lifecycle
-
-```text
-skins/<skin-id>/
-  skin.json      # manifest (required)
-  skin.py        # ScoreboardSkin subclass (required)
-  preview.png    # optional, shown by the web UI
-  assets/        # optional skin-local images
-  helpers.py ... # optional extra modules (namespaced per skin at import)
-```
-
-Skins live in the central `skins/` directory — deliberately **not** inside the
-plugin's directory, because plugin reinstall/update deletes the whole plugin
-directory and a skin must survive that. One skin can also target several
-plugins (mlb + milb).
-
-Lifecycle: discovered lazily on first render → manifest validated → API major
-version gated → module imported under a namespaced `sys.modules` key (two
-skins can both ship a `helpers.py`, same scheme plugins use) → instantiated
-with `(manifest, options)`. Every failure logs and falls back to built-in.
-
-Skins should be **stateless**: the live, recent, and upcoming mode classes
-each hold their own skin instance, so derive everything from `(ctx, game)`.
-
-## Selection and configuration
-
-Inside the plugin's own config section in `config/config.json`:
-
-```json
-"baseball-scoreboard": {
-  "skin": "retro-baseball",
-  "skin_options": { "accent_color": [255, 80, 0] }
-}
-```
-
-`"skin"` is either one id for all modes or a per-mode mapping
-(`{"live": "retro-baseball", "recent": "built-in"}`). Absent, empty, or
-`"built-in"` means the stock renderer. Because this rides the plugin's config
-section, it persists across plugin reinstalls like every other setting.
-
-The web UI shows a **Visual Skin** dropdown for plugins that have matching
-skins installed: `SchemaManager.inject_skin_selector` adds an enum to the
-*served* schema only. Validation never sees the enum — so a config that
-references an uninstalled skin stays valid (rendering just falls back), and
-the currently-configured value is always kept selectable. `GET /api/v3/skins`
-lists installed skins (optionally filtered by `?plugin_id=`).
-
-## Distribution
-
-- **Manual:** `git clone <skin repo> skins/<skin-id>` — that's the whole
-  install. No manifest bumps, no `update_registry.py`; skins are not monorepo
-  plugins.
-- **Store:** registry entries with `"type": "skin"` install through the same
-  `plugins.json` pipeline; `PluginStoreManager` routes them to `skins/`,
-  validates `skin.json` (including the API major version) instead of
-  `manifest.json`, and never installs dependencies — skins are render-only
-  (stdlib + PIL + the provided context, no third-party packages in v1).
-
-## Trust model
-
-A skin is Python executing inside the display service — **exactly the same
-trust level as a plugin**, even though "skin" sounds cosmetic. Only install
-skins from sources you'd be willing to install a plugin from.
-
-## v2 directions (not in v1)
-
-- A generic `BasePlugin` opt-in (`render_with_skin()`) so non-sports plugins
-  (weather, music) can offer skinnable layouts; `skin_runtime` is already
-  sports-agnostic in anticipation.
-- Store UI: preview gallery, one-click install from the skin browser.
-- An update path for git-cloned skins (today: re-clone or store reinstall).
-- Animation support in skins (today the API is one frame per render call;
-  stateful tricks work but are at-your-own-risk).

docs/SPORTS_UNIFICATION.md

@@ -1,387 +0,0 @@
-# Sports Code Unification — Architecture
-
-How the nine sports scoreboard plugins converge onto shared core code **without**
-becoming nine clients of a god class.
-
-## The problem
-
-Nine plugins (`afl`, `baseball`, `basketball`, `football`, `hockey`, `lacrosse`,
-`nrl`, `soccer`, `ufc`) each ship a ~3,000-line `sports.py` descended from this
-repo's `src/base_classes/sports.py`. They have drifted into three lineages, and
-only 28 of the 66 methods appearing across them are present in all nine. One
-logical fix (the UTC start-time bug) cost 75 files.
-
-Merging everything into one base class would fix the duplication and create a
-worse problem: a single 2,500-line class that all nine plugins inherit, where any
-change has a nine-plugin blast radius and per-sport behavior survives only as
-`if self.sport == "hockey"` branches.
-
-## Three properties, three mechanisms
-
-These are independent concerns. Conflating them is what produces god classes.
-
-### Upgradability — a plugin keeps working across core versions
-
-| Rule | Mechanism |
-|---|---|
-| Plugin loads on a core that predates a module | Guarded import with a bundled fallback (`try: from src.X import Y / except ModuleNotFoundError: from y import Y`) |
-| Plugin loads on a core that predates a *method* | Capability probing — `hasattr(SportsCore, "_detect_stale_games")` — never a version comparison. The loader's compat check is advisory-only (it logs and continues), so probing is the real protection. |
-| Core changes never break a plugin's rendering | The **view-model contract**: `_extract_game_details_common` returns a dict whose `GUARANTEED_KEYS` are frozen by `test/test_skin_system.py::TestViewModelContract`. Keys may be added, never renamed or removed. |
-| A plugin can drop its bundled copy safely | The **sunset rule**: its manifest must floor `ledmatrix_min_version` at the first core release shipping the module (recorded in `CHANGELOG.md`) — *necessary but not sufficient*. Nothing enforces that floor today, so the copy also waits for the B6 gate below. |
-
-The core API is **additive-only**. A method the plugins call is never removed or
-given a new required parameter; new behavior arrives as new methods with
-defaults, or as capabilities they opt into.
-
-### Reusability — write once, nine plugins benefit
-
-Only code that is **identical in intent across all nine** moves into the base
-class. That set is small and knowable — it is exactly the methods present in every
-copy today (phase B1 below). Everything else stays where it is until it earns
-promotion.
-
-### Modularity — a change to one feature cannot reach a plugin that doesn't use it
-
-This is the property the naive merge destroys, and it is enforced structurally:
-
-1. **Capabilities are separate modules composed by inheritance, not config
-   branches inside the base class.** Hockey has no celebrations, so
-   `HockeyLive` does not inherit `CelebrationMixin` — the celebration code is not
-   merely disabled for hockey, it is *not in hockey's MRO at all*. No shared
-   state, no dead branches, no risk. Contrast with
-   `if self.celebrations_enabled:` inside `SportsLive`, where a bug in
-   celebration code can still crash a plugin that never wanted the feature.
-
-2. **Variant behavior is a strategy object chosen by name, not a branch.**
-   Live rotation exists in three dialects across the lineages; core ships all
-   three behind `rotation_strategy: "swrr" | "weighted" | "simple"` and a plugin
-   may register its own. Core never learns sport names.
-
-3. **Sport-specific behavior is a documented override point.** The base class
-   declares the seam; the plugin fills it. Basketball's tournament-round parsing
-   and baseball's BDF sizing stay in their plugins forever — they are not
-   candidates for promotion, and core must never grow a branch for them.
-
-4. **Files bound the blast radius.** Capabilities live in their own modules so a
-   diff shows at a glance which plugins a change can reach.
-
-## Layering
-
-```
-src/base_classes/sports/
-  __init__.py            re-exports the public API (import path unchanged)
-  core.py                SportsCore — fetch, cache, config, logos, fonts, odds,
-                         view-model extraction, the skin seam
-  modes.py               SportsUpcoming / SportsRecent / SportsLive
-  capabilities/
-    celebrations.py      CelebrationMixin        (opt-in: 4 of 9 plugins)
-    rotation.py          RotationStrategy + registry
-
-src/common/
-  sports_scroll.py       SportsScrollDisplay / …Manager — scroll orchestration
-                         (content building stays in the plugins)
-```
-
-`from src.base_classes.sports import SportsCore` keeps working — the package
-`__init__` re-exports, so the conversion is invisible to every existing importer.
-
-## Override points (the plugin-facing seam)
-
-The base class calls these; plugins implement or override them. This table is the
-contract — additions require a default implementation, removals require a
-deprecation cycle.
-
-| Hook | Purpose | Default |
-|---|---|---|
-| `_fetch_data()` | Sport's schedule source | abstract |
-| `_extract_game_details(event)` | Sport-specific view-model fields on top of the common ones | delegates to `_extract_game_details_common` |
-| `_draw_scorebug_layout(game, force_clear)` | Sport's card rendering | base layout |
-| `_custom_scorebug_layout(game, draw)` | Per-sport overlay on the base layout | no-op |
-| `render_skin_card(game, size)` | Skin-system entry point | built-in fallback |
-| `score_phrase(points, team_abbr)` | Celebration wording (`"GOOOOAAALLL!"` vs `"TOUCHDOWN!"`). `points` is the score delta, which sports with variable-value scores use to name the play | `"<abbr> SCORES!"` — only consulted when `CelebrationMixin` is present |
-| `win_phrase(team_abbr)` | Win-celebration wording | `"<abbr> WINS!"` — mixin only |
-| `_favorite_key(game, side)` | Which view-model field identifies a team for favorites matching | `game["<side>_abbr"]` |
-| `_config_schema_path()` | Plugin's `config_schema.json` — returning it routes `_get_layout_offset` through the `src.element_style` resolver (and gives it the defaults to compare against) | `None`, i.e. the classic inline `customization.layout` read |
-| `_font_root()` | Directory to resolve `assets/fonts` against | core install root |
-
-Two class attributes serve the same purpose for values that are per-sport
-constants rather than behavior:
-
-| Attribute | Meaning | Default |
-|---|---|---|
-| `FINAL_PERIOD` | Period at/after which a zero clock can mean "over" | `4` (hockey overrides to `3`) |
-| `CLOCK_COUNTS_DOWN` | Whether `0:00` means "expired" | `True` (soccer/afl/nrl override to `False` — their clocks count up, so `0:00` is kickoff) |
-| `COALESCE_SCORING_SEQUENCE` | Fold score increments arriving during an active celebration into that one celebration | `False` (football overrides to `True` — a touchdown lands as +6, then +1 for the extra point) |
-
-### Why these are seams and not branches
-
-`_favorite_key` exists because NRL abbreviations are **not unique** — "NEW" is both
-Newcastle Knights and New Zealand Warriors, "CAN" both Canberra and Canterbury —
-so NRL matches favorites on team ID. Flattening every plugin to abbreviations
-would silently select the wrong club for NRL users. The base declares the seam,
-NRL fills it, and core never learns the string `"nrl"`.
-
-`CLOCK_COUNTS_DOWN` exists for the same reason in the opposite direction: a
-soccer clock reading `0:00` means the match has not kicked off, so running the
-clock-expiry branch there would evict live games.
-
-`COALESCE_SCORING_SEQUENCE` is the third of the same kind. In football one
-scoring play arrives as two score updates, so the follow-up must be folded into
-the first celebration; in soccer two increments a few seconds apart are two real
-goals, and folding them would swallow one. Neither default is "right" — which is
-precisely why it is a declared per-sport constant rather than a hidden
-assumption baked into the shared body.
-
-## Capabilities
-
-```
-capabilities/
-  celebrations.py   CelebrationMixin        opt-in: afl, nrl, soccer, football
-  rotation.py       RotationStrategy + registry
-```
-
-**`CelebrationMixin`** merges the two dialects the lineages grew
-(`_check_for_goal`/`celebrate_opponent_goals` vs
-`_check_for_score`/`celebrate_opponent_scores`). Their bodies were identical
-apart from three things, each now a seam: wording (`score_phrase`), follow-up
-suppression (`COALESCE_SCORING_SEQUENCE`), and team identity (`_favorite_key`,
-so NRL matches on id). Both config spellings are read, so a plugin adopting the
-mixin keeps working with the keys already in its published schema.
-
-Mix it in **before** the mode class — `class SoccerLive(CelebrationMixin,
-SportsLive)` — so the celebration `display()` runs first and falls through to
-the scorebug via `super()`.
-
-**Rotation strategies.** The three "dialects" turned out to be one algorithm
-(Smooth Weighted Round-Robin) in two shapes: an incremental picker holding state
-across calls (afl/nrl/soccer) and a precomputed per-cycle list
-(football/baseball/basketball, and hockey with a different loop shape). They
-agree within a cycle and differ only at the boundary — the incremental form has
-no restart seam — so core ships both rather than declaring a winner:
-
-```python
-self.rotation = get_rotation_strategy("swrr", weight_for=self._live_weight)
-```
-
-`weight_for` is supplied by the host, so the *favorites* policy stays with the
-plugin and `rotation.py` never learns what a favorite is. An unknown strategy
-name degrades to `simple` rather than raising: the name comes from user config,
-and a typo should cost the boost, not the scoreboard. When a plugin needs an
-ordering that core does not ship, it calls `register_rotation_strategy` to add
-its own — rather than core growing a branch for it.
-
-`test_sports_capabilities.py` checks each strategy against a **verbatim
-transcription** of the plugin code it replaces, over every live-game shape up to
-four games. That differential is what B5 deletes the bundled copies on the
-strength of.
-
-## Scroll display — where the promotion line falls
-
-`src/common/sports_scroll.py` is deliberately *not* a superset of the ten
-`scroll_display.py` copies. A method-level comparison of the eight that share a
-shape (f1 and ufc are genuine forks) found a sharp split:
-
-| Layer | Evidence | Outcome |
-|---|---|---|
-| Orchestration — `get_all_vegas_content_items`, `clear_all`, `get_scroll_info`, `get_dynamic_duration`, `is_complete`, `display_frame` | identical to 96–100% similar across all eight | **promoted** |
-| Settings — `_get_scroll_settings` | one algorithm; the copies differ *only* in which league keys they walk | **promoted**, with the ladder as data (`SCROLL_LEAGUE_KEYS`) |
-| Content — `prepare_scroll_content`, `_load_separator_icons` | 8 distinct bodies across 8 plugins (145 lines, 53% similar at worst); icons 6% | **override point, permanently** |
-
-Same name, different job: `prepare_scroll_content` draws *this sport's* game
-card. Merging the eight bodies would be the exact mistake the promotion rule
-exists to prevent, so the base class raises `NotImplementedError` rather than
-rendering something plausible — a base that rendered *something* would let a
-plugin ship a silently blank scroll.
-
-The one behavior the upstreamed version adds is native
-`global_config['target_fps']` support. The bundled copies hardcode ~100 FPS via
-`scroll_delay = 0.01` and never consult the global smooth-scrolling target;
-Part A threaded it through each copy by hand, and this makes that threading
-legacy compatibility rather than the mechanism.
-
-## Phases
-
-B0–B3 are merged and shipping in core 3.2.0. Everything that remains is
-**rollout**, and it splits into three phases with very different risk profiles.
-The original plan folded the last two together; they are separated here because
-one of them is safe by construction and the other is not.
-
-| Phase | Scope | Status | Gate |
-|---|---|---|---|
-| **B0** | Characterization tests, CI unit job, `element_style`, font cwd fix, CHANGELOG discipline | ✅ | — |
-| **B1** | Promote the nine universal methods; convert `sports.py` → package | ✅ | Characterization suite green; no behavior change intended |
-| **B2** | `CelebrationMixin` + rotation strategies as opt-in capabilities | ✅ | Non-adopters have zero new code in their MRO; strategies checked against verbatim plugin transcriptions |
-| **B3** | Upstream the scroll **orchestration** layer as `src/common/sports_scroll.py`, reading `global_config['target_fps']` natively | ✅ | Content building stays per-sport |
-| **B4** | Ship 3.2.0 *and* make version reporting trustworthy | ⏳ **next** | Tag, release, and `src.__version__` agree; compatibility gate merged |
-| **B5** | Adoption — guarded core imports: three pilots, then the remaining six. **Bundled copies stay.** | after B4 | Per plugin: harness + goldens byte-identical, then a device soak |
-| **B6** | Sunset — delete the bundled copies | **blocked** | B4's gate shipped *and* in users' hands (see below) |
-
-### B4 — what "ship 3.2.0" actually requires
-
-Cutting the tag is the small part. The version *number* has to become something
-a floor can be trusted against, and today it is not:
-
-- **The tag and `src.__version__` have never agreed.** `v3.1.0` was tagged
-  2026-05-31; `__version__` only became `"3.1.0"` on 2026-07-12 (`7f7f0d64`).
-  The v3.1.0 release therefore reports `__version__ = "1.0.0"`.
-- **Which silences the compatibility warning entirely for that population.**
-  `PluginLoader._warn_if_incompatible` skips the check when the parsed core
-  version is below `(2, 0, 0)` — an anti-spam guard that, given the above,
-  matches exactly the users most likely to be behind.
-- **Nothing enforces a floor anyway.** The check is advisory (it logs and
-  continues), and neither `StoreManager.install_plugin` nor
-  `StoreManager.update_plugin` compares the core version at all — `update_plugin`
-  compares the plugin's manifest version against the registry's
-  `latest_version` and nothing else.
-
-So B4 is: tag and release 3.2.0; make the tag, the release, and `__version__`
-agree, and keep them agreeing; reconsider the `< 2.0.0` skip; migrate manifests
-from `ledmatrix_min` to `ledmatrix_min_version`; and add the install/update
-compatibility gate that B6 depends on.
-
-#### Two fields express compatibility, and the gate only reads one
-
-`compatible_versions` is the canonical contract: `schema/manifest_schema.json`
-**requires** it, all 42 published manifests carry it, and it holds semver
-*ranges* — `[">=2.0.0"]` in 41 of them, `[">=1.0.0"]` in `7-segment-clock`.
-`ledmatrix_min_version` is the optional per-release floor inside `versions[]`.
-
-The gate as merged reads only the floor. Today that is harmless: no manifest
-uses an upper bound, and the two fields agree everywhere except
-`7-segment-clock` (`>=1.0.0` against a `2.0.0` floor). But the fields *can*
-disagree, and the range syntax the schema already permits includes upper bounds
-— a plugin declaring `["2.0.0 - 2.9.9"]` means "not compatible with 3.x" and
-the gate would install it on 3.2.0 regardless.
-
-**Before B6, the gate must evaluate `compatible_versions` as well**, and the
-manifest migration must reconcile the two fields rather than only renaming the
-floor. Deciding which wins when they disagree is part of that work; the safe
-default is the more restrictive.
-
-(The schema also deprecates a top-level `ledmatrix_version` in favour of
-`compatible_versions`. No manifest still carries it, so there is nothing to
-migrate there.)
-
-### B5 — adoption is safe by construction
-
-A plugin adopting core imports keeps its bundled copy and reaches it through the
-guarded import (see the Upgradability table above). On a core that ships the
-module the plugin uses core code; on one that doesn't it falls back and behaves
-exactly as it does today. There is no version of this step that breaks a user,
-which is why it does not wait for B6's gate.
-
-The hockey scroll-display pilot is **already validated**: adopted against a core
-carrying 3.2.0, `scroll_display.py` went from 691 to 289 lines and all 16 harness
-renders (8 sizes × 2 screens) came out byte-for-byte identical to the
-pre-adoption run. That byte-comparison is the acceptance gate for every
-adoption. The recipe and its two gotchas are in the plugins repo's
-`docs/plugin-development/08-shared-sports-code.md`.
-
-### B6 — why the sunset needs more than a version floor
-
-Deleting a bundled copy removes the fallback, so the guarded import becomes a
-hard dependency. On a core without the module the plugin raises
-`ModuleNotFoundError` at load; `PluginManager.load_plugin` catches it, records
-`PluginState.ERROR`, logs one line, and continues. Nothing crashes — the user
-simply loses that scoreboard, with no visible explanation.
-
-Verified against a `v3.1.0` worktree: `src/common/sports_scroll.py`,
-`src/element_style.py` and the `src/base_classes/sports/` package are all absent
-there, and the import fails with `exc.name == 'src.common.sports_scroll'`. Guard
-sets must name that exact dotted path — `{"src"}` alone does not match it.
-
-Combined with the B4 findings, a plugin that deletes its copy today reaches an
-un-updated user through a normal store update, fails to load, and warns nobody.
-**B6 therefore waits for B4's compatibility gate to have shipped and to have
-been in users' hands long enough that the population running a core without it
-is small.** The bundled copies cost disk space; deleting them early costs
-scoreboards, silently. That trade is not close.
-
-Before the first sunset, add a **compatibility regression test**. It has to
-cover four cases, not one — B5's safety claim and B6's failure mode are
-different propositions and only the second is obvious:
-
-| | bundled copy present | bundled copy removed |
-|---|---|---|
-| **pinned old core** | **loads** — this is B5's whole guarantee, that the guarded import falls back | `PluginState.ERROR`, and the recorded error names the exact missing module |
-| **current core** | loads, using core code | loads, using core code |
-
-The top-left cell is the one worth writing first: nothing in the suite currently
-proves that an adopted plugin still works on a core that predates the module,
-which is the entire basis for saying B5 is safe to run ahead of the gate.
-
-Assert the old-core/removed-copy case as `PluginState.ERROR` **plus the missing
-module path**, not as an uncaught exception. `PluginManager.load_plugin` catches
-`ModuleNotFoundError`, so nothing propagates — a test expecting a raise would
-pass for the wrong reason on a core where the module is merely broken rather
-than absent. "Fails loudly" is aspirational, not what the code does today: it
-fails into `ERROR` state with one log line, which is precisely why B6 needs the
-gate rather than trusting the failure to be noticed.
-
-The same suite should exercise the install/update gate, since it is the other
-half of the guarantee.
-
-## What's next
-
-In order. Each step is independently useful and independently revertible.
-
-1. **Tag and publish v3.2.0.** The code is already on `main` (`21825cbf`).
-   Nothing else blocks this, and it is what makes `ledmatrix_min_version:
-   "3.2.0"` refer to something real.
-2. **Make the version number honest.** Have the release process assert that the
-   tag, the GitHub release, and `src.__version__` agree — a check in CI is
-   cheaper than the confusion of the last two releases. Then revisit the
-   `< 2.0.0` skip in `_warn_if_incompatible`, which currently silences the
-   warning for the users who most need it.
-3. **Add the compatibility gate** to `StoreManager.install_plugin` and
-   `.update_plugin`: refuse a plugin whose declared floor exceeds
-   `src.__version__`, and surface the reason in the store UI rather than only
-   the log. This is the single change that turns the floor from documentation
-   into a guarantee, and B6 depends on it.
-4. **Migrate the manifests** to `ledmatrix_min_version`, and reconcile them with
-   `compatible_versions` (see above — that field is the required, canonical one,
-   and the gate does not read it yet). Currently 28 plugins spell the floor both
-   ways across their `versions[]` entries, 12 use only the old spelling, and 2
-   only the new. Scope the sweep to the nine sports plugins if a 42-plugin
-   version-bump wave isn't worth it — but the `compatible_versions` half has to
-   cover every manifest the gate can refuse, or define explicit legacy handling,
-   before the gate is allowed to block anything.
-5. **Run B5 adoption** — hockey, soccer, football, then the remaining six.
-   Bundled copies stay. Byte-identical harness output per plugin, then a soak.
-6. **Only then plan B6**, with the compatibility regression test described above
-   in CI first.
-
-## How to keep this project healthy
-
-Lessons this migration paid for, worth applying beyond it:
-
-- **A version number is a promise; keep it in one place.** Three different
-  answers to "what version am I on" (tag, release, `__version__`) is what made
-  the floor untrustworthy. Assert their agreement mechanically.
-- **Advisory checks protect nobody.** If a rule matters, enforce it where the
-  action happens — the install path, not a log line the user will never read.
-  If it doesn't matter enough to enforce, don't write the rule.
-- **Prefer failures that are loud and early.** A plugin that dies at load with
-  one journal line is indistinguishable, to a user, from a plugin that was never
-  installed. Surface plugin health in the UI.
-- **Keep the two repos' rules in sync deliberately.** The sunset rule lives in
-  both this file and the plugins repo's
-  `docs/plugin-development/08-shared-sports-code.md`. When one changes, change
-  the other in the same PR — drift between them is how a contributor ends up
-  following a rule that was superseded.
-- **Measure before and after, on real hardware.** Byte-identical harness renders
-  and a device soak caught what unit tests could not. Reserve "it should be
-  fine" for things you have actually looked at.
-
-## Rules for contributors
-
-- **Promote on evidence, not intuition.** A method moves to core when every copy
-  has it and they agree on intent. Otherwise it stays in the plugins.
-- **Never add a sport name to core.** If core needs to know which sport it is,
-  the design is wrong — add an override point instead.
-- **A capability that is not opted into must not execute.** If you find yourself
-  writing `if self.<capability>_enabled` inside a base class, it belongs in a
-  mixin.
-- **Touch the view-model keys only additively.** Published skins depend on them.
-- **Every promotion lands with the characterization suite green**, and every
-  pilot adoption lands with that plugin's harness and golden suites green.

docs/TROUBLESHOOTING.md

@@ -82,70 +82,6 @@ python3 web_interface/start.py
 
 ## Common Issues by Category
 
-### Installation & Build Issues
-
-#### Step 6 fails: "Failed building wheel for rgbmatrix"
-
-**Symptoms:**
-
-```
-note: This error originates from a subprocess, and is likely not a problem with pip.
-  ERROR: Failed building wheel for rgbmatrix
-Failed to build rgbmatrix
-✗ Failed to install rpi-rgb-led-matrix Python package
-```
-
-**Cause:**
-
-Almost always the kernel's out-of-memory killer, not missing build tools. The
-`rpi-rgb-led-matrix` library compiles roughly 45 C++ translation units, two of
-them Cython-generated — a single `cc1plus` on those can peak near 800MB. The
-build system defaults to running several of those at once, which exceeds RAM on
-512MB and 1GB boards. Because the OOM killer writes nothing to pip's output, the
-failure looks like a toolchain problem, and `sudo apt install -y
-python-dev-is-python3 cmake build-essential` will report everything is already
-up to date.
-
-**How to confirm:**
-
-```bash
-dmesg -T | grep -i "out of memory"     # look for "Killed process ... (cc1plus)"
-free -h                                 # total RAM and swap
-```
-
-**Fix:**
-
-Current versions of the installer handle this automatically: they cap build
-parallelism based on available RAM and add a temporary swapfile for the build,
-removing it when the build finishes. If you are on an older checkout, or the
-temporary swapfile could not be created, either force a serial compile:
-
-```bash
-sudo ./first_time_install.sh --build-jobs 1
-```
-
-or add permanent swap and re-run the installer, which resumes at Step 6:
-
-```bash
-sudo apt install -y dphys-swapfile
-sudo sed -i 's/^#\?CONF_SWAPSIZE=.*/CONF_SWAPSIZE=2048/' /etc/dphys-swapfile
-sudo sed -i 's/^#\?CONF_MAXSWAP=.*/CONF_MAXSWAP=2048/' /etc/dphys-swapfile
-sudo dphys-swapfile swapoff && sudo dphys-swapfile setup && sudo dphys-swapfile swapon
-sudo ./first_time_install.sh
-```
-
-`CONF_MAXSWAP` matters: it defaults to 2048 and silently clamps `CONF_SWAPSIZE`,
-so setting only `CONF_SWAPSIZE` to a larger value has no effect.
-
-**Related:**
-
-- The installer needs roughly 3GB free on the card to place the swapfile. If
-  disk is tight it will say so and skip the swapfile: `sudo apt clean` first.
-- `sudo bash scripts/check_system_compatibility.sh` reports RAM and disk.
-- `sudo bash scripts/diagnose_dependencies.sh` dumps build-dependency state.
-
----
-
 ### Web Interface & Service Issues
 
 #### Service Not Running/Starting
@@ -330,8 +266,8 @@ sudo systemctl cat ledmatrix-web | grep User
 
 6. **Manually enable AP mode:**
    ```bash
-   # Via API (the WiFi blueprint is mounted under /api/v3)
-   curl -X POST http://localhost:5000/api/v3/wifi/ap/enable
+   # Via API
+   curl -X POST http://localhost:5000/api/wifi/ap/enable
 
    # Via Python
    python3 -c "
@@ -482,19 +418,19 @@ sudo systemctl cat ledmatrix-web | grep User
 
 1. **Check plugin directory exists:**
    ```bash
-   ls -ld plugin-repos/plugin-id/
+   ls -ld plugins/plugin-id/
    ```
 
 2. **Verify manifest.json:**
    ```bash
-   cat plugin-repos/plugin-id/manifest.json
+   cat plugins/plugin-id/manifest.json
    # Verify all required fields present
    ```
 
 3. **Check dependencies installed:**
    ```bash
-   if [ -f plugin-repos/plugin-id/requirements.txt ]; then
-     pip3 install --break-system-packages -r plugin-repos/plugin-id/requirements.txt
+   if [ -f plugins/plugin-id/requirements.txt ]; then
+     pip3 install --break-system-packages -r plugins/plugin-id/requirements.txt
    fi
    ```
 
@@ -507,7 +443,7 @@ sudo systemctl cat ledmatrix-web | grep User
    ```bash
    python3 -c "
    import sys
-   sys.path.insert(0, 'plugin-repos/plugin-id')
+   sys.path.insert(0, 'plugins/plugin-id')
    from manager import PluginClass
    print('Plugin imports successfully')
    "
@@ -523,18 +459,12 @@ sudo systemctl cat ledmatrix-web | grep User
 **Solutions:**
 
 1. **Manual cache clearing:**
-
-   The cache 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 easiest option is the helper script:
-
    ```bash
-   # Clear the cache with the helper script
-   sudo python3 scripts/utils/clear_cache.py
+   # Remove plugin-specific cache
+   rm -rf cache/plugin-id*
 
-   # Or remove files manually from the cache dir in use, e.g.:
-   sudo rm -rf /var/cache/ledmatrix/*
+   # Or remove all cache
+   rm -rf cache/*
 
    # Restart display
    sudo systemctl restart ledmatrix
@@ -542,8 +472,8 @@ sudo systemctl cat ledmatrix-web | grep User
 
 2. **Check cache permissions:**
    ```bash
-   ls -ld /var/cache/ledmatrix
-   sudo ./scripts/fix_perms/fix_cache_permissions.sh
+   ls -ld cache/
+   sudo chown -R ledpi:ledpi cache/
    ```
 
 ---
@@ -778,11 +708,11 @@ nmcli device status
 ```bash
 # Check file exists
 ls -l config/config.json
-ls -l plugin-repos/plugin-id/manifest.json
+ls -l plugins/plugin-id/manifest.json
 
 # Check directory structure
 ls -la web_interface/
-ls -la plugin-repos/
+ls -la plugins/
 
 # Check file permissions
 ls -l config/config_secrets.json
@@ -810,7 +740,7 @@ python3 -c "from src.wifi_manager import WiFiManager; print('OK')"
 # Test plugin import
 python3 -c "
 import sys
-sys.path.insert(0, 'plugin-repos/plugin-id')
+sys.path.insert(0, 'plugins/plugin-id')
 from manager import PluginClass
 print('Plugin imports OK')
 "
@@ -818,28 +748,39 @@ print('Plugin imports OK')
 
 ---
 
-## Reinstalling Service Files
+## Service File Template
 
-If a systemd service file is corrupted or missing, do NOT hand-write
-one. The real unit files live in the repo's `systemd/` directory
-(`ledmatrix.service`, `ledmatrix-web.service`,
-`ledmatrix-wifi-monitor.service`) and contain a
-`__PROJECT_ROOT_DIR__` placeholder that the install scripts substitute
-with your actual checkout path:
+If your systemd service file is corrupted or missing, use this template:
 
-```bash
-# Reinstall the display service unit
-sudo ./scripts/install/install_service.sh
+```ini
+[Unit]
+Description=LEDMatrix Web Interface
+After=network.target
 
-# Reinstall the web interface service unit
-sudo ./scripts/install/install_web_service.sh
+[Service]
+Type=simple
+User=ledpi
+Group=ledpi
+WorkingDirectory=/home/ledpi/LEDMatrix
+Environment="PYTHONUNBUFFERED=1"
+ExecStart=/usr/bin/python3 /home/ledpi/LEDMatrix/web_interface/start.py
+Restart=on-failure
+RestartSec=5s
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=ledmatrix-web
+
+[Install]
+WantedBy=multi-user.target
 ```
 
-Note that `ledmatrix-web.service` runs as root via
-`scripts/utils/start_web_conditionally.py` — root is needed for
-system operations (service control, WiFi management), and the wrapper
-honors the `web_display_autostart` config flag before actually
-starting the web server.
+Save to `/etc/systemd/system/ledmatrix-web.service` and run:
+
+```bash
+sudo systemctl daemon-reload
+sudo systemctl enable ledmatrix-web
+sudo systemctl start ledmatrix-web
+```
 
 ---
 
@@ -873,7 +814,7 @@ echo ""
 
 echo "5. File Structure:"
 ls -la web_interface/ | head -10
-ls -la plugin-repos/ | head -10
+ls -la plugins/ | head -10
 echo ""
 
 echo "6. Python Imports:"
@@ -949,11 +890,12 @@ sudo systemctl restart ledmatrix-web
 # Reinstall WiFi monitor
 sudo ./scripts/install/install_wifi_monitor.sh
 
-# Recreate service files (substitutes __PROJECT_ROOT_DIR__ in systemd/ units)
-sudo ./scripts/install/install_service.sh
-sudo ./scripts/install/install_web_service.sh
+# Recreate service files from templates
+sudo cp templates/ledmatrix.service /etc/systemd/system/
+sudo cp templates/ledmatrix-web.service /etc/systemd/system/
 
-# Restart
+# Reload and restart
+sudo systemctl daemon-reload
 sudo systemctl restart ledmatrix ledmatrix-web
 ```
 

docs/WEB_INTERFACE_GUIDE.md

@@ -39,18 +39,12 @@ present:
 - **WiFi** — Network selection and AP-mode setup
 - **Schedule** — Power and dim schedules
 - **Display** — Matrix hardware configuration (rows, cols, hardware
-  mapping, GPIO slowdown, brightness, PWM) and Vegas Scroll Mode
-  settings
-- **Rotation** — drag-and-drop **Rotation Order** list and per-plugin
-  **Screen Durations**
+  mapping, GPIO slowdown, brightness, PWM)
 - **Config Editor** — Raw `config.json` editor with validation
-- **Backup & Restore** — back up and restore your configuration
 - **Fonts** — Upload and manage fonts
 - **Logs** — Real-time log streaming
 - **Cache** — Cached data inspection and cleanup
 - **Operation History** — Recent service operations
-- **Tools** — system diagnostics, git & updates, Python dependencies,
-  maintenance, power supply, network radio, services, and plugin health
 
 A second nav row holds plugin tabs:
 
@@ -117,12 +111,6 @@ Configure your LED matrix hardware:
 - Dynamic Duration — global cap for plugins that extend their display
   time based on content
 
-**Vegas Scroll Mode:** the Display tab also has a full Vegas Scroll
-Mode section — enable toggle, scroll speed, separator width, dynamic
-duration, and related settings — so you can configure Vegas mode
-entirely from the web UI without hand-editing JSON. See
-[ADVANCED_FEATURES.md](ADVANCED_FEATURES.md) for what the options do.
-
 Changes require **Restart Display Service** from the Overview tab.
 
 ### Plugin Manager Tab
@@ -171,10 +159,9 @@ Manage fonts for your display:
 - See font previews
 - Check font sizes and styles
 
-**Font Overrides:**
-- Overrides are set per display *element* (e.g. a specific score or
-  clock text element), not per plugin
-- Override default font choices for individual elements
+**Plugin Font Overrides:**
+- Set custom fonts for specific plugins
+- Override default font choices
 - Preview font changes
 
 **Delete Fonts:**
@@ -196,11 +183,9 @@ View real-time system logs:
 - Filter by plugin or component
 
 **Actions:**
-- **Refresh**: Reload the log view
 - **Clear**: Clear the current view
 - **Download**: Download logs for offline analysis
-- **Auto-scroll** checkbox: toggle automatic scrolling to the latest
-  entries
+- **Pause**: Pause auto-scrolling
 
 ---
 
@@ -263,8 +248,7 @@ The web interface uses Server-Sent Events (SSE) for real-time updates:
 **Performance:**
 - Minimal bandwidth usage
 - Server-side rendering for fast load times
-- The UI is built on Alpine.js and HTMX, so JavaScript must be enabled
-  in the browser
+- Progressive enhancement - works without JavaScript
 
 ---
 
@@ -283,6 +267,17 @@ The interface is fully responsive and works on mobile devices:
 
 ---
 
+## Keyboard Shortcuts
+
+Use keyboard shortcuts for faster navigation:
+
+- **Tab**: Navigate between form fields
+- **Enter**: Submit forms
+- **Esc**: Close modals
+- **Ctrl+F**: Search in logs
+
+---
+
 ## API Access
 
 The web interface is built on a REST API that you can access programmatically:
@@ -293,7 +288,7 @@ http://your-pi-ip:5000/api/v3
 ```
 
 The API blueprint mounts at `/api/v3` (see
-`web_interface/app.py:199`). All endpoints below are relative to that
+`web_interface/app.py:144`). All endpoints below are relative to that
 base.
 
 **Common Endpoints:**

docs/widget-guide.md

@@ -206,40 +206,6 @@ To use an existing widget in your plugin's `config_schema.json`, simply add the
 
 The widget will be automatically rendered when the plugin configuration form is loaded.
 
-## Marking Fields as Advanced (`x-advanced`)
-
-Add `"x-advanced": true` to any top-level, non-object property to move it out
-of the main form and into a single collapsed **Advanced Settings** section at
-the bottom of the plugin's configuration page:
-
-```json
-{
-  "properties": {
-    "city": {
-      "type": "string",
-      "title": "City"
-    },
-    "request_timeout": {
-      "type": "integer",
-      "default": 10,
-      "description": "HTTP timeout in seconds",
-      "x-advanced": true
-    }
-  }
-}
-```
-
-Guidelines:
-
-- Use it for fine-tuning knobs most users never touch (timeouts, retry
-  behavior, cache TTLs, styling overrides). Anything a first-time user must
-  set to get the plugin working should stay basic.
-- Nothing is hidden permanently — the section expands on click, and the
-  settings search finds and auto-expands advanced fields like any others.
-- The flag is ignored on `object`-type properties (they already render as
-  their own collapsible sections) and is safely ignored by older cores, so
-  adding it never breaks compatibility.
-
 ## Creating Custom Widgets
 
 ### Step 1: Create Widget File

first_time_install.sh

@@ -152,8 +152,6 @@ ASSUME_YES=${LEDMATRIX_ASSUME_YES:-0}
 SKIP_SOUND=${LEDMATRIX_SKIP_SOUND:-0}
 SKIP_PERF=${LEDMATRIX_SKIP_PERF:-0}
 SKIP_REBOOT_PROMPT=${LEDMATRIX_SKIP_REBOOT_PROMPT:-0}
-SKIP_SWAP=${LEDMATRIX_SKIP_SWAP:-0}
-BUILD_JOBS_OVERRIDE=${LEDMATRIX_BUILD_JOBS:-}
 
 usage() {
     cat <<USAGE
@@ -165,21 +163,11 @@ Options:
       --skip-sound          Skip sound module configuration
       --skip-perf           Skip performance tweaks (isolcpus/audio)
       --no-reboot-prompt    Do not prompt for reboot at the end
-      --skip-swap           Never add temporary swap for the C++ build
-      --build-jobs N        Compile the C++ library with N parallel jobs
-                            (default: scaled to available RAM)
   -h, --help                Show this help message and exit
 
 Environment variables (same effect as flags):
   LEDMATRIX_ASSUME_YES=1, RPI_RGB_FORCE_REBUILD=1, LEDMATRIX_SKIP_SOUND=1,
-  LEDMATRIX_SKIP_PERF=1, LEDMATRIX_SKIP_REBOOT_PROMPT=1,
-  LEDMATRIX_SKIP_SWAP=1, LEDMATRIX_BUILD_JOBS=N
-
-Low-memory devices:
-  On a Pi with under 2GB of RAM the C++ build is limited to fewer parallel
-  jobs and a temporary swapfile is added for the duration of the build, then
-  removed. Without this the compiler is killed by the kernel out-of-memory
-  killer on 512MB and 1GB models.
+  LEDMATRIX_SKIP_PERF=1, LEDMATRIX_SKIP_REBOOT_PROMPT=1
 USAGE
 }
 
@@ -190,38 +178,12 @@ while [ $# -gt 0 ]; do
         --skip-sound) SKIP_SOUND=1 ;;
         --skip-perf) SKIP_PERF=1 ;;
         --no-reboot-prompt) SKIP_REBOOT_PROMPT=1 ;;
-        --skip-swap) SKIP_SWAP=1 ;;
-        --build-jobs)
-            shift
-            if [ $# -eq 0 ]; then echo "--build-jobs requires a number"; usage; exit 1; fi
-            BUILD_JOBS_OVERRIDE="$1"
-            ;;
         -h|--help) usage; exit 0 ;;
         *) echo "Unknown option: $1"; usage; exit 1 ;;
     esac
     shift
 done
 
-# Low-memory build helpers (job sizing, temporary swap, OOM detection).
-# Sourced rather than inlined so the sizing logic can be unit-tested; if the
-# file is missing we fall back to the historical behaviour rather than failing
-# the install.
-LOWMEM_LIB="$PROJECT_ROOT_DIR/scripts/install/lib_lowmem.sh"
-LOWMEM_AVAILABLE=0
-if [ -f "$LOWMEM_LIB" ]; then
-    # shellcheck source=scripts/install/lib_lowmem.sh
-    . "$LOWMEM_LIB"
-    LOWMEM_AVAILABLE=1
-else
-    echo "⚠ $LOWMEM_LIB not found; skipping low-memory build protections."
-    lm_remove_build_swap() { return 0; }
-fi
-
-# Remove the temporary build swapfile no matter how the script ends. Step 6
-# tears it down itself; this is the backstop for the error path, since
-# on_error ends in `exit` and EXIT traps still run.
-trap 'lm_remove_build_swap' EXIT
-
 # Helpers
 retry() {
     local attempt=1
@@ -301,144 +263,15 @@ check_disk_space() {
     fi
 }
 
-# Decide how much memory Step 6's C++ build may use, and say so up front.
-#
-# Sets TOTAL_RAM_MB, TOTAL_SWAP_MB, BUILD_JOBS and LOW_RAM for later steps.
-check_memory() {
-    command -v nproc >/dev/null 2>&1 && CPU_CORES=$(nproc) || CPU_CORES=1
-
-    # Validated up front rather than trusted: a non-numeric value would other-
-    # wise survive as far as an arithmetic test in Step 6 and fail there with a
-    # generic error. This must precede the fallback return below, which also
-    # honours the override.
-    if [ -n "$BUILD_JOBS_OVERRIDE" ]; then
-        if ! echo "$BUILD_JOBS_OVERRIDE" | grep -qE '^[1-9][0-9]*$'; then
-            echo "✗ Invalid build job count: '$BUILD_JOBS_OVERRIDE' (expected a positive integer)"
-            exit 1
-        fi
-    fi
-
-    if [ "$LOWMEM_AVAILABLE" != "1" ]; then
-        TOTAL_RAM_MB=0
-        TOTAL_SWAP_MB=0
-        LOW_RAM=0
-        BUILD_JOBS=${BUILD_JOBS_OVERRIDE:-$CPU_CORES}
-        return 0
-    fi
-
-    TOTAL_RAM_MB=$(lm_total_ram_mb)
-    TOTAL_SWAP_MB=$(lm_total_swap_mb)
-
-    # Test hook: exercise the low-memory path on a machine that has plenty.
-    if [ -n "${LEDMATRIX_FORCE_LOW_RAM:-}" ] && [ "${LEDMATRIX_FORCE_LOW_RAM}" != "0" ]; then
-        TOTAL_RAM_MB="${LEDMATRIX_FORCE_LOW_RAM}"
-        echo "⚠ LEDMATRIX_FORCE_LOW_RAM set: pretending this device has ${TOTAL_RAM_MB}MB of RAM"
-    fi
-
-    LOW_RAM=0
-    if [ "$TOTAL_RAM_MB" -gt 0 ] && [ "$TOTAL_RAM_MB" -lt 2048 ]; then
-        LOW_RAM=1
-    fi
-
-    if [ -n "$BUILD_JOBS_OVERRIDE" ]; then
-        BUILD_JOBS="$BUILD_JOBS_OVERRIDE"
-    else
-        BUILD_JOBS=$(lm_build_jobs "$TOTAL_RAM_MB" "$CPU_CORES")
-    fi
-
-    echo "System memory: ${TOTAL_RAM_MB}MB RAM, ${TOTAL_SWAP_MB}MB swap, ${CPU_CORES} core(s)"
-    if [ "$LOW_RAM" = "1" ]; then
-        echo "⚠ Low-memory device detected."
-        echo "  The rpi-rgb-led-matrix C++ build in Step 6 will use ${BUILD_JOBS} parallel job(s)"
-        echo "  instead of all cores, and a temporary swapfile will be added for the build"
-        echo "  and removed afterwards. Without this the compiler is killed by the kernel"
-        echo "  out-of-memory killer. Expect Step 6 to take 15-25 minutes."
-        if [ "$SKIP_SWAP" = "1" ]; then
-            echo "  Temporary swap is disabled (--skip-swap); the build may still run out of memory."
-        fi
-    else
-        echo "✓ Memory sufficient for the rpi-rgb-led-matrix build (${BUILD_JOBS} parallel job(s))"
-    fi
-}
-
-# Compile and install the rgbmatrix Python package.
-#
-# CMAKE_BUILD_PARALLEL_LEVEL is the setting that actually caps the compile:
-# upstream's pyproject.toml declares no [tool.scikit-build] options, so
-# scikit-build-core drives Ninja through `cmake --build`, which reads this
-# variable. Ninja's own default is nproc+2, i.e. six concurrent cc1plus
-# processes on a 4-core Pi. MAKEFLAGS is ignored by Ninja and is set only to
-# cover the Makefile-generator fallback if ninja-build is somehow absent.
-#
-# BUILD_TMPDIR redirects pip's build tree off tmpfs where applicable — see
-# where it is computed in Step 6.
-run_rgbmatrix_build() {
-    local jobs="$1" out="$2"
-    local pid elapsed=0
-
-    TMPDIR="${BUILD_TMPDIR:-${TMPDIR:-/tmp}}" \
-    CMAKE_BUILD_PARALLEL_LEVEL="$jobs" \
-    MAKEFLAGS="-j${jobs}" \
-        python3 -m pip install --break-system-packages . > "$out" 2>&1 &
-    pid=$!
-
-    # The build's output is captured to a file, so without a heartbeat a serial
-    # compile on a 1GB Pi looks like a 20-minute hang and invites a Ctrl-C.
-    #
-    # Polled at a short interval but reported every 30s: polling at the report
-    # interval instead would add most of that interval to the wall time of
-    # every build, including fast ones on a Pi 4/5.
-    while kill -0 "$pid" 2>/dev/null; do
-        sleep 2
-        elapsed=$((elapsed + 2))
-        if [ "$((elapsed % 30))" -eq 0 ] && kill -0 "$pid" 2>/dev/null; then
-            printf '  ... still compiling (%dm%02ds elapsed)\n' "$((elapsed / 60))" "$((elapsed % 60))"
-        fi
-    done
-
-    wait "$pid"
-}
-
-# Explain a failed rgbmatrix build. The kernel OOM killer writes nothing to the
-# build's own output, which is why this used to be reported as a missing
-# build-tools problem and sent users chasing packages they already had.
-print_rgbmatrix_build_failure() {
-    local out="$1"
-
-    if [ "$LOWMEM_AVAILABLE" = "1" ] && lm_build_failed_on_oom "$out"; then
-        echo "✗ The rpi-rgb-led-matrix build was killed: the system ran out of memory."
-        echo "  This is NOT a missing build-tools problem — the C++ compiler ran out of RAM."
-        echo "  RAM: ${TOTAL_RAM_MB}MB   Swap: $(lm_total_swap_mb)MB   Parallel jobs used: ${BUILD_JOBS}"
-        if [ -n "${LM_SWAP_SKIP_REASON:-}" ]; then
-            echo "  No temporary swap was added: ${LM_SWAP_SKIP_REASON}"
-        fi
-        echo ""
-        echo "  Try one of these, then re-run this script (it resumes at Step 6):"
-        echo "    1. Force a single compile job:"
-        echo "       sudo ./first_time_install.sh --build-jobs 1"
-        echo "    2. Add permanent swap, if the temporary swapfile could not be created:"
-        echo "       sudo apt install -y dphys-swapfile"
-        echo "       sudo sed -i 's/^#\\?CONF_SWAPSIZE=.*/CONF_SWAPSIZE=2048/' /etc/dphys-swapfile"
-        echo "       sudo sed -i 's/^#\\?CONF_MAXSWAP=.*/CONF_MAXSWAP=2048/' /etc/dphys-swapfile"
-        echo "       sudo dphys-swapfile swapoff && sudo dphys-swapfile setup && sudo dphys-swapfile swapon"
-        echo "    3. Free up disk space so a larger swapfile fits: sudo apt clean"
-    else
-        echo "✗ Failed to install rpi-rgb-led-matrix Python package"
-        echo "  Ensure build tools are installed:"
-        echo "  sudo apt install -y python-dev-is-python3 cmake build-essential"
-    fi
-}
-
 echo ""
 echo "This script will perform the following steps:"
-echo "1. Check prerequisites (network, disk, memory) and install system dependencies"
+echo "1. Install system dependencies"
 echo "2. Fix cache permissions"
 echo "3. Fix assets directory permissions"
 echo "3.1. Fix plugin directory permissions"
 echo "4. Ensure configuration files exist"
 echo "5. Install Python project dependencies (requirements.txt)"
 echo "6. Build and install rpi-rgb-led-matrix and test import"
-echo "   (compiles C++; low-memory Pis get temporary swap and a serial build)"
 echo "7. Install web interface dependencies"
 echo "7.5. Install main LED Matrix service"
 echo "8. Install web interface service"
@@ -482,16 +315,9 @@ echo "----------------------------------------"
 # Pre-flight checks before APT operations
 check_network
 check_disk_space
-check_memory
 
-# Update package list. The one-shot installer refreshes the lists moments
-# before invoking this script and exports LEDMATRIX_APT_UPDATED=1, so skip the
-# duplicate refresh on that path.
-if [ "${LEDMATRIX_APT_UPDATED:-0}" = "1" ]; then
-    echo "Package lists already refreshed by the one-shot installer; skipping apt update."
-else
-    apt_update
-fi
+# Update package list
+apt_update
 
 # Install required system packages
 echo "Installing Python packages and dependencies..."
@@ -821,6 +647,10 @@ if [ ! -f "$PROJECT_ROOT_DIR/config/config_secrets.json" ]; then
         echo "⚠ Template config/config_secrets.template.json not found; creating a minimal secrets file"
         cat > "$PROJECT_ROOT_DIR/config/config_secrets.json" <<'EOF'
 {
+    "youtube": {
+        "api_key": "YOUR_YOUTUBE_API_KEY",
+        "channel_id": "YOUR_YOUTUBE_CHANNEL_ID"
+    },
     "github": {
         "api_token": "YOUR_GITHUB_PERSONAL_ACCESS_TOKEN"
     }
@@ -896,11 +726,7 @@ if [ -f "$PROJECT_ROOT_DIR/requirements.txt" ]; then
         
         if command -v timeout >/dev/null 2>&1; then
             # Use timeout if available (10 minutes = 600 seconds)
-            # --ignore-installed: apt-managed packages (e.g. python3-requests)
-            # ship no pip RECORD file, so upgrading them would otherwise abort
-            # with "uninstall-no-record-file"; this lays the new version down
-            # alongside instead of trying to uninstall the apt copy first.
-            if timeout 600 python3 -m pip install --break-system-packages --no-cache-dir --prefer-binary --ignore-installed --verbose "$line" > "$INSTALL_OUTPUT" 2>&1; then
+            if timeout 600 python3 -m pip install --break-system-packages --no-cache-dir --prefer-binary --verbose "$line" > "$INSTALL_OUTPUT" 2>&1; then
                 INSTALL_SUCCESS=true
             else
                 EXIT_CODE=$?
@@ -908,7 +734,7 @@ if [ -f "$PROJECT_ROOT_DIR/requirements.txt" ]; then
                     echo "✗ Timeout (10 minutes) installing: $line"
                     echo "  This package may require building from source, which can be slow on Raspberry Pi."
                     echo "  You can try installing it manually later with:"
-                    echo "    python3 -m pip install --break-system-packages --no-cache-dir --prefer-binary --ignore-installed --verbose '$line'"
+                    echo "    python3 -m pip install --break-system-packages --no-cache-dir --prefer-binary --verbose '$line'"
                 else
                     echo "✗ Failed to install: $line (exit code: $EXIT_CODE)"
                 fi
@@ -916,7 +742,7 @@ if [ -f "$PROJECT_ROOT_DIR/requirements.txt" ]; then
         else
             # No timeout command available, install without timeout
             echo "  Note: timeout command not available, installation may take a while..."
-            if python3 -m pip install --break-system-packages --no-cache-dir --prefer-binary --ignore-installed --verbose "$line" > "$INSTALL_OUTPUT" 2>&1; then
+            if python3 -m pip install --break-system-packages --no-cache-dir --prefer-binary --verbose "$line" > "$INSTALL_OUTPUT" 2>&1; then
                 INSTALL_SUCCESS=true
             else
                 EXIT_CODE=$?
@@ -968,7 +794,7 @@ if [ -f "$PROJECT_ROOT_DIR/requirements.txt" ]; then
         echo "  1. Ensure you have enough disk space: df -h"
         echo "  2. Check available memory: free -h"
         echo "  3. Try installing failed packages individually with verbose output:"
-        echo "     python3 -m pip install --break-system-packages --no-cache-dir --prefer-binary --ignore-installed --verbose <package>"
+        echo "     python3 -m pip install --break-system-packages --no-cache-dir --prefer-binary --verbose <package>"
         echo "  4. For packages that build from source (like numpy), consider:"
         echo "     - Installing pre-built wheels: python3 -m pip install --only-binary :all: <package>"
         echo "     - Or installing via apt if available: sudo apt install python3-<package>"
@@ -990,10 +816,7 @@ echo ""
 # Install web interface dependencies
 echo "Installing web interface dependencies..."
 if [ -f "$PROJECT_ROOT_DIR/web_interface/requirements.txt" ]; then
-    # --ignore-installed: apt-managed packages (e.g. python3-requests) ship no
-    # pip RECORD file, so upgrading them to the version pinned here would
-    # otherwise abort the whole install with "uninstall-no-record-file".
-    if python3 -m pip install --break-system-packages --prefer-binary --ignore-installed -r "$PROJECT_ROOT_DIR/web_interface/requirements.txt"; then
+    if python3 -m pip install --break-system-packages --prefer-binary -r "$PROJECT_ROOT_DIR/web_interface/requirements.txt"; then
         echo "✓ Web interface dependencies installed"
         # Create marker file to indicate dependencies are installed
         touch "$PROJECT_ROOT_DIR/.web_deps_installed"
@@ -1072,66 +895,29 @@ else
             fi
         fi
 
-        # Add temporary swap on low-memory devices so the compiler survives.
-        CURRENT_STEP="Prepare the low-memory build environment"
-        if [ "$LOWMEM_AVAILABLE" = "1" ] && [ "$SKIP_SWAP" != "1" ]; then
-            lm_ensure_build_swap "$(lm_swap_needed_mb "$TOTAL_RAM_MB" "$TOTAL_SWAP_MB")"
-        elif [ "$SKIP_SWAP" = "1" ]; then
-            LM_SWAP_SKIP_REASON="disabled with --skip-swap"
-        fi
-
-        # pip builds in $TMPDIR. Debian 13 mounts /tmp as tmpfs, so the default
-        # would hold the entire C++ build tree in RAM — competing with the very
-        # compiler we are trying to keep under the memory limit.
-        BUILD_TMPDIR=""
-        if [ "$LOWMEM_AVAILABLE" = "1" ]; then
-            _disk_tmp=$(lm_disk_backed_tmpdir)
-            if [ -n "$_disk_tmp" ]; then
-                BUILD_TMPDIR="$_disk_tmp/ledmatrix-build"
-                # If this fails (a nearly-full disk being the likely cause on
-                # exactly the devices this targets), fall back to the default
-                # rather than pointing the build at a path that does not exist.
-                if mkdir -p "$BUILD_TMPDIR" 2>/dev/null; then
-                    echo "Building in $BUILD_TMPDIR (TMPDIR is memory-backed; keeping the build tree on disk)"
-                else
-                    echo "⚠ Could not create $BUILD_TMPDIR; falling back to the default TMPDIR"
-                    BUILD_TMPDIR=""
-                fi
-            fi
-        fi
-
-        CURRENT_STEP="Build and install rpi-rgb-led-matrix"
         pushd "$PROJECT_ROOT_DIR/rpi-rgb-led-matrix-master" >/dev/null
         echo "Installing rpi-rgb-led-matrix Python package (scikit-build-core + cmake)..."
         echo "  Build deps required: python-dev-is-python3 cmake"
-        echo "  Compiling C++ with ${BUILD_JOBS} parallel job(s)..."
-        if [ "$BUILD_JOBS" -le 1 ]; then
-            echo "  Deliberately serial to stay within this device's memory — expect 15-25 minutes."
-        else
-            echo "  This may take 2-5 minutes on a Pi 4/5..."
-        fi
+        echo "  This compiles C++ — may take 2-5 minutes on Pi 4/5..."
         BUILD_OUTPUT=$(mktemp)
         BUILD_SUCCESS=false
-        if run_rgbmatrix_build "$BUILD_JOBS" "$BUILD_OUTPUT"; then
+        if python3 -m pip install --break-system-packages . > "$BUILD_OUTPUT" 2>&1; then
             BUILD_SUCCESS=true
         fi
         cat "$BUILD_OUTPUT" >> "$LOG_FILE"
         if [ "$BUILD_SUCCESS" != true ]; then
-            print_rgbmatrix_build_failure "$BUILD_OUTPUT"
+            echo "✗ Failed to install rpi-rgb-led-matrix Python package"
+            echo "  Ensure build tools are installed:"
+            echo "  sudo apt install -y python-dev-is-python3 cmake build-essential"
             echo ""
             echo "-- Last 50 lines of build output --"
             tail -n 50 "$BUILD_OUTPUT"
             rm -f "$BUILD_OUTPUT"
-            if [ -n "$BUILD_TMPDIR" ]; then rm -rf "$BUILD_TMPDIR"; fi
             popd >/dev/null
-            lm_remove_build_swap
             exit 1
         fi
         rm -f "$BUILD_OUTPUT"
-        if [ -n "$BUILD_TMPDIR" ]; then rm -rf "$BUILD_TMPDIR"; fi
         popd >/dev/null
-        # Hand the memory back well before Step 14's reboot.
-        lm_remove_build_swap
     else
         echo "✗ rpi-rgb-led-matrix-master directory not found at $PROJECT_ROOT_DIR"
         echo "Failed to initialize submodule or clone repository"
@@ -1189,7 +975,12 @@ else
         # real time and in order relative to this script's own echo statements
         python3 -u "$PROJECT_ROOT_DIR/scripts/install_dependencies_apt.py"
     else
-        echo "Web dependencies already installed from web_interface/requirements.txt in Step 5"
+        echo "Using pip to install dependencies..."
+        if [ -f "$PROJECT_ROOT_DIR/requirements_web_v2.txt" ]; then
+            python3 -m pip install --break-system-packages --prefer-binary -r requirements_web_v2.txt
+        else
+            echo "⚠ requirements_web_v2.txt not found; skipping web dependency install"
+        fi
     fi
 
     # Create marker file to indicate dependencies are installed

requirements-test.txt

@@ -1,7 +1,9 @@
-# Test/dev-only dependencies (not needed on a running display).
+# Test-only dependencies for the plugin safety harness and pytest suite.
 # Install alongside requirements.txt:  pip install -r requirements.txt -r requirements-test.txt
-pytest>=9.0.3,<10.0.0
-pytest-cov>=4.1.0,<5.0.0
-pytest-mock>=3.11.0,<4.0.0
+#
+# pytest, pytest-cov, pytest-mock, and jsonschema are already pinned (with
+# major-version caps) in requirements.txt, so they are intentionally NOT
+# repeated here — re-pinning pytest to <9 collided with requirements.txt's
+# pytest>=9.0.3,<10 and made the two files impossible to install together.
+# Only declare what requirements.txt doesn't already provide.
 freezegun>=1.2,<2        # deterministic time for golden-image tests
-mypy>=1.5.0,<2.0.0       # static type checking (also pinned in .pre-commit-config.yaml)

requirements.txt

@@ -8,34 +8,46 @@ numpy>=1.24.0  # For fast array operations in ScrollHelper (compatible with 2.x)
 
 # Timezone handling
 pytz>=2024.2,<2025.0  # Updated for latest timezone data
+timezonefinder>=6.5.0,<7.0.0  # Updated for better performance and accuracy
+geopy>=2.4.1,<3.0.0
 
 # HTTP requests
 requests>=2.33.0,<3.0.0
-urllib3>=1.26.0,<3.0.0  # requests transitive, but imported directly (urllib3.util.retry.Retry)
 
 # Google API integration
+google-auth-oauthlib>=1.2.0,<2.0.0
+google-auth-httplib2>=0.2.0,<1.0.0
+google-api-python-client>=2.147.0,<3.0.0
 
 # Font rendering
 freetype-py>=2.5.1,<3.0.0
 
-# Spotify integration (used by web_interface/blueprints/api_v3.py OAuth endpoints)
+# Spotify integration
 spotipy>=2.25.2,<3.0.0
 
 # Flask web framework
 Flask>=3.1.3,<4.0.0
 
-# WebSocket support: intentionally NOT declared here. Plugins that need
-# it (e.g. ledmatrix-music's Socket.IO client) declare it in their own
-# requirements.txt, which the plugin store installs.
+# Text processing
+unidecode>=1.3.8,<2.0.0
+
+# Calendar integration
+icalevents>=0.1.27,<1.0.0
+
+# WebSocket support
+python-socketio>=5.14.0,<6.0.0
+python-engineio>=4.9.0,<5.0.0
+websockets>=12.0,<14.0
+websocket-client>=1.8.0,<2.0.0
 
 # JSON Schema validation
 jsonschema>=4.20.0,<5.0.0
 
-# Requirement specifier parsing (plugin dependency satisfaction checks)
-packaging>=23.0,<27.0
-
-# Testing dependencies live in requirements-test.txt:
-#   pip install -r requirements.txt -r requirements-test.txt
+# Testing dependencies
+pytest>=9.0.3,<10.0.0
+pytest-cov>=4.1.0,<5.0.0
+pytest-mock>=3.11.0,<4.0.0
+mypy>=1.5.0,<2.0.0
 
 # ───────────────────────────────────────────────────────────────────────
 # Optional dependencies — the code imports these inside try/except
@@ -51,9 +63,7 @@ packaging>=23.0,<27.0
 # psutil            — per-plugin resource monitoring in
 #                     src/plugin_system/resource_monitor.py. The monitor
 #                     silently no-ops when missing (PSUTIL_AVAILABLE = False).
-#                     Note: web_interface/requirements.txt requires this
-#                     range as a hard dependency — keep the two in sync.
-#   pip install 'psutil>=6.0.0,<7.0.0'
+#   pip install 'psutil>=5.9.0,<6.0.0'
 #
 # Flask-Limiter     — request rate limiting in web_interface/app.py
 #                     (accidental-abuse protection, not security). The

schema/manifest_schema.json

@@ -90,40 +90,11 @@
             "min_height": {
               "type": "integer",
               "minimum": 1
-            },
-            "max_width": {
-              "type": "integer",
-              "minimum": 1
-            },
-            "max_height": {
-              "type": "integer",
-              "minimum": 1
             }
           }
         }
       }
     },
-    "display": {
-      "type": "object",
-      "properties": {
-        "design_size": {
-          "type": "object",
-          "properties": {
-            "width": {
-              "type": "integer",
-              "minimum": 8
-            },
-            "height": {
-              "type": "integer",
-              "minimum": 8
-            }
-          },
-          "required": ["width", "height"],
-          "description": "Panel size the plugin's layout was authored against; core derives the adaptive-layout scale factor from it. Defaults to 128x32 when omitted."
-        }
-      },
-      "description": "Display/layout hints for the adaptive layout system"
-    },
     "config_schema": {
       "type": "string",
       "description": "Path to configuration schema file"

scripts/add_defaults_to_schemas.py

@@ -201,7 +201,7 @@ def process_schema_file(schema_path: Path) -> bool:
 def main():
     """Main entry point."""
     project_root = Path(__file__).parent.parent
-    plugins_dir = project_root / 'plugin-repos'
+    plugins_dir = project_root / 'plugins'
     
     if not plugins_dir.exists():
         print(f"Error: Plugins directory not found: {plugins_dir}")

scripts/analyze_plugin_schemas.py

@@ -193,7 +193,7 @@ def analyze_schema(schema_path: Path) -> Dict[str, Any]:
 def main():
     """Main analysis function."""
     project_root = Path(__file__).parent.parent
-    plugins_dir = project_root / "plugin-repos"
+    plugins_dir = project_root / "plugins"
     
     if not plugins_dir.exists():
         print(f"Plugins directory not found: {plugins_dir}")

scripts/audit_plugins.py

@@ -1,344 +0,0 @@
-#!/usr/bin/env python3
-"""
-LEDMatrix Plugin Security Auditor
-
-Performs AST-based security analysis of all Python files in plugin directories.
-Designed to run in CI — exits non-zero on CRITICAL findings only.
-
-Usage:
-    python scripts/audit_plugins.py
-    python scripts/audit_plugins.py --verbose
-    python scripts/audit_plugins.py --plugin hello-world
-    python scripts/audit_plugins.py --output results.json
-"""
-
-import ast
-import argparse
-import json
-import sys
-from dataclasses import dataclass, asdict
-from pathlib import Path
-from datetime import datetime, timezone
-
-PROJECT_ROOT = Path(__file__).resolve().parent.parent
-
-PLUGIN_BASE_DIRS = [
-    PROJECT_ROOT / "plugins",
-    PROJECT_ROOT / "plugin-repos",
-]
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Finding dataclass
-# ─────────────────────────────────────────────────────────────────────────────
-
-@dataclass
-class Finding:
-    plugin_id: str
-    file: str
-    line: int
-    severity: str   # CRITICAL | WARNING | INFO
-    rule: str
-    message: str
-
-    def to_dict(self) -> dict:
-        return asdict(self)
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# AST visitor
-# ─────────────────────────────────────────────────────────────────────────────
-
-class _PluginVisitor(ast.NodeVisitor):
-    """Collect security findings from a single plugin Python file."""
-
-    def __init__(self, filepath: Path, plugin_id: str):
-        self.filepath = filepath
-        self.plugin_id = plugin_id
-        self.findings: list[Finding] = []
-        # Local name -> real dotted path, so aliased imports and from-imports
-        # of dangerous APIs (import subprocess as sp; from builtins import
-        # eval as e) are still recognized in visit_Call below.
-        self._aliases: dict[str, str] = {}
-
-    def _add(self, node: ast.AST, severity: str, rule: str, message: str) -> None:
-        self.findings.append(Finding(
-            plugin_id=self.plugin_id,
-            file=str(self.filepath.relative_to(PROJECT_ROOT)),
-            line=getattr(node, "lineno", 0),
-            severity=severity,
-            rule=rule,
-            message=message,
-        ))
-
-    def _resolve(self, local_name: str) -> str:
-        """Resolve a local name through recorded import aliases to its real
-        dotted path (e.g. "sp" -> "subprocess"); unresolved names pass through
-        unchanged."""
-        return self._aliases.get(local_name, local_name)
-
-    def _resolve_call_target(self, func: ast.expr) -> str | None:
-        """Resolve a Call's func node to a fully-qualified dotted target,
-        covering a direct name (bare builtin, aliased import, or
-        from-import: from builtins import eval as e; from subprocess
-        import run; from os import system as s) and module-attribute
-        access (subprocess.run, sp.run, os.system, o.system) uniformly.
-        Returns None for call shapes this doesn't attempt to resolve."""
-        if isinstance(func, ast.Name):
-            return self._resolve(func.id)
-        if isinstance(func, ast.Attribute) and isinstance(func.value, ast.Name):
-            base = self._resolve(func.value.id)
-            return f"{base}.{func.attr}"
-        return None
-
-    def visit_Call(self, node: ast.Call) -> None:
-        target = self._resolve_call_target(node.func)
-        if target is None:
-            self.generic_visit(node)
-            return
-
-        leaf = target.rsplit(".", 1)[-1]
-
-        # eval() / exec() / compile() — arbitrary code execution, whether a
-        # bare call, an aliased import, or a from-import
-        # (from builtins import eval as e; e(...))
-        if leaf == "eval":
-            self._add(node, "CRITICAL", "PLUGIN-001",
-                      "eval() call — arbitrary code execution risk")
-        elif leaf == "exec":
-            self._add(node, "CRITICAL", "PLUGIN-002",
-                      "exec() call — arbitrary code execution risk")
-        elif leaf == "compile":
-            self._add(node, "WARNING", "PLUGIN-003",
-                      "compile() call — dynamic code compilation")
-
-        # subprocess.*(shell=True), whether subprocess.run(...), sp.run(...),
-        # or a from-import (from subprocess import run; run(..., shell=True))
-        if target in {
-            "subprocess.run", "subprocess.call", "subprocess.Popen",
-            "subprocess.check_call", "subprocess.check_output",
-        }:
-            for kw in node.keywords:
-                if (kw.arg == "shell" and
-                        isinstance(kw.value, ast.Constant) and
-                        kw.value.value is True):
-                    self._add(node, "WARNING", "PLUGIN-004",
-                              f"subprocess.{leaf}(shell=True) — "
-                              f"shell injection risk if args include user input")
-
-        # os.system(), whether os.system(...), o.system(...), or a
-        # from-import (from os import system as s; s(...))
-        if target == "os.system":
-            self._add(node, "WARNING", "PLUGIN-005",
-                      "os.system() call — prefer subprocess with list args")
-
-        self.generic_visit(node)
-
-    def visit_Import(self, node: ast.Import) -> None:
-        for alias in node.names:
-            if alias.asname:
-                local, real = alias.asname, alias.name
-            else:
-                # `import os.path` binds the top-level name `os`, not `os.path`
-                local = real = alias.name.split(".")[0]
-            self._aliases[local] = real
-            self._check_import(node, alias.name)
-        self.generic_visit(node)
-
-    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
-        if node.module:
-            for alias in node.names:
-                local = alias.asname or alias.name
-                self._aliases[local] = f"{node.module}.{alias.name}"
-            self._check_import(node, node.module)
-        self.generic_visit(node)
-
-    def _check_import(self, node: ast.AST, module_name: str) -> None:
-        dangerous = {
-            "ctypes": ("WARNING", "PLUGIN-010", "ctypes import — native code execution"),
-            "cffi": ("WARNING", "PLUGIN-011", "cffi import — native code execution"),
-            "pickle": ("WARNING", "PLUGIN-012",
-                       "pickle import — deserialization can execute arbitrary code"),
-            "marshal": ("WARNING", "PLUGIN-013",
-                        "marshal import — deserialization risk"),
-        }
-        for mod, (severity, rule, msg) in dangerous.items():
-            if module_name == mod or module_name.startswith(mod + "."):
-                self._add(node, severity, rule, msg)
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Per-plugin audit
-# ─────────────────────────────────────────────────────────────────────────────
-
-def audit_plugin(plugin_dir: Path) -> list[Finding]:
-    """Audit a single plugin directory. Returns all findings."""
-    findings: list[Finding] = []
-    plugin_id = plugin_dir.name
-
-    # Check for required files
-    for required_file, rule, msg in [
-        ("manifest.json", "PLUGIN-020",
-         "manifest.json missing — plugin may be incomplete"),
-        ("config_schema.json", "PLUGIN-021",
-         "config_schema.json missing — no input validation schema declared"),
-    ]:
-        if not (plugin_dir / required_file).exists():
-            findings.append(Finding(
-                plugin_id=plugin_id,
-                file=str((plugin_dir / required_file).relative_to(PROJECT_ROOT)),
-                line=0,
-                severity="WARNING",
-                rule=rule,
-                message=msg,
-            ))
-
-    # AST analysis of all Python files
-    for py_file in sorted(plugin_dir.rglob("*.py")):
-        try:
-            source = py_file.read_text(encoding="utf-8")
-            tree = ast.parse(source, filename=str(py_file))
-            visitor = _PluginVisitor(py_file, plugin_id)
-            visitor.visit(tree)
-            findings.extend(visitor.findings)
-        except SyntaxError as exc:
-            # A file the visitor can't even parse is a file we can't verify
-            # is safe -- this must block the audit, not just warn.
-            findings.append(Finding(
-                plugin_id=plugin_id,
-                file=str(py_file.relative_to(PROJECT_ROOT)),
-                line=getattr(exc, "lineno", 0) or 0,
-                severity="CRITICAL",
-                rule="PLUGIN-030",
-                message=f"Python syntax error — cannot be parsed: {exc}",
-            ))
-        except OSError as exc:
-            # Same reasoning as SyntaxError: an unreadable file was never
-            # actually scanned, so it must block rather than pass silently.
-            findings.append(Finding(
-                plugin_id=plugin_id,
-                file=str(py_file.relative_to(PROJECT_ROOT)),
-                line=0,
-                severity="CRITICAL",
-                rule="PLUGIN-031",
-                message=f"Could not read file: {exc}",
-            ))
-
-    return findings
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Main
-# ─────────────────────────────────────────────────────────────────────────────
-
-def main() -> int:
-    parser = argparse.ArgumentParser(
-        description="LEDMatrix plugin security auditor",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    parser.add_argument("--plugin", "-p", default=None,
-                        help="Audit a specific plugin ID only")
-    parser.add_argument("--output", "-o", default=None,
-                        help="Write JSON results to this file")
-    parser.add_argument("--verbose", "-v", action="store_true",
-                        help="Show all findings, not just summary")
-    args = parser.parse_args()
-
-    print("=" * 60)
-    print("LEDMatrix Plugin Security Audit")
-    print(f"Project root: {PROJECT_ROOT}")
-    print("=" * 60)
-
-    all_findings: list[Finding] = []
-    plugins_scanned = 0
-    plugin_found = args.plugin is None
-
-    for base_dir in PLUGIN_BASE_DIRS:
-        if not base_dir.exists():
-            if args.verbose:
-                print(f"  ⏭️  Skipping {base_dir.name}/ (directory not found)")
-            continue
-
-        base_label = base_dir.relative_to(PROJECT_ROOT)
-        print(f"\n  Scanning {base_label}/")
-
-        for plugin_dir in sorted(base_dir.iterdir()):
-            if not plugin_dir.is_dir():
-                continue
-            if plugin_dir.name.startswith((".", "_")):
-                continue
-            if args.plugin and plugin_dir.name != args.plugin:
-                continue
-            if args.plugin:
-                plugin_found = True
-
-            findings = audit_plugin(plugin_dir)
-            all_findings.extend(findings)
-            plugins_scanned += 1
-
-            critical = [f for f in findings if f.severity == "CRITICAL"]
-            warnings = [f for f in findings if f.severity == "WARNING"]
-
-            if critical:
-                icon, label = "🚨", "CRITICAL"
-            elif warnings:
-                icon, label = "⚠️ ", "WARN   "
-            else:
-                icon, label = "✅", "PASS   "
-
-            print(f"    {icon} [{label}] {plugin_dir.name}"
-                  f" — {len(critical)} critical, {len(warnings)} warnings")
-
-            if args.verbose:
-                for f in findings:
-                    severity_icon = {"CRITICAL": "🚨", "WARNING": "⚠️ ", "INFO": "ℹ️ "}.get(
-                        f.severity, "  "
-                    )
-                    print(f"           {severity_icon} {f.rule} {f.file}:{f.line} — {f.message}")
-
-    if args.plugin and not plugin_found:
-        print(f"\n  🚨 Plugin '{args.plugin}' not found in any of "
-              f"{[str(d.relative_to(PROJECT_ROOT)) for d in PLUGIN_BASE_DIRS]} — "
-              f"nothing was audited")
-        return 1
-
-    # Summary
-    critical_findings = [f for f in all_findings if f.severity == "CRITICAL"]
-    warning_findings = [f for f in all_findings if f.severity == "WARNING"]
-
-    print(f"\n{'=' * 60}")
-    print(f"  Plugins scanned : {plugins_scanned}")
-    print(f"  CRITICAL        : {len(critical_findings)}")
-    print(f"  WARNING         : {len(warning_findings)}")
-
-    if critical_findings:
-        print("\n  🚨 CRITICAL findings:")
-        for f in critical_findings:
-            print(f"    {f.plugin_id} | {Path(f.file).name}:{f.line} | {f.message}")
-
-    # Write JSON output
-    if args.output:
-        output_data = {
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "plugins_scanned": plugins_scanned,
-            "summary": {
-                "critical": len(critical_findings),
-                "warnings": len(warning_findings),
-            },
-            "findings": [f.to_dict() for f in all_findings],
-        }
-        Path(args.output).write_text(
-            json.dumps(output_data, indent=2), encoding="utf-8"
-        )
-        print(f"\n  Results written to: {args.output}")
-
-    if critical_findings:
-        print("\n  🚨 Blocking — CRITICAL issues must be resolved")
-        return 1
-
-    print("\n  ✅ No critical issues found")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

scripts/check_plugin.py

@@ -37,11 +37,10 @@ os.environ['EMULATOR'] = 'true'
 
 from src.logging_config import get_logger  # noqa: E402
 from src.plugin_system.testing.loading import (  # noqa: E402
-    build_full_config, find_plugin_dir, load_harness_spec, load_manifest,
+    find_plugin_dir, load_config_defaults, load_harness_spec,
 )
 from src.plugin_system.testing.harness import (  # noqa: E402
     RenderResult, render_plugin_matrix, compare_to_goldens, write_goldens,
-    check_scale_up,
 )
 from src.plugin_system.testing.sizes import (  # noqa: E402
     parse_size_token, resolve_test_sizes, safe_mode_filename, size_label,
@@ -97,11 +96,12 @@ def check_one(plugin_id: str, search_dirs: List[str], sizes, mock_data: Dict,
     # matrix path does; explicit CLI flags still override the file.
     spec = load_harness_spec(plugin_dir)
 
-    # config_schema defaults (real-install behavior, with enabled forced True
-    # so a plugin's own enabled:false default can't accidentally disable
-    # testing), then harness.json config, then CLI --config — most specific
-    # wins.
-    full_config = build_full_config(plugin_dir, spec, config)
+    # config_schema defaults (real-install behavior), then harness.json config,
+    # then CLI --config — most specific wins.
+    full_config = {"enabled": True}
+    full_config.update(load_config_defaults(plugin_dir))
+    full_config.update(spec.get("config", {}))
+    full_config.update(config)
 
     # Precedence: CLI flag > LEDMATRIX_TEST_SIZES env > harness.json > default.
     effective_sizes = sizes if sizes else resolve_test_sizes(spec.get("sizes"))
@@ -110,55 +110,28 @@ def check_one(plugin_id: str, search_dirs: List[str], sizes, mock_data: Dict,
     effective_freeze = freeze_time or spec.get("freeze_time")
     effective_run_update = run_update and not spec.get("skip_update", False)
 
-    # The plugin's declared design size drives the scale-up fill check
-    # (panels >= 2x the design size must not be left mostly empty).
-    declared = load_manifest(plugin_dir).get("display", {}).get("design_size", {})
-    design_size = (int(declared.get("width", 128)), int(declared.get("height", 32)))
-    fill_strict = spec.get("fill_check") == "strict"
+    results = render_plugin_matrix(
+        plugin_id=plugin_id, plugin_dir=plugin_dir, config=full_config,
+        mock_data=effective_mock_data, sizes=effective_sizes,
+        run_update=effective_run_update, freeze_time=effective_freeze,
+    )
 
-    # Every run: the base config, plus one per harness.json "variant" —
-    # a config overlay with its own golden dir (e.g. adaptive layout mode
-    # tested alongside the classic default).
-    runs = [(None, {}, golden_dir_override or (plugin_dir / 'test' / 'golden'))]
-    for variant in spec.get("variants", []):
-        name = variant.get("name") or "variant"
-        vdir = plugin_dir / variant.get("golden_dir", f"test/golden-{name}")
-        runs.append((name, variant.get("config", {}), vdir))
+    golden_dir = golden_dir_override or (plugin_dir / 'test' / 'golden')
+    if update_golden:
+        written = write_goldens(results, golden_dir)
+        logger.info("Wrote %d golden image(s) for %s to %s", written, plugin_id, golden_dir)
+    else:
+        compare_to_goldens(results, golden_dir)
 
-    all_run_results: List[RenderResult] = []
-    for variant_name, overlay, golden_dir in runs:
-        run_config = {**full_config, **overlay}
-        results = render_plugin_matrix(
-            plugin_id=plugin_id, plugin_dir=plugin_dir, config=run_config,
-            mock_data=effective_mock_data, sizes=effective_sizes,
-            run_update=effective_run_update, freeze_time=effective_freeze,
-        )
+    if out_dir:
+        for r in results:
+            if r.image is None:
+                continue
+            dest = out_dir / plugin_id / size_label(r.width, r.height)
+            dest.mkdir(parents=True, exist_ok=True)
+            r.image.save(dest / f"{safe_mode_filename(r.mode)}.png", format="PNG")
 
-        if update_golden:
-            written = write_goldens(results, golden_dir)
-            logger.info("Wrote %d golden image(s) for %s%s to %s", written, plugin_id,
-                        f" [{variant_name}]" if variant_name else "", golden_dir)
-        else:
-            compare_to_goldens(results, golden_dir)
-
-        check_scale_up(results, design_size=design_size, strict=fill_strict)
-
-        # Tag variant runs so the report and PNG dumps stay distinguishable.
-        if variant_name:
-            for r in results:
-                r.mode = f"{r.mode}@{variant_name}"
-
-        if out_dir:
-            for r in results:
-                if r.image is None:
-                    continue
-                dest = out_dir / plugin_id / size_label(r.width, r.height)
-                dest.mkdir(parents=True, exist_ok=True)
-                r.image.save(dest / f"{safe_mode_filename(r.mode)}.png", format="PNG")
-
-        all_run_results.extend(results)
-
-    return all_run_results
+    return results
 
 
 def print_report(all_results: Dict[str, List[RenderResult]]) -> bool:
@@ -174,10 +147,6 @@ def print_report(all_results: Dict[str, List[RenderResult]]) -> bool:
                     detail = " (golden ✓)"
                 if r.update_error is not None:
                     detail += f" (update warn: {r.update_error})"
-                if r.fill_checked and r.fill_ok is None and r.fill_extent:
-                    # warn-only underfill: big panel left mostly empty
-                    ex, ey = r.fill_extent
-                    detail += f" (fill warn: extent {ex:.0%}x{ey:.0%})"
             else:
                 everything_ok = False
                 if r.error is not None:
@@ -187,10 +156,6 @@ def print_report(all_results: Dict[str, List[RenderResult]]) -> bool:
                 elif r.golden_ok is False:
                     status = "FAIL"
                     detail = f" golden drift: {r.golden_diff_pixels}px (max Δ={r.golden_max_delta})"
-                elif r.fill_ok is False:
-                    ex, ey = r.fill_extent or (0.0, 0.0)
-                    status = "FAIL"
-                    detail = f" fill: extent {ex:.0%}x{ey:.0%} below required coverage"
                 else:
                     status, detail = "FAIL", ""
             print(f"  [{status}] {r.size_label:>7}  {r.mode}{detail}")

scripts/check_release_version.py

@@ -1,122 +0,0 @@
-#!/usr/bin/env python3
-"""Assert that a release tag, the CHANGELOG, and `src.__version__` all agree.
-
-Run it *before* creating a tag to check yourself:
-
-    python scripts/check_release_version.py v3.2.0
-
-Wiring it into CI (on pushed `v*` tags and published releases) is a follow-up
-PR, so for now it is a manual pre-flight: run it before creating the tag and a
-mismatch shows up here rather than as a silent wrong answer on user devices.
-
-Why this exists: `v3.1.0` was tagged 2026-05-31 while `src/__init__.py` still
-said `"1.0.0"`; the bump to `"3.1.0"` did not land until 2026-07-12. Devices
-installed from that release report `1.0.0`, which is below the `(2, 0, 0)` floor
-in `PluginLoader._warn_if_incompatible`, so they are silently exempt from every
-plugin compatibility warning. Plugin `ledmatrix_min_version` floors are only as
-trustworthy as this agreement. See `docs/SPORTS_UNIFICATION.md`, phase B4.
-"""
-
-from __future__ import annotations
-
-import argparse
-import re
-import sys
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parents[1]
-sys.path.insert(0, str(REPO_ROOT))
-
-# [0-9] rather than \d, and [ \t] rather than \s: \d also matches non-ASCII
-# decimal digits (which int() parses), and \s matches newlines, so "##\n3.2.0"
-# would otherwise read as a version heading. Keep these in step with
-# test/test_version_consistency.py.
-SEMVER = re.compile(r"^[0-9]+\.[0-9]+\.[0-9]+$")
-HEADING = re.compile(
-    r"^##[ \t]+(?P<version>[0-9]+\.[0-9]+\.[0-9]+)[ \t]*$", re.MULTILINE)
-
-
-def normalize(tag: str) -> str:
-    """`v3.2.0` and `3.2.0` are the same release; tags here carry the `v`."""
-    return tag[1:] if tag.startswith("v") else tag
-
-
-def newest_changelog_version(changelog: Path) -> str | None:
-    """Newest version heading, or None when there is none.
-
-    Raises OSError if the file cannot be read; main() turns that into a clear
-    message rather than a traceback, because this runs as a release gate and a
-    traceback there reads as "the tooling is broken", not "your CHANGELOG is
-    missing".
-    """
-    headings = HEADING.findall(changelog.read_text(encoding="utf-8"))
-    return headings[0] if headings else None
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument(
-        "tag",
-        help="Release tag to check, with or without the leading 'v' (e.g. v3.2.0)",
-    )
-    args = parser.parse_args()
-
-    from src import __version__ as core_version
-
-    tag_version = normalize(args.tag)
-    changelog_path = REPO_ROOT / "CHANGELOG.md"
-
-    problems: list[str] = []
-
-    try:
-        changelog_version = newest_changelog_version(changelog_path)
-    except OSError as e:
-        print(
-            f"Release version check FAILED for tag {args.tag}:\n"
-            f"  - could not read {changelog_path}: {e}\n"
-            f"    Restore the file (git checkout -- CHANGELOG.md) and re-run.",
-            file=sys.stderr,
-        )
-        return 1
-
-    if not SEMVER.match(tag_version):
-        problems.append(
-            f"tag {args.tag!r} is not vX.Y.Z. Older tags (v2.5) predate this "
-            "check; new releases must be full semver so floors can parse them."
-        )
-
-    if not SEMVER.match(core_version):
-        problems.append(f"src.__version__ is {core_version!r}, which is not X.Y.Z")
-
-    if tag_version != core_version:
-        problems.append(
-            f"tag says {tag_version} but src.__version__ says {core_version}. "
-            "Bump src/__init__.py to match the tag before releasing — devices "
-            "report __version__, not the tag, and plugin floors compare "
-            "against it."
-        )
-
-    if changelog_version is None:
-        problems.append("CHANGELOG.md has no '## X.Y.Z' version heading")
-    elif changelog_version != core_version:
-        problems.append(
-            f"CHANGELOG.md's newest heading is {changelog_version} but "
-            f"src.__version__ is {core_version}. Plugin authors read the "
-            "CHANGELOG to pick a ledmatrix_min_version floor."
-        )
-
-    if problems:
-        print(f"Release version check FAILED for tag {args.tag}:", file=sys.stderr)
-        for problem in problems:
-            print(f"  - {problem}", file=sys.stderr)
-        return 1
-
-    print(
-        f"OK: tag {args.tag}, src.__version__ {core_version}, and the CHANGELOG "
-        "all agree."
-    )
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

scripts/clear_dependency_markers.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+# Clear all plugin dependency markers to force fresh dependency check
+# Useful after updating plugins or troubleshooting dependency issues
+
+echo "Clearing plugin dependency markers..."
+
+# Check both possible cache locations
+CACHE_DIRS=(
+    "/var/cache/ledmatrix"
+    "$HOME/.cache/ledmatrix"
+)
+
+for CACHE_DIR in "${CACHE_DIRS[@]}"; do
+    if [ -d "$CACHE_DIR" ]; then
+        echo "Checking $CACHE_DIR..."
+        marker_count=$(find "$CACHE_DIR" -name "plugin_*_deps_installed" 2>/dev/null | wc -l)
+        if [ "$marker_count" -gt 0 ]; then
+            echo "Found $marker_count dependency marker(s) in $CACHE_DIR"
+            find "$CACHE_DIR" -name "plugin_*_deps_installed" -delete
+            echo "Cleared $marker_count marker(s)"
+        else
+            echo "No dependency markers found in $CACHE_DIR"
+        fi
+    fi
+done
+
+echo "Done! Dependency markers cleared."
+echo "Next startup will check and install dependencies as needed."
+

scripts/debug/check_imports.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+"""
+Check what imports are actually in the app.py file on the Pi
+"""
+
+from pathlib import Path
+
+# Read the app.py file and check the import lines
+app_py_path = Path.home() / 'LEDMatrix' / 'web_interface' / 'app.py'
+
+print(f"🔍 Checking imports in: {app_py_path}")
+print(f"📁 File exists: {app_py_path.exists()}")
+
+if app_py_path.exists():
+    with open(app_py_path, 'r') as f:
+        lines = f.readlines()
+
+    print("\n🔍 Import lines in app.py:")
+    for i, line in enumerate(lines, 1):
+        if 'from' in line and 'blueprints' in line and 'import' in line:
+            print(f"  Line {i}: {line.strip()}")
+
+    print("\n🔍 Blueprint registration lines:")
+    for i, line in enumerate(lines, 1):
+        if 'register_blueprint' in line:
+            print(f"  Line {i}: {line.strip()}")
+else:
+    print("❌ app.py file not found!")

scripts/debug/debug_web_manual.py

@@ -13,8 +13,8 @@ def main():
     print("🔍 LED Matrix Web Interface Debug Tool")
     print("=" * 50)
 
-    # Change to project root (two levels up from scripts/debug/)
-    project_root = Path(__file__).parent.parent.parent.resolve()
+    # Change to project root (where this script is located)
+    project_root = Path(__file__).parent.resolve()
     os.chdir(project_root)
     print(f"📁 Working directory: {os.getcwd()}")
 

scripts/debug/direct_fix_imports.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+Direct fix for import issues - manually edit the app.py file
+"""
+
+import os
+from pathlib import Path
+
+def fix_imports():
+    app_py_path = Path.home() / 'LEDMatrix' / 'web_interface' / 'app.py'
+
+    print(f"🔧 Directly fixing imports in: {app_py_path}")
+
+    # Read the file
+    with open(app_py_path, 'r') as f:
+        lines = f.readlines()
+
+    # Find and fix the import lines
+    fixed = False
+    for i, line in enumerate(lines, 1):
+        if 'from blueprints.pages_v3 import' in line:
+            lines[i-1] = "from web_interface.blueprints.pages_v3 import pages_v3\n"
+            print(f"✅ Fixed line {i}: from blueprints.pages_v3 import → from web_interface.blueprints.pages_v3 import")
+            fixed = True
+        elif 'from blueprints.api_v3 import' in line:
+            lines[i-1] = "from web_interface.blueprints.api_v3 import api_v3\n"
+            print(f"✅ Fixed line {i}: from blueprints.api_v3 import → from web_interface.blueprints.api_v3 import")
+            fixed = True
+
+    if not fixed:
+        print("❌ No import lines found to fix")
+        return False
+
+    # Write the fixed file back
+    with open(app_py_path, 'w') as f:
+        f.writelines(lines)
+
+    print("✅ File updated successfully")
+    return True
+
+def verify_fix():
+    print("\n🔍 Verifying the fix...")
+    os.system("python3 check_imports.py")
+
+if __name__ == "__main__":
+    if fix_imports():
+        print("\n🧹 Clearing Python cache...")
+        os.system("find ~/LEDMatrix -type d -name '__pycache__' -exec rm -rf {} + 2>/dev/null || true")
+        os.system("find ~/LEDMatrix -name '*.pyc' -delete 2>/dev/null || true")
+
+        print("\n✅ Imports fixed and cache cleared!")
+        verify_fix()
+
+        print("\n🚀 Now try running the web interface:")
+        print("cd ~/LEDMatrix")
+        print("python3 web_interface/start.py")
+    else:
+        print("\n❌ Fix failed")

scripts/dev/test_pillow_compat.py

@@ -55,7 +55,7 @@ def main():
     failures += not check("draw.textbbox",
         lambda: draw.textbbox((0, 0), "Test", font=font))
 
-    print("\nResampling (used in logo_helper, sports base):")
+    print("\nResampling (used in logo_helper, image_utils, sports base):")
     logo = Image.new('RGBA', (200, 200), (255, 128, 0, 200))
     failures += not check("Image.Resampling.LANCZOS exists",
         lambda: str(Image.Resampling.LANCZOS))

scripts/dev/vegas_audit.py

@@ -1,384 +0,0 @@
-#!/usr/bin/env python3
-"""
-Vegas Mode Density Audit
-
-Reports how much of the Vegas ticker is actually showing something. Loads the
-real enabled plugins, pulls each one's content through the real
-``PluginAdapter``, composes the strip through the real ``ScrollHelper``, then
-measures the result.
-
-The headline number is the **dead-frame ratio**: the fraction of viewport
-positions across a full cycle that are effectively blank. Because the panel
-only ever shows ``display_width`` columns at a time, a blank stretch wider than
-the viewport is a stretch where the display looks switched off — so this ratio
-tracks perceived dead time rather than just counting unlit pixels.
-
-Runs entirely off-hardware, so it is safe to run alongside a live display.
-
-Usage:
-    # Audit every enabled plugin at the display size from config.json
-    python scripts/dev/vegas_audit.py
-
-    # Specific plugins, dump each segment as a PNG for eyeballing
-    python scripts/dev/vegas_audit.py -p of-the-day,youtube-stats --dump-dir /tmp/vg
-
-    # Machine-readable, for before/after comparison
-    python scripts/dev/vegas_audit.py --json > after.json
-"""
-
-import argparse
-import json
-import logging
-import os
-import sys
-import time
-from pathlib import Path
-from typing import Any, Dict, List
-
-PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
-sys.path.insert(0, str(PROJECT_ROOT))
-
-# Must precede any src import that may reach for hardware.
-os.environ.setdefault('EMULATOR', 'true')
-
-from PIL import Image  # noqa: E402
-
-from src.common.scroll_helper import ScrollHelper  # noqa: E402
-from src.plugin_system.testing.loading import (  # noqa: E402
-    build_full_config,
-    find_plugin_dir,
-    load_manifest,
-)
-from src.vegas_mode.config import VegasModeConfig  # noqa: E402
-from src.vegas_mode.geometry import (  # noqa: E402
-    DEFAULT_INK_THRESHOLD,
-    column_has_ink,
-    content_bounds,
-    dead_window_stats,
-    window_coverage_stats,
-)
-from src.vegas_mode.plugin_adapter import PluginAdapter  # noqa: E402
-
-# Sampling stride for the dead-window scan. A full cycle can be 30,000px wide;
-# 4px granularity keeps the scan instant while staying well under the ~10px a
-# single scroll step ever covers, so no dead stretch is missed.
-DEAD_SCAN_STEP = 4
-
-
-def load_main_config(path: Path) -> Dict[str, Any]:
-    with open(path, 'r') as fh:
-        return json.load(fh)
-
-
-def display_size_from_config(config: Dict[str, Any]) -> tuple:
-    """Derive the logical ticker size the way DisplayManager does."""
-    hw = config.get('display', {}).get('hardware', {})
-    cols = int(hw.get('cols', 64))
-    chain = int(hw.get('chain_length', 1))
-    rows = int(hw.get('rows', 32))
-    parallel = int(hw.get('parallel', 1))
-    return cols * chain, rows * parallel
-
-
-def enabled_plugin_ids(config: Dict[str, Any]) -> List[str]:
-    """Plugin IDs that are enabled in config, excluding non-plugin sections."""
-    ids = []
-    for key, value in config.items():
-        if isinstance(value, dict) and value.get('enabled') is True:
-            ids.append(key)
-    return ids
-
-
-def instantiate(plugin_id: str, display_manager, cache_manager, plugin_manager):
-    """Load one plugin offline. Returns the instance or None."""
-    from src.plugin_system.plugin_loader import PluginLoader
-
-    search_dirs = [
-        str(PROJECT_ROOT / 'plugin-repos'),
-        str(PROJECT_ROOT / 'plugins'),
-    ]
-    plugin_dir = find_plugin_dir(plugin_id, search_dirs)
-    if not plugin_dir:
-        return None
-
-    try:
-        manifest = load_manifest(Path(plugin_dir))
-        cfg = build_full_config(Path(plugin_dir))
-        instance, _ = PluginLoader().load_plugin(
-            plugin_id=plugin_id,
-            manifest=manifest,
-            plugin_dir=Path(plugin_dir),
-            config=cfg,
-            display_manager=display_manager,
-            cache_manager=cache_manager,
-            plugin_manager=plugin_manager,
-            install_deps=False,
-        )
-        return instance
-    except Exception as exc:  # noqa: BLE001 - audit tool must survive any plugin
-        print(f"  ! {plugin_id}: load failed ({type(exc).__name__}: {exc})",
-              file=sys.stderr)
-        return None
-
-
-def join_rows(images: List[Image.Image], gap: int) -> Image.Image:
-    """Concatenate one plugin's rows, matching RenderPipeline._join_plugin_rows."""
-    if len(images) == 1:
-        return images[0]
-    gap = max(0, gap)
-    width = sum(img.width for img in images) + gap * (len(images) - 1)
-    height = max(img.height for img in images)
-    block = Image.new('RGB', (width, height), (0, 0, 0))
-    x = 0
-    for img in images:
-        block.paste(img, (x, 0))
-        x += img.width + gap
-    return block
-
-
-def measure_segment(images: List[Image.Image], display_width: int,
-                    scroll_speed: float, threshold: int) -> Dict[str, Any]:
-    """Geometry of one plugin's contribution to the ticker."""
-    total_width = sum(img.width for img in images)
-    combined = Image.new('RGB', (max(1, total_width), images[0].height))
-    x = 0
-    for img in images:
-        combined.paste(img, (x, 0))
-        x += img.width
-
-    ink = column_has_ink(combined, threshold)
-    bounds = content_bounds(combined, threshold)
-    ink_cols = int(ink.sum())
-
-    return {
-        'images': len(images),
-        'width_px': total_width,
-        'ink_cols': ink_cols,
-        'ink_pct': round(100.0 * ink_cols / total_width, 1) if total_width else 0.0,
-        'lead_black_px': bounds[0] if bounds else total_width,
-        'trail_black_px': (total_width - 1 - bounds[1]) if bounds else 0,
-        'seconds_on_screen': round(total_width / scroll_speed, 1) if scroll_speed else 0.0,
-        'widths': [img.width for img in images],
-    }
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(
-        description='Audit Vegas mode content density')
-    parser.add_argument('--config', default=str(PROJECT_ROOT / 'config' / 'config.json'),
-                        help='Path to main config.json')
-    parser.add_argument('-p', '--plugins', default=None,
-                        help='Comma-separated plugin IDs (default: all enabled)')
-    parser.add_argument('--width', type=int, default=None,
-                        help='Override display width (default: from config hardware)')
-    parser.add_argument('--height', type=int, default=None,
-                        help='Override display height (default: from config hardware)')
-    parser.add_argument('--dump-dir', default=None,
-                        help='Write each segment and the composed strip as PNGs here')
-    parser.add_argument('--threshold', type=int, default=DEFAULT_INK_THRESHOLD,
-                        help=f'Ink threshold (default: {DEFAULT_INK_THRESHOLD})')
-    parser.add_argument('--per-cycle', type=int, default=None,
-                        help='Plugins composed per cycle '
-                             '(default: buffer_ahead + 1, matching production)')
-    parser.add_argument('--json', action='store_true',
-                        help='Emit JSON instead of a text report')
-    args = parser.parse_args()
-
-    config = load_main_config(Path(args.config))
-    vegas = VegasModeConfig.from_config(config)
-
-    cfg_w, cfg_h = display_size_from_config(config)
-    width = args.width or cfg_w
-    height = args.height or cfg_h
-    speed = vegas.scroll_speed
-
-    if args.plugins:
-        plugin_ids = [p.strip() for p in args.plugins.split(',') if p.strip()]
-    else:
-        plugin_ids = vegas.get_ordered_plugins(enabled_plugin_ids(config))
-
-    dump_dir = Path(args.dump_dir) if args.dump_dir else None
-    if dump_dir:
-        dump_dir.mkdir(parents=True, exist_ok=True)
-
-    from src.plugin_system.testing import (
-        MockCacheManager, MockPluginManager, VisualTestDisplayManager,
-    )
-
-    display_manager = VisualTestDisplayManager(width=width, height=height)
-    cache_manager = MockCacheManager()
-    plugin_manager = MockPluginManager()
-    # Pass the loaded config, exactly as VegasModeCoordinator does. Omitting it
-    # makes PluginAdapter fall back to VegasModeConfig() defaults, so the audit
-    # would silently report trimming and width-budget behaviour that differs
-    # from the user's config.json — the same drift the lead_gap and grouping
-    # arguments below exist to avoid.
-    adapter = PluginAdapter(display_manager, vegas)
-
-    if not args.json:
-        print(f"Vegas audit — display {width}x{height}, scroll {speed:g}px/s, "
-              f"separator {vegas.separator_width}px")
-        print(f"One display width = {width / speed:.1f}s of screen time\n")
-
-    results: List[Dict[str, Any]] = []
-    segments: List[Image.Image] = []
-
-    for plugin_id in plugin_ids:
-        started = time.time()
-        instance = instantiate(plugin_id, display_manager, cache_manager, plugin_manager)
-        if instance is None:
-            results.append({'plugin': plugin_id, 'status': 'load_failed'})
-            continue
-
-        plugin_manager.plugins[plugin_id] = instance
-        adapter.invalidate_cache(plugin_id)
-
-        try:
-            images = adapter.get_content(instance, plugin_id)
-        except Exception as exc:  # noqa: BLE001
-            results.append({'plugin': plugin_id, 'status': 'fetch_error',
-                            'error': f'{type(exc).__name__}: {exc}'})
-            continue
-
-        fetch_ms = round((time.time() - started) * 1000)
-
-        if not images:
-            results.append({'plugin': plugin_id, 'status': 'no_content',
-                            'fetch_ms': fetch_ms})
-            if not args.json:
-                print(f"  {plugin_id:28s} NO CONTENT            ({fetch_ms}ms)")
-            continue
-
-        entry = {'plugin': plugin_id, 'status': 'ok', 'fetch_ms': fetch_ms}
-        entry.update(measure_segment(images, width, speed, args.threshold))
-        results.append(entry)
-        segments.extend(images)
-
-        if dump_dir:
-            for idx, img in enumerate(images):
-                img.save(dump_dir / f"{plugin_id}__{idx:02d}.png")
-
-        if not args.json:
-            print(f"  {plugin_id:28s} {entry['width_px']:>6d}px  "
-                  f"{entry['images']:>2d} img  ink {entry['ink_pct']:>5.1f}%  "
-                  f"lead {entry['lead_black_px']:>4d}  tail {entry['trail_black_px']:>4d}  "
-                  f"{entry['seconds_on_screen']:>6.1f}s  ({fetch_ms}ms)")
-
-    summary: Dict[str, Any] = {
-        'display_width': width,
-        'display_height': height,
-        'scroll_speed': speed,
-        'separator_width': vegas.separator_width,
-        'plugins_audited': len(plugin_ids),
-        'plugins_with_content': sum(1 for r in results if r.get('status') == 'ok'),
-    }
-
-    # Production composes only the plugins sitting in the active buffer, so
-    # measuring one giant strip of every plugin would hide the per-cycle costs
-    # (most importantly the leading gap, which is charged once per cycle).
-    # Group the segments the way the running service does.
-    per_cycle = max(1, args.per_cycle or vegas.plugins_per_cycle)
-
-    cycles: List[Dict[str, Any]] = []
-    with_content = [r for r in results if r.get('status') == 'ok']
-
-    if segments:
-        logger = logging.getLogger('vegas_audit')
-        seg_index = 0
-        for start in range(0, len(with_content), per_cycle):
-            group = with_content[start:start + per_cycle]
-
-            # Mirror RenderPipeline: each plugin's rows are joined by
-            # intra_plugin_gap into one block, and separator_width is applied
-            # only between blocks. Measuring a flat list here would report gaps
-            # the service does not emit.
-            blocks: List[Image.Image] = []
-            for entry in group:
-                count = entry['images']
-                rows = segments[seg_index:seg_index + count]
-                seg_index += count
-                if rows:
-                    blocks.append(join_rows(rows, vegas.intra_plugin_gap))
-            if not blocks:
-                continue
-
-            # ScrollHelper logs unconditionally, so it needs a real logger.
-            helper = ScrollHelper(width, height, logger)
-            helper.create_scrolling_image(
-                content_items=blocks,
-                item_gap=vegas.separator_width,
-                element_gap=0,
-                # Must match RenderPipeline. Omitting this made the audit
-                # measure a full-display-width leading gap the service no
-                # longer emits, overstating dead space by 512px per cycle.
-                lead_gap=vegas.lead_in_width,
-            )
-            composed = helper.cached_image
-            if composed is None:
-                continue
-
-            dead = dead_window_stats(composed, width, args.threshold, step=DEAD_SCAN_STEP)
-            cover = window_coverage_stats(
-                composed, width, args.threshold, step=DEAD_SCAN_STEP)
-
-            if dump_dir:
-                composed.save(dump_dir / f"_cycle{len(cycles):02d}.png")
-
-            cycles.append({
-                'plugins': [e['plugin'] for e in group],
-                'width_px': composed.width,
-                'seconds': round(composed.width / speed, 1) if speed else 0.0,
-                'dead_pct': round(100 * dead.dead_ratio, 1),
-                'longest_dead_seconds': round(
-                    dead.longest_dead_run * DEAD_SCAN_STEP / speed, 1) if speed else 0.0,
-                'mean_ink_pct': round(100 * cover.mean_ink_ratio, 1),
-                'sparse_pct': round(100 * cover.sparse_ratio, 1),
-                'longest_sparse_seconds': round(
-                    cover.longest_sparse_run * DEAD_SCAN_STEP / speed, 1) if speed else 0.0,
-            })
-
-    if cycles:
-        total_px = sum(c['width_px'] for c in cycles)
-        # Weight each cycle by its width so a long cycle counts proportionally.
-        summary.update({
-            'cycles': len(cycles),
-            'total_px': total_px,
-            'full_rotation_seconds': round(total_px / speed, 1) if speed else 0.0,
-            'dead_pct': round(
-                sum(c['dead_pct'] * c['width_px'] for c in cycles) / total_px, 1),
-            'mean_ink_pct': round(
-                sum(c['mean_ink_pct'] * c['width_px'] for c in cycles) / total_px, 1),
-            'sparse_pct': round(
-                sum(c['sparse_pct'] * c['width_px'] for c in cycles) / total_px, 1),
-            'worst_dead_seconds': max(c['longest_dead_seconds'] for c in cycles),
-            'worst_sparse_seconds': max(c['longest_sparse_seconds'] for c in cycles),
-        })
-
-    if args.json:
-        print(json.dumps({'summary': summary, 'cycles': cycles, 'plugins': results},
-                         indent=2))
-    else:
-        print(f"\n  Cycles ({per_cycle} plugins each, as production composes them):")
-        for idx, cyc in enumerate(cycles):
-            print(f"    [{idx}] {cyc['width_px']:>6d}px {cyc['seconds']:>6.1f}s  "
-                  f"ink {cyc['mean_ink_pct']:>5.1f}%  blank {cyc['dead_pct']:>5.1f}%  "
-                  f"worst blank {cyc['longest_dead_seconds']:>5.1f}s  "
-                  f"| {', '.join(cyc['plugins'])}")
-
-        print(f"\n  {'-' * 66}")
-        print(f"  full rotation        {summary.get('full_rotation_seconds', 0):>7.1f}s "
-              f"over {summary.get('cycles', 0)} cycles")
-        print(f"  mean ink coverage    {summary.get('mean_ink_pct', 0):>7.1f}%  "
-              f"(higher is better; target >25%)")
-        print(f"  fully blank          {summary.get('dead_pct', 0):>7.1f}%  (target <2%)")
-        print(f"  reads as empty       {summary.get('sparse_pct', 0):>7.1f}%  (target <15%)")
-        print(f"  worst blank stretch  {summary.get('worst_dead_seconds', 0):>7.1f}s  "
-              f"(target <1.5s)")
-        print(f"  plugins w/ content   {summary.get('plugins_with_content', 0):>7d}"
-              f" of {summary['plugins_audited']}")
-
-    return 0
-
-
-if __name__ == '__main__':
-    raise SystemExit(main())

scripts/dev_server.py

@@ -16,7 +16,6 @@ Opens at http://localhost:5001
 import sys
 import os
 import json
-import re
 import time
 import argparse
 import logging
@@ -45,10 +44,6 @@ MAX_HEIGHT = 512
 MIN_WIDTH = 1
 MIN_HEIGHT = 1
 
-# plugin_id arrives in request input and is used to build filesystem paths —
-# allowlist it (same pattern the web UI's pages_v3 uses)
-_SAFE_PLUGIN_ID_RE = re.compile(r'^[a-zA-Z0-9_-]{1,64}$')
-
 
 # --------------------------------------------------------------------------
 # Plugin discovery
@@ -111,30 +106,15 @@ def discover_plugins() -> List[Dict[str, Any]]:
 
 
 def find_plugin_dir(plugin_id: str) -> Optional[Path]:
-    """Find a plugin directory by ID.
-
-    plugin_id comes from request input: it must pass an allowlist match,
-    and the resulting directory is normalized and required to live inside
-    one of the plugin search dirs, so a crafted id can never name a path
-    outside them.
-    """
-    if not isinstance(plugin_id, str) or not _SAFE_PLUGIN_ID_RE.match(plugin_id):
-        return None
+    """Find a plugin directory by ID."""
     from src.plugin_system.plugin_loader import PluginLoader
     loader = PluginLoader()
     for search_dir in get_search_dirs():
         if not search_dir.exists():
             continue
         result = loader.find_plugin_directory(plugin_id, search_dir)
-        if not result:
-            continue
-        # Normalize WITHOUT following symlinks (dev plugins are often
-        # symlinked into plugins/) and require lexical containment in the
-        # search dir, so no id can ever name a path outside it.
-        result_abs = os.path.abspath(str(result))
-        root_abs = os.path.abspath(str(search_dir))
-        if os.path.commonpath([result_abs, root_abs]) == root_abs:
-            return Path(result_abs)
+        if result:
+            return Path(result)
     return None
 
 
@@ -196,118 +176,6 @@ def api_plugin_defaults(plugin_id):
     return jsonify({'defaults': defaults})
 
 
-def _render_once(plugin_id, plugin_dir, manifest, config, mock_data, width, height,
-                 skip_update):
-    """Render one plugin at one size. Returns the /api/render response dict.
-
-    A fresh plugin instance per call, mirroring the safety harness, so sizes
-    never share state.
-    """
-    from src.plugin_system.testing import VisualTestDisplayManager, MockCacheManager, MockPluginManager
-    from src.plugin_system.plugin_loader import PluginLoader
-
-    display_manager = VisualTestDisplayManager(width=width, height=height)
-    cache_manager = MockCacheManager()
-    plugin_manager = MockPluginManager()
-
-    # Pre-populate cache with mock data
-    for key, value in mock_data.items():
-        cache_manager.set(key, value)
-
-    loader = PluginLoader()
-    errors = []
-    warnings = []
-
-    plugin_instance, _module = loader.load_plugin(
-        plugin_id=plugin_id,
-        manifest=manifest,
-        plugin_dir=plugin_dir,
-        config=config,
-        display_manager=display_manager,
-        cache_manager=cache_manager,
-        plugin_manager=plugin_manager,
-        install_deps=False,
-    )
-
-    start_time = time.time()
-
-    # Run update()
-    if not skip_update:
-        try:
-            plugin_instance.update()
-        except Exception as e:
-            logger.warning("update() raised for plugin %s", plugin_id, exc_info=True)
-            warnings.append(f"update() raised: {type(e).__name__} — see server log")
-
-    # Run display()
-    try:
-        plugin_instance.display(force_clear=True)
-    except Exception as e:
-        logger.warning("display() raised for plugin %s", plugin_id, exc_info=True)
-        errors.append(f"display() raised: {type(e).__name__} — see server log")
-
-    render_time_ms = round((time.time() - start_time) * 1000, 1)
-
-    return {
-        'image': f'data:image/png;base64,{display_manager.get_image_base64()}',
-        'width': width,
-        'height': height,
-        'render_time_ms': render_time_ms,
-        'errors': errors,
-        'warnings': warnings,
-    }
-
-
-def _trusted_plugin_dir(plugin_dir: Path) -> Optional[Path]:
-    """Re-derive a plugin directory from the search dirs' own listings.
-
-    Path-injection barrier: unlike ``Path.iterdir()`` (which CodeQL doesn't
-    recognize as a taint-clearing enumeration), ``os.scandir()`` is. The
-    returned Path is built from a trusted root plus a name the filesystem
-    itself produced under that root via scandir — request-derived strings
-    never enter its construction — so a crafted plugin id can never make
-    downstream file access leave the plugin search dirs. Comparison is by
-    name, deliberately without symlink resolution (dev plugins are
-    commonly symlinked into plugins/).
-    """
-    wanted_name = Path(os.path.normpath(str(plugin_dir))).name
-    for search_dir in get_search_dirs():
-        search_dir_str = str(search_dir)
-        try:
-            with os.scandir(search_dir_str) as entries:
-                for entry in entries:
-                    if entry.name == wanted_name and entry.is_dir():
-                        return Path(search_dir_str) / entry.name
-        except OSError:
-            continue
-    return None
-
-
-def _parse_render_request(data):
-    """Shared /api/render* request prep. Returns (plugin_dir, manifest, config,
-    mock_data, skip_update) or raises ValueError with a client message."""
-    plugin_id = data['plugin_id']
-    candidate_dir = find_plugin_dir(plugin_id)
-    # Never reuse `candidate_dir` past this point: it's built from
-    # request-derived input, and a variable reassigned only on some paths
-    # isn't a barrier CodeQL's flow analysis honors. `trusted_dir` is the
-    # sole name used below, always the scandir-sourced result.
-    trusted_dir = _trusted_plugin_dir(candidate_dir) if candidate_dir else None
-    if not trusted_dir:
-        raise LookupError(f'Plugin not found: {plugin_id}')
-
-    manifest_path = trusted_dir / 'manifest.json'
-    with open(manifest_path, 'r') as f:
-        manifest = json.load(f)
-
-    # Build config: schema defaults + user overrides
-    config = {'enabled': True}
-    config.update(load_config_defaults(trusted_dir))
-    config.update(data.get('config', {}))
-
-    return trusted_dir, manifest, config, data.get('mock_data', {}), data.get('skip_update', False)
-
-
 @app.route('/api/render', methods=['POST'])
 def api_render():
     """Render a plugin and return the display as base64 PNG."""
@@ -315,6 +183,11 @@ def api_render():
     if not data or 'plugin_id' not in data:
         return jsonify({'error': 'plugin_id is required'}), 400
 
+    plugin_id = data['plugin_id']
+    user_config = data.get('config', {})
+    mock_data = data.get('mock_data', {})
+    skip_update = data.get('skip_update', False)
+
     try:
         width = int(data.get('width', 128))
         height = int(data.get('height', 32))
@@ -326,77 +199,78 @@ def api_render():
     if not (MIN_HEIGHT <= height <= MAX_HEIGHT):
         return jsonify({'error': f'height must be between {MIN_HEIGHT} and {MAX_HEIGHT}'}), 400
 
-    try:
-        plugin_dir, manifest, config, mock_data, skip_update = _parse_render_request(data)
-    except LookupError:
-        return jsonify({'error': f"Plugin not found: {data['plugin_id']}"}), 404
-    except Exception:
-        # Bad manifest.json / schema / fixture — details go to the dev's
-        # console, not the HTTP response
-        app.logger.exception('render request preparation failed')
-        return jsonify({'error': 'Could not prepare render request; see server log'}), 400
+    # Find plugin
+    plugin_dir = find_plugin_dir(plugin_id)
+    if not plugin_dir:
+        return jsonify({'error': f'Plugin not found: {plugin_id}'}), 404
+
+    # Load manifest
+    manifest_path = plugin_dir / 'manifest.json'
+    with open(manifest_path, 'r') as f:
+        manifest = json.load(f)
+
+    # Build config: schema defaults + user overrides
+    config_defaults = load_config_defaults(plugin_dir)
+    config = {'enabled': True}
+    config.update(config_defaults)
+    config.update(user_config)
+
+    # Create display manager and mocks
+    from src.plugin_system.testing import VisualTestDisplayManager, MockCacheManager, MockPluginManager
+    from src.plugin_system.plugin_loader import PluginLoader
+
+    display_manager = VisualTestDisplayManager(width=width, height=height)
+    cache_manager = MockCacheManager()
+    plugin_manager = MockPluginManager()
+
+    # Pre-populate cache with mock data
+    for key, value in mock_data.items():
+        cache_manager.set(key, value)
+
+    # Load plugin
+    loader = PluginLoader()
+    errors = []
+    warnings = []
 
     try:
-        result = _render_once(data['plugin_id'], plugin_dir, manifest, config,
-                              mock_data, width, height, skip_update)
-    except Exception:
-        app.logger.exception('plugin load failed during render')
-        return jsonify({'error': 'Failed to load plugin; see server log'}), 500
-    return jsonify(result)
+        plugin_instance, module = loader.load_plugin(
+            plugin_id=plugin_id,
+            manifest=manifest,
+            plugin_dir=plugin_dir,
+            config=config,
+            display_manager=display_manager,
+            cache_manager=cache_manager,
+            plugin_manager=plugin_manager,
+            install_deps=False,
+        )
+    except Exception as e:
+        return jsonify({'error': f'Failed to load plugin: {e}'}), 500
 
+    start_time = time.time()
 
-@app.route('/api/sizes')
-def api_sizes():
-    """The representative panel-size sample the safety harness renders at."""
-    from src.plugin_system.testing.sizes import DEFAULT_TEST_SIZES
-    return jsonify({'sizes': [list(s) for s in DEFAULT_TEST_SIZES]})
-
-
-MAX_MATRIX_SIZES = 12
-
-
-@app.route('/api/render-matrix', methods=['POST'])
-def api_render_matrix():
-    """Render a plugin at a list of sizes (default: the harness sample) so the
-    UI can show a side-by-side multi-resolution gallery."""
-    data = request.get_json()
-    if not data or 'plugin_id' not in data:
-        return jsonify({'error': 'plugin_id is required'}), 400
-
-    from src.plugin_system.testing.sizes import DEFAULT_TEST_SIZES
-    sizes = data.get('sizes') or [list(s) for s in DEFAULT_TEST_SIZES]
-    if len(sizes) > MAX_MATRIX_SIZES:
-        return jsonify({'error': f'at most {MAX_MATRIX_SIZES} sizes per request'}), 400
-    parsed_sizes = []
-    for pair in sizes:
+    # Run update()
+    if not skip_update:
         try:
-            w, h = int(pair[0]), int(pair[1])
-        except (TypeError, ValueError, IndexError):
-            return jsonify({'error': f'invalid size entry {pair!r} (expected [w, h])'}), 400
-        if not (MIN_WIDTH <= w <= MAX_WIDTH and MIN_HEIGHT <= h <= MAX_HEIGHT):
-            return jsonify({'error': f'size {w}x{h} out of bounds'}), 400
-        parsed_sizes.append((w, h))
+            plugin_instance.update()
+        except Exception as e:
+            warnings.append(f"update() raised: {e}")
 
+    # Run display()
     try:
-        plugin_dir, manifest, config, mock_data, skip_update = _parse_render_request(data)
-    except LookupError:
-        return jsonify({'error': f"Plugin not found: {data['plugin_id']}"}), 404
-    except Exception:
-        app.logger.exception('render request preparation failed')
-        return jsonify({'error': 'Could not prepare render request; see server log'}), 400
+        plugin_instance.display(force_clear=True)
+    except Exception as e:
+        errors.append(f"display() raised: {e}")
 
-    results = []
-    for w, h in parsed_sizes:
-        try:
-            results.append(_render_once(data['plugin_id'], plugin_dir, manifest,
-                                        config, mock_data, w, h, skip_update))
-        except Exception:
-            app.logger.exception('plugin load failed during %dx%d render', w, h)
-            results.append({'image': None, 'width': w, 'height': h,
-                            'render_time_ms': 0,
-                            'errors': ['Failed to load plugin; see server log'],
-                            'warnings': []})
-    return jsonify({'results': results})
+    render_time_ms = round((time.time() - start_time) * 1000, 1)
+
+    return jsonify({
+        'image': f'data:image/png;base64,{display_manager.get_image_base64()}',
+        'width': width,
+        'height': height,
+        'render_time_ms': render_time_ms,
+        'errors': errors,
+        'warnings': warnings,
+    })
 
 
 # --------------------------------------------------------------------------

scripts/diagnose_dependencies.sh

@@ -156,13 +156,9 @@ echo ""
 echo "6. Check disk space - building packages requires temporary space"
 echo "   df -h"
 echo ""
-echo "7. For slow builds or out-of-memory kills, increase swap space."
-echo "   first_time_install.sh already adds temporary swap on low-memory devices;"
-echo "   this makes it permanent. Set CONF_MAXSWAP too - it defaults to 2048 and"
-echo "   silently clamps CONF_SWAPSIZE, so raising CONF_SWAPSIZE alone does nothing."
+echo "7. For slow builds, increase swap space:"
 echo "   sudo dphys-swapfile swapoff"
-echo "   sudo sed -i 's/^#\\?CONF_SWAPSIZE=.*/CONF_SWAPSIZE=2048/' /etc/dphys-swapfile"
-echo "   sudo sed -i 's/^#\\?CONF_MAXSWAP=.*/CONF_MAXSWAP=2048/' /etc/dphys-swapfile"
+echo "   sudo nano /etc/dphys-swapfile  # Set CONF_SWAPSIZE=2048"
 echo "   sudo dphys-swapfile setup"
 echo "   sudo dphys-swapfile swapon"
 echo ""

scripts/download_nba_logos.py

@@ -7,8 +7,8 @@ import os
 import logging
 from typing import Tuple
 
-# Add the project root to Python path so we can import the logo downloader
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+# Add the src directory to Python path so we can import the logo downloader
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
 
 # Set up logging
 logging.basicConfig(
@@ -28,7 +28,7 @@ def download_nba_logos(force_download: bool = False) -> Tuple[int, int]:
         Tuple of (downloaded_count, failed_count)
     """
     try:
-        from src.logo_downloader import download_all_logos_for_league
+        from logo_downloader import download_all_logos_for_league
 
         logger.info("🏀 Starting NBA logo download...")
         logger.info(f"Target directory: assets/sports/nba_logos/")

scripts/fix_perms/README.md

@@ -31,6 +31,9 @@ owned by the `ledmatrix` service user or by `root`.
   systemd journal access, and the sudoers entries the web interface
   needs to control the display service.
 
+- **`fix_nhl_cache.sh`** — Targeted fix for NHL plugin cache issues
+  (clears the NHL cache and restarts the display service).
+
 - **`safe_plugin_rm.sh`** — Validates that a plugin removal path is
   inside an allowed base directory before deleting it. Used by the web
   interface (via sudo) when a user clicks **Uninstall** on a plugin —

scripts/fix_perms/fix_nhl_cache.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+"""
+Script to fix NHL cache issues on Raspberry Pi.
+This will clear the NHL cache and restart the display service.
+"""
+
+echo "=========================================="
+echo "Fixing NHL Cache Issues"
+echo "=========================================="
+
+# Clear NHL cache
+echo "Clearing NHL cache..."
+python3 clear_nhl_cache.py
+
+# Restart the display service to force fresh data fetch
+echo "Restarting display service..."
+sudo systemctl restart ledmatrix.service
+
+echo "NHL cache cleared and service restarted!"
+echo "NHL managers should now fetch fresh data from ESPN API."
+echo "Check the logs to see if NHL games are now being displayed."

scripts/install/lib_lowmem.sh

@@ -1,283 +0,0 @@
-#!/bin/bash
-#
-# Low-memory build helpers for the LED Matrix installer.
-#
-# Sourced by first_time_install.sh. These live in a separate, sourceable file
-# so the pure sizing/detection functions can be unit-tested
-# (test/test_install_lowmem.py); first_time_install.sh itself is not sourceable
-# because it self-elevates and runs top to bottom.
-#
-# Why this exists: the rgbmatrix build compiles ~45 C++ translation units, two
-# of them Cython-generated (a single cc1plus on those peaks around 400-800MB at
-# -O3). Upstream's pyproject.toml sets no [tool.scikit-build] options, so
-# scikit-build-core uses Ninja at its default of nproc+2 jobs -- six concurrent
-# compiles on a 4-core Pi. On a 512MB-1GB Pi the OOM killer reaps cc1plus and
-# pip reports only "Failed building wheel for rgbmatrix".
-#
-# The caller runs under `set -Eeuo pipefail` with an ERR trap, and these are
-# invoked from the middle of numbered steps, so nothing here may call exit and
-# the swap helpers must always return 0.
-
-# Overridable so tests can point at fixture files instead of /proc.
-LM_MEMINFO="${LM_MEMINFO:-/proc/meminfo}"
-LM_SWAPS="${LM_SWAPS:-/proc/swaps}"
-
-# Temporary swapfile created for the build and removed afterwards. Deliberately
-# never added to /etc/fstab: a malformed fstab can leave a novice with an
-# unbootable Pi, and this swap only needs to outlive the compile.
-LM_SWAPFILE="${LM_SWAPFILE:-/var/swap.ledmatrix-install}"
-
-# Bring RAM + real swap up to this much before compiling, capped per swapfile.
-LM_SWAP_TARGET_MB="${LM_SWAP_TARGET_MB:-3072}"
-LM_SWAP_MAX_MB="${LM_SWAP_MAX_MB:-2048}"
-
-# Worst-case cc1plus footprint on the Cython translation unit, used to size
-# build parallelism against available RAM.
-LM_MB_PER_JOB="${LM_MB_PER_JOB:-768}"
-
-# Set to 1 once swap is live, so lm_remove_build_swap (wired up as an EXIT
-# trap) knows whether there is anything to undo.
-LM_TEMP_SWAP_ACTIVE=0
-
-# Human-readable reason no swapfile was created, quoted back in the failure
-# message so a user who still OOMs is told why the safety net was absent.
-LM_SWAP_SKIP_REASON=""
-
-# ---------------------------------------------------------------------------
-# Pure helpers (no side effects; unit-tested)
-# ---------------------------------------------------------------------------
-
-# Total physical RAM in MB, or 0 if it cannot be determined.
-lm_total_ram_mb() {
-    # Defaults are re-resolved here as well as at source time so the function
-    # stays safe under the installer's `set -u`.
-    awk '/^MemTotal:/ {printf "%d\n", $2 / 1024; found = 1; exit} END {if (!found) print 0}' \
-        "${LM_MEMINFO:-/proc/meminfo}" 2>/dev/null || echo 0
-}
-
-# Total swap in MB, EXCLUDING zram devices.
-#
-# zram swap is compressed RAM: it consumes the very resource that is already
-# exhausted and does nothing for a build OOM. Counting it would let a
-# zram-enabled image decide it has enough swap and then fail exactly as before.
-lm_total_swap_mb() {
-    awk 'NR > 1 && $1 !~ /^\/dev\/zram/ {total += $3} END {printf "%d\n", total / 1024}' \
-        "${LM_SWAPS:-/proc/swaps}" 2>/dev/null || echo 0
-}
-
-# lm_build_jobs <ram_mb> <cores> -> max(1, min(cores, ram_mb / LM_MB_PER_JOB))
-#
-# Computed from RAM alone and never RAM+swap: handing out extra jobs because
-# swap exists just guarantees SD-card thrash, which is far slower than
-# compiling serially.
-lm_build_jobs() {
-    local ram_mb="${1:-0}" cores="${2:-1}" jobs
-    local per_job="${LM_MB_PER_JOB:-768}"
-    if [ "$cores" -lt 1 ]; then
-        cores=1
-    fi
-    jobs=$(( ram_mb / per_job ))
-    if [ "$jobs" -lt 1 ]; then
-        jobs=1
-    fi
-    if [ "$jobs" -gt "$cores" ]; then
-        jobs="$cores"
-    fi
-    echo "$jobs"
-}
-
-# lm_swap_needed_mb <ram_mb> <existing_swap_mb> -> swapfile size in MB, or 0.
-#
-# Brings RAM + real swap up to LM_SWAP_TARGET_MB, capped at LM_SWAP_MAX_MB and
-# rounded up to a 256MB multiple. Machines with enough memory get 0 and are
-# left completely untouched.
-lm_swap_needed_mb() {
-    local ram_mb="${1:-0}" swap_mb="${2:-0}" needed
-    local target="${LM_SWAP_TARGET_MB:-3072}" max="${LM_SWAP_MAX_MB:-2048}"
-    needed=$(( target - ram_mb - swap_mb ))
-    if [ "$needed" -le 0 ]; then
-        echo 0
-        return 0
-    fi
-    if [ "$needed" -gt "$max" ]; then
-        needed="$max"
-    fi
-    echo $(( ( (needed + 255) / 256 ) * 256 ))
-}
-
-# lm_build_failed_on_oom <build_output_file> -> 0 if the build was OOM-killed.
-#
-# Two independent evidence sources, because neither alone is reliable: the
-# compiler sometimes reports its own allocation failure, but when the kernel
-# OOM killer fires it writes nothing to the build's stdout. That silence is
-# exactly why the old handler misdiagnosed this as missing build tools.
-lm_build_failed_on_oom() {
-    local build_output="${1:-}" kernel_log=""
-
-    if [ -n "$build_output" ] && [ -f "$build_output" ]; then
-        if grep -qiE 'cc1plus: out of memory|virtual memory exhausted|Cannot allocate memory|MemoryError|fatal error: Killed signal terminated program|signal 9' \
-            "$build_output"; then
-            return 0
-        fi
-    fi
-
-    # LM_KERNEL_LOG_FILE lets tests supply a fixture instead of the real kernel
-    # ring buffer, which on a shared CI machine may hold unrelated OOM events.
-    if [ -n "${LM_KERNEL_LOG_FILE:-}" ]; then
-        if [ -f "$LM_KERNEL_LOG_FILE" ]; then
-            kernel_log=$(cat "$LM_KERNEL_LOG_FILE" 2>/dev/null || true)
-        fi
-    elif command -v dmesg >/dev/null 2>&1; then
-        kernel_log=$(dmesg -T 2>/dev/null || dmesg 2>/dev/null || true)
-    fi
-    if [ -z "$kernel_log" ] && [ -z "${LM_KERNEL_LOG_FILE:-}" ] && command -v journalctl >/dev/null 2>&1; then
-        kernel_log=$(journalctl -k --since "30 min ago" --no-pager 2>/dev/null || true)
-    fi
-
-    if [ -n "$kernel_log" ]; then
-        if printf '%s\n' "$kernel_log" | tail -n 300 | \
-            grep -qiE 'Out of memory: Kill|oom_kill|oom-kill|Killed process'; then
-            return 0
-        fi
-    fi
-
-    return 1
-}
-
-# lm_disk_backed_tmpdir [candidate] -> a disk-backed temp dir, or nothing.
-#
-# pip builds in $TMPDIR. Debian 13 mounts /tmp as tmpfs, so the default puts the
-# whole C++ build tree in RAM, competing with the compiler we are already trying
-# to keep under the limit. Prints a replacement only when the current TMPDIR is
-# memory-backed and the candidate is not; otherwise prints nothing and the
-# caller keeps its default.
-lm_disk_backed_tmpdir() {
-    local candidate="${1:-/var/tmp}"
-    local current="${TMPDIR:-/tmp}"
-    local current_fs="" candidate_fs=""
-
-    current_fs=$(lm_fstype_of "$current")
-    case "$current_fs" in
-        tmpfs|ramfs) ;;
-        *) return 0 ;;
-    esac
-
-    candidate_fs=$(lm_fstype_of "$candidate")
-    case "$candidate_fs" in
-        tmpfs|ramfs|"") return 0 ;;
-    esac
-
-    echo "$candidate"
-}
-
-# Filesystem type backing a path, or empty if it cannot be determined.
-lm_fstype_of() {
-    local path="${1:-/}"
-    if command -v findmnt >/dev/null 2>&1; then
-        findmnt -no FSTYPE --target "$path" 2>/dev/null | head -n 1
-        return 0
-    fi
-    if command -v stat >/dev/null 2>&1; then
-        stat -f -c %T "$path" 2>/dev/null | head -n 1
-        return 0
-    fi
-    return 0
-}
-
-# ---------------------------------------------------------------------------
-# Swap management (requires root; not unit-tested)
-# ---------------------------------------------------------------------------
-
-# lm_ensure_build_swap <needed_mb>
-#
-# Always returns 0. On any refusal it sets LM_SWAP_SKIP_REASON and leaves the
-# system untouched -- swap is a safety net for the build, never a precondition.
-lm_ensure_build_swap() {
-    local needed_mb="${1:-0}"
-    local swap_dir free_mb budget
-
-    LM_SWAP_SKIP_REASON=""
-
-    if [ "$needed_mb" -le 0 ]; then
-        LM_SWAP_SKIP_REASON="not needed (RAM and existing swap are sufficient)"
-        return 0
-    fi
-
-    if ! command -v mkswap >/dev/null 2>&1 || ! command -v swapon >/dev/null 2>&1; then
-        LM_SWAP_SKIP_REASON="mkswap/swapon are not available on this system"
-        echo "⚠ Cannot add build swap: $LM_SWAP_SKIP_REASON"
-        return 0
-    fi
-
-    # Clear a stale swapfile left by a run that was killed before its cleanup
-    # ran, so this is safe to call repeatedly.
-    if [ -e "$LM_SWAPFILE" ]; then
-        echo "Removing a leftover swapfile from a previous run: $LM_SWAPFILE"
-        swapoff "$LM_SWAPFILE" >/dev/null 2>&1 || true
-        rm -f "$LM_SWAPFILE" || true
-    fi
-
-    # Keep a working margin for the build tree itself; never eat the last GB.
-    swap_dir=$(dirname "$LM_SWAPFILE")
-    free_mb=$(df -m "$swap_dir" 2>/dev/null | awk 'NR==2{print $4}')
-    free_mb=${free_mb:-0}
-    budget=$(( free_mb - 1024 ))
-    if [ "$budget" -lt 256 ]; then
-        LM_SWAP_SKIP_REASON="only ${free_mb}MB free on ${swap_dir}, need about $(( needed_mb + 1024 ))MB"
-        echo "⚠ Skipping the build swapfile: $LM_SWAP_SKIP_REASON"
-        return 0
-    fi
-    if [ "$needed_mb" -gt "$budget" ]; then
-        echo "⚠ Trimming the build swapfile from ${needed_mb}MB to leave 1GB free on ${swap_dir}"
-        needed_mb=$(( ( budget / 256 ) * 256 ))
-    fi
-
-    echo "Adding a temporary ${needed_mb}MB swapfile for the build: $LM_SWAPFILE"
-    echo "  This is removed automatically once the build finishes."
-
-    # fallocate can produce a sparse file that mkswap rejects, and is not
-    # supported on every filesystem; dd always yields a usable file.
-    if ! fallocate -l "${needed_mb}M" "$LM_SWAPFILE" 2>/dev/null; then
-        if ! dd if=/dev/zero of="$LM_SWAPFILE" bs=1M count="$needed_mb" status=none 2>/dev/null; then
-            LM_SWAP_SKIP_REASON="could not allocate ${needed_mb}MB at $LM_SWAPFILE"
-            echo "⚠ $LM_SWAP_SKIP_REASON"
-            rm -f "$LM_SWAPFILE" || true
-            return 0
-        fi
-    fi
-
-    chmod 600 "$LM_SWAPFILE" || true
-
-    if ! mkswap "$LM_SWAPFILE" >/dev/null 2>&1; then
-        LM_SWAP_SKIP_REASON="mkswap failed on $LM_SWAPFILE"
-        echo "⚠ $LM_SWAP_SKIP_REASON"
-        rm -f "$LM_SWAPFILE" || true
-        return 0
-    fi
-
-    if ! swapon "$LM_SWAPFILE" >/dev/null 2>&1; then
-        LM_SWAP_SKIP_REASON="swapon failed on $LM_SWAPFILE"
-        echo "⚠ $LM_SWAP_SKIP_REASON"
-        rm -f "$LM_SWAPFILE" || true
-        return 0
-    fi
-
-    LM_TEMP_SWAP_ACTIVE=1
-    echo "✓ Temporary build swap active (${needed_mb}MB; total swap is now $(lm_total_swap_mb)MB)"
-    return 0
-}
-
-# Remove the temporary swapfile. Safe to call unconditionally and repeatedly.
-#
-# Wired up as an EXIT trap, so it must never return non-zero -- a failing trap
-# would surface as a spurious installer error.
-lm_remove_build_swap() {
-    if [ "${LM_TEMP_SWAP_ACTIVE:-0}" != "1" ]; then
-        return 0
-    fi
-    LM_TEMP_SWAP_ACTIVE=0
-    echo "Removing the temporary build swapfile: $LM_SWAPFILE"
-    swapoff "$LM_SWAPFILE" >/dev/null 2>&1 || true
-    rm -f "$LM_SWAPFILE" || true
-    return 0
-}

scripts/install/one-shot-install.sh

@@ -145,34 +145,6 @@ check_disk_space() {
     fi
 }
 
-# Report available memory so the user knows what to expect before the wait.
-#
-# Informational only — first_time_install.sh does the real work of capping
-# build parallelism and adding temporary swap. Never fatal: a low-RAM Pi is
-# supported, it is just slower.
-check_memory() {
-    CURRENT_STEP="Memory check"
-    if [ ! -r /proc/meminfo ]; then
-        print_warning "Cannot read /proc/meminfo, skipping memory check"
-        return 0
-    fi
-
-    TOTAL_RAM_MB=$(awk '/^MemTotal:/ {printf "%d\n", $2 / 1024; exit}' /proc/meminfo 2>/dev/null || echo 0)
-    TOTAL_RAM_MB=${TOTAL_RAM_MB:-0}
-
-    if [ "$TOTAL_RAM_MB" -eq 0 ]; then
-        print_warning "Could not determine system memory, continuing"
-    elif [ "$TOTAL_RAM_MB" -lt 2048 ]; then
-        print_warning "Low memory: ${TOTAL_RAM_MB}MB RAM"
-        echo "  The rpi-rgb-led-matrix C++ build needs more memory than this Pi has."
-        echo "  The installer will compile with fewer parallel jobs and add a temporary"
-        echo "  swapfile for the build, removing it afterwards. That step will take"
-        echo "  15-25 minutes rather than the usual 2-5."
-    else
-        print_success "Memory sufficient: ${TOTAL_RAM_MB}MB RAM"
-    fi
-}
-
 # Ensure sudo access
 check_sudo() {
     CURRENT_STEP="Sudo access check"
@@ -232,7 +204,7 @@ main() {
     print_step "LED Matrix One-Shot Installation"
     
     echo "This script will:"
-    echo "  1. Check prerequisites (network, disk space, memory, sudo)"
+    echo "  1. Check prerequisites (network, disk space, sudo)"
     echo "  2. Install system dependencies (git, python3, build tools)"
     echo "  3. Clone the LEDMatrix repository"
     echo "  4. Run the first-time installation script"
@@ -241,7 +213,6 @@ main() {
     # Check prerequisites
     check_network
     check_disk_space
-    check_memory
     check_sudo
     # Note: /tmp permissions are checked and fixed inline before running first_time_install.sh
     # (only if actually wrong, not preemptively)
@@ -257,14 +228,12 @@ main() {
         exit 1
     fi
     
-    # Update package list first. first_time_install.sh is told the lists are
-    # already fresh so it does not repeat this a minute later.
+    # Update package list first
     if [ "$EUID" -eq 0 ]; then
         retry apt-get update -qq
     else
         retry sudo apt-get update -qq
     fi
-    export LEDMATRIX_APT_UPDATED=1
     
     # Install git and curl (needed for cloning and the script itself)
     if ! command -v git >/dev/null 2>&1 || ! command -v curl >/dev/null 2>&1; then
@@ -403,12 +372,7 @@ main() {
         # Pass both -y flag AND environment variable for non-interactive mode
         # This ensures it works even if the script re-executes itself with sudo
         # Also ensure stdin is properly handled for non-interactive mode
-        # LEDMATRIX_APT_UPDATED is passed explicitly rather than relying on
-        # -E: a sudoers env_reset/env_keep policy can strip exported variables,
-        # which would silently reinstate the duplicate apt update.
-        sudo -E env TMPDIR=/tmp LEDMATRIX_ASSUME_YES=1 \
-            LEDMATRIX_APT_UPDATED="${LEDMATRIX_APT_UPDATED:-0}" \
-            bash ./first_time_install.sh -y </dev/null
+        sudo -E env TMPDIR=/tmp LEDMATRIX_ASSUME_YES=1 bash ./first_time_install.sh -y </dev/null
     fi
     INSTALL_EXIT_CODE=$?
     trap 'on_error $LINENO' ERR  # Re-enable ERR trap

scripts/install_dependencies_apt.py

@@ -44,12 +44,17 @@ def install_via_apt(package_name: str) -> Tuple[bool, str]:
     apt_package_map = {
         'flask': 'python3-flask',
         'PIL': 'python3-pil',
-        'freetype-py': 'python3-freetype',
+        'freetype': 'python3-freetype',
         'psutil': 'python3-psutil',
         'werkzeug': 'python3-werkzeug',
         'numpy': 'python3-numpy',
         'requests': 'python3-requests',
-        'pytz': 'python3-tz'
+        'python-dateutil': 'python3-dateutil',
+        'pytz': 'python3-tz',
+        'geopy': 'python3-geopy',
+        'unidecode': 'python3-unidecode',
+        'websockets': 'python3-websockets',
+        'websocket-client': 'python3-websocket-client'
     }
 
     apt_package = apt_package_map.get(package_name, f'python3-{package_name}')
@@ -76,8 +81,8 @@ def install_via_pip(package_name: str) -> Tuple[bool, str]:
     pip RECORD file, so an uninstall attempt fails with "uninstall-no-record-file"
     and aborts the whole install. With --ignore-installed, pip lays the new
     version down in /usr/local where it shadows the apt copy instead of removing
-    it. This matters when a pip dependency needs to upgrade an apt-managed
-    package (e.g. a package that pulls a newer requests).
+    it. This matters when a pip dependency (google-api-python-client pulls a
+    newer requests) needs to upgrade an apt-managed package.
 
     Returns (success, output).
     """
@@ -96,7 +101,8 @@ def install_via_pip(package_name: str) -> Tuple[bool, str]:
 
 # Distribution (pip/apt) names whose importable module name differs.
 IMPORT_NAME_MAP = {
-    'freetype-py': 'freetype',
+    'python-dateutil': 'dateutil',
+    'websocket-client': 'websocket',
 }
 
 
@@ -141,12 +147,17 @@ def main():
     required_packages = [
         'flask',
         'PIL',
-        'freetype-py',
+        'freetype',
         'psutil',
         'werkzeug',
         'numpy',
         'requests',
-        'pytz'
+        'python-dateutil',
+        'pytz',
+        'geopy',
+        'unidecode',
+        'websockets',
+        'websocket-client'
     ]
 
     failed_packages = []
@@ -166,12 +177,15 @@ def main():
                 failure_details[package] = pip_output or apt_output
 
     # Install packages that don't have apt equivalents
-    # Packages without apt equivalents. Plugin-specific dependencies
-    # (timezonefinder, google-api stack, icalevents, socketio, ...) are
-    # no longer installed here — store plugins declare their own
-    # requirements.txt, which the plugin store installs.
     special_packages = [
+        'timezonefinder>=6.5.0,<7.0.0',
+        'google-auth-oauthlib>=1.2.0,<2.0.0',
+        'google-auth-httplib2>=0.2.0,<1.0.0',
+        'google-api-python-client>=2.147.0,<3.0.0',
         'spotipy',
+        'icalevents',
+        'python-socketio>=5.11.0,<6.0.0',
+        'python-engineio>=4.9.0,<5.0.0'
     ]
 
     for package in special_packages:

scripts/prove_security.py

@@ -1,593 +0,0 @@
-#!/usr/bin/env python3
-"""
-LEDMatrix Security Proof Tests
-
-Automated proofs that run in CI to verify security properties hold on every
-commit. Inspired by the Huntarr security review approach of using standard
-tooling to confirm specific vulnerability classes are absent.
-
-Usage:
-    python scripts/prove_security.py
-    python scripts/prove_security.py --verbose
-    python scripts/prove_security.py --output results.json
-
-Exit code: 1 only if CRITICAL findings are detected. Warnings are reported
-but do not block CI.
-"""
-
-import ast
-import argparse
-import hashlib
-import json
-import re
-import sys
-from dataclasses import dataclass, asdict
-from pathlib import Path
-
-PROJECT_ROOT = Path(__file__).resolve().parent.parent
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Result dataclass
-# ─────────────────────────────────────────────────────────────────────────────
-
-@dataclass
-class TestResult:
-    test_id: str
-    severity: str   # PASS | INFO | WARNING | CRITICAL | SKIP
-    message: str
-    details: str = ""
-
-    def to_dict(self) -> dict:
-        return asdict(self)
-
-    @property
-    def icon(self) -> str:
-        return {
-            "PASS": "✅",  # nosec B105 - severity label, not a credential
-            "INFO": "ℹ️ ",
-            "WARNING": "⚠️ ",
-            "CRITICAL": "🚨",
-            "SKIP": "⏭️ ",
-        }.get(self.severity, "❓")
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# T1: Plugin Loading / Zip Slip
-# ─────────────────────────────────────────────────────────────────────────────
-
-def test_t1a_zip_slip_protection() -> TestResult:
-    """
-    Verify that zip-slip protection actually guards zip extraction in
-    store_manager.py.
-
-    A whole-file substring check for "is_relative_to"/"Zip-slip detected"
-    would pass even if the guard existed somewhere unrelated, or covered
-    only one of several extract()/extractall() call sites. Instead, this
-    walks the AST: for every extract()/extractall() call, it confirms an
-    is_relative_to() check (and the "Zip-slip detected" log) appears
-    earlier in that same enclosing function -- validate-then-bulk-extract
-    (validate every member, then call extractall() only after all passed)
-    counts as protecting the call, since it covers the same member list.
-    """
-    store_manager = PROJECT_ROOT / "src" / "plugin_system" / "store_manager.py"
-    if not store_manager.exists():
-        return TestResult("T1a", "CRITICAL",
-                          "store_manager.py not found",
-                          f"Expected at {store_manager}")
-
-    content = store_manager.read_text(encoding="utf-8")
-    try:
-        tree = ast.parse(content, filename=str(store_manager))
-    except SyntaxError as exc:
-        return TestResult("T1a", "CRITICAL",
-                          "store_manager.py could not be parsed",
-                          str(exc))
-
-    extraction_sites = 0
-    unprotected: list[str] = []
-
-    for func in ast.walk(tree):
-        if not isinstance(func, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            continue
-
-        extract_calls = [
-            node for node in ast.walk(func)
-            if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute)
-            and node.func.attr in ("extract", "extractall")
-        ]
-        if not extract_calls:
-            continue
-        extraction_sites += len(extract_calls)
-
-        guard_lines = [
-            n.lineno for n in ast.walk(func)
-            if isinstance(n, ast.Attribute) and n.attr == "is_relative_to"
-        ]
-        has_zip_slip_log = any(
-            isinstance(n, ast.Constant) and isinstance(n.value, str)
-            and "Zip-slip detected" in n.value
-            for n in ast.walk(func)
-        )
-
-        for call in extract_calls:
-            guarded = has_zip_slip_log and any(g < call.lineno for g in guard_lines)
-            if not guarded:
-                unprotected.append(
-                    f"{func.name}() line {call.lineno}: {call.func.attr}() call not "
-                    f"clearly preceded by an is_relative_to() guard + Zip-slip log "
-                    f"in the same function"
-                )
-
-    if extraction_sites == 0:
-        return TestResult("T1a", "WARNING",
-                          "No zipfile extract()/extractall() calls found in store_manager.py",
-                          "Verify plugin installation no longer extracts zip archives, "
-                          "or that this check still targets the right file")
-
-    if unprotected:
-        return TestResult("T1a", "CRITICAL",
-                          f"{len(unprotected)} of {extraction_sites} zip extraction "
-                          f"call(s) not clearly guarded",
-                          "; ".join(unprotected))
-
-    return TestResult("T1a", "PASS",
-                      "Zip-slip protection verified",
-                      f"All {extraction_sites} extract()/extractall() call(s) in "
-                      f"store_manager.py are preceded by an is_relative_to() guard "
-                      f"with a Zip-slip log in the same function")
-
-
-def test_t1b_dangerous_plugin_calls() -> list[TestResult]:
-    """
-    Scan plugin directories for dangerous function calls (eval, exec).
-    These represent arbitrary code execution risks in plugin code.
-    """
-    results = []
-    plugin_dirs = [
-        PROJECT_ROOT / "plugins",
-        PROJECT_ROOT / "plugin-repos",
-    ]
-
-    violations: list[str] = []
-    files_scanned = 0
-
-    scan_errors: list[str] = []
-
-    for base in plugin_dirs:
-        if not base.exists():
-            continue
-        for plugin_dir in sorted(base.iterdir()):
-            if not plugin_dir.is_dir() or plugin_dir.name.startswith(('.', '_')):
-                continue
-            for py_file in plugin_dir.rglob("*.py"):
-                files_scanned += 1
-                try:
-                    source = py_file.read_text(encoding="utf-8")
-                    tree = ast.parse(source, filename=str(py_file))
-                    for node in ast.walk(tree):
-                        if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
-                            if node.func.id in ("eval", "exec"):
-                                rel = py_file.relative_to(PROJECT_ROOT)
-                                violations.append(
-                                    f"{rel}:{node.lineno} — {node.func.id}() call")
-                except (SyntaxError, OSError) as exc:
-                    # A file we couldn't parse/read was never actually
-                    # scanned for eval()/exec() -- that must block this
-                    # test, not silently pass as if it were clean.
-                    rel = py_file.relative_to(PROJECT_ROOT)
-                    scan_errors.append(f"{rel} — {type(exc).__name__}: {exc}")
-
-    if scan_errors:
-        results.append(TestResult(
-            "T1b", "CRITICAL",
-            f"{len(scan_errors)} plugin file(s) could not be scanned for eval()/exec()",
-            "; ".join(scan_errors[:10])
-        ))
-
-    if violations:
-        results.append(TestResult(
-            "T1b", "CRITICAL",
-            f"Dangerous function calls found in plugins ({len(violations)} instance(s))",
-            "; ".join(violations[:10])
-        ))
-    elif not scan_errors:
-        results.append(TestResult(
-            "T1b", "PASS",
-            "No eval()/exec() calls found in plugins",
-            f"{files_scanned} plugin Python files scanned"
-        ))
-
-    return results
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# T2: API Surface Inventory
-# ─────────────────────────────────────────────────────────────────────────────
-
-def test_t2a_api_surface_inventory() -> TestResult:
-    """
-    Document the API surface area.
-
-    This app intentionally has no authentication (local-only Raspberry Pi
-    design, documented in web_interface/app.py). This test produces an
-    inventory for audit purposes and warns only if the design-intent comment
-    is removed from app.py (which would indicate someone deleted the rationale
-    without adding auth, rather than a deliberate undocumented change).
-    """
-    api_file = PROJECT_ROOT / "web_interface" / "blueprints" / "api_v3.py"
-    app_file = PROJECT_ROOT / "web_interface" / "app.py"
-
-    if not api_file.exists():
-        return TestResult("T2a", "WARNING", "api_v3.py not found", str(api_file))
-
-    api_content = api_file.read_text(encoding="utf-8")
-    routes = re.findall(r"@api_v3\.route\('([^']+)'", api_content)
-
-    csrf_documented = False
-    if app_file.exists():
-        app_content = app_file.read_text(encoding="utf-8")
-        csrf_documented = "CSRF protection disabled for local-only" in app_content
-
-    summary = (
-        f"{len(routes)} API routes in api_v3.py. "
-        f"No auth decorators (intentional local-only design). "
-        f"CSRF disabled: {'YES — design intent documented in app.py' if csrf_documented else 'YES — but design intent comment NOT found in app.py'}. "
-        f"Rate limiting: 1000/min."
-    )
-
-    if not csrf_documented:
-        return TestResult(
-            "T2a", "WARNING",
-            "CSRF is disabled but the design-intent comment is missing from app.py",
-            "Add the rationale comment back, or add proper CSRF protection if "
-            "the app is now internet-facing"
-        )
-
-    # There is currently no config mechanism that actually enforces the
-    # local-only boundary the design-intent comment describes -- app.py
-    # hardcodes host='0.0.0.0' unconditionally, so nothing here can confirm
-    # this deployment is in fact LAN-only. Reporting this as mere INFO
-    # understates that: an unauthenticated, CSRF-disabled API surface is a
-    # real risk the moment this ever runs somewhere other than a home LAN,
-    # documented rationale or not.
-    return TestResult(
-        "T2a", "WARNING",
-        "API surface has no auth and CSRF disabled; enforcement of the "
-        "documented local-only boundary cannot be confirmed",
-        summary
-    )
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# T3: Secrets & Credential Handling
-# ─────────────────────────────────────────────────────────────────────────────
-
-# Patterns that suggest real credentials (must be >8 chars, not placeholders)
-_SECRET_PATTERNS = [
-    (r'(?i)password\s*=\s*["\'](?!none|empty|placeholder|example|test|default|""|'')[^"\']{8,}["\']', "WARNING", "password"),
-    (r'(?i)api[_-]?key\s*=\s*["\'](?!none|empty|placeholder|YOUR_|example|test)[^"\']{16,}["\']', "WARNING", "api_key"),
-    (r'(?i)secret\s*=\s*["\'](?!none|empty|placeholder|YOUR_|example|test)[^"\']{16,}["\']', "WARNING", "secret"),
-    # Real GitHub token pattern
-    (r'ghp_[a-zA-Z0-9]{36}', "CRITICAL", "github_token"),
-    # Generic long bearer tokens
-    (r'Bearer\s+[a-zA-Z0-9\-_\.]{32,}', "WARNING", "bearer_token"),
-]
-
-_TEMPLATE_SKIP_STRINGS = [
-    "YOUR_", "PLACEHOLDER", "_HERE", "example.com", "config_secrets.template",
-    "prove_security",  # this file itself
-]
-
-_SCAN_DIRS = ["src", "web_interface", "scripts"]
-
-
-def test_t3a_hardcoded_secrets() -> TestResult:
-    """Scan source code for hardcoded credentials."""
-    violations: list[str] = []
-
-    for dir_name in _SCAN_DIRS:
-        scan_dir = PROJECT_ROOT / dir_name
-        if not scan_dir.exists():
-            continue
-        for py_file in scan_dir.rglob("*.py"):
-            # Skip test files and this script
-            if "test" in str(py_file).lower() or "prove_security" in str(py_file):
-                continue
-            try:
-                content = py_file.read_text(encoding="utf-8")
-            except OSError:
-                continue
-
-            for pattern, severity, pattern_type in _SECRET_PATTERNS:
-                for match in re.finditer(pattern, content):
-                    line_content = match.group(0)
-                    # Skip lines containing template placeholder strings.
-                    # line_content is only used for this in-memory check --
-                    # it must never be stored or included in output below.
-                    if any(skip in line_content for skip in _TEMPLATE_SKIP_STRINGS):
-                        continue
-                    rel = py_file.relative_to(PROJECT_ROOT)
-                    line_no = content[: match.start()].count("\n") + 1
-                    # Redacted fingerprint lets the same finding be recognized
-                    # across scans without ever reporting the matched
-                    # credential itself (which would otherwise get published
-                    # into CI logs, JSON artifacts, and PR comments -- wider
-                    # exposure than the original leak).
-                    fingerprint = hashlib.sha256(line_content.encode()).hexdigest()[:12]
-                    violations.append(
-                        f"[{severity}] {rel}:{line_no} — {pattern_type} "
-                        f"(fingerprint {fingerprint})"
-                    )
-
-    critical_violations = [v for v in violations if "[CRITICAL]" in v]
-    if critical_violations:
-        return TestResult(
-            "T3a", "CRITICAL",
-            f"Hardcoded secrets found ({len(critical_violations)} critical)",
-            "; ".join(critical_violations[:5])
-        )
-    if violations:
-        return TestResult(
-            "T3a", "WARNING",
-            f"Potential hardcoded secrets found ({len(violations)} instance(s))",
-            "; ".join(violations[:5])
-        )
-
-    return TestResult("T3a", "PASS", "No hardcoded secrets detected",
-                      f"Scanned {', '.join(_SCAN_DIRS)}")
-
-
-def test_t3b_plaintext_password_storage() -> TestResult:
-    """
-    Check for user account password storage without hashing.
-
-    The LEDMatrix app has no user account system, so this should produce INFO.
-    It would only CRITICAL if someone added user auth and stored passwords without hashing.
-
-    We require all three of: a password *variable assignment or DB operation*,
-    a clear storage call (INSERT / db commit / ORM save), and no hashing lib present
-    — to avoid false positives from files that contain 'password' for WiFi handling
-    and '.save()' for image/file saving in unrelated functions.
-    """
-    hashing_libs = ["bcrypt", "argon2", "pbkdf2", "scrypt",
-                    "generate_password_hash", "hashpw", "make_password"]
-    # Patterns that indicate password being stored in a database / ORM context.
-    # Must be specific enough to avoid matching set.add(), file.save(), etc.
-    db_storage_patterns = ["INSERT INTO", "db.session", "session.add(", "session.commit(", "orm.save"]
-
-    password_storage_found = False
-
-    for dir_name in _SCAN_DIRS:
-        scan_dir = PROJECT_ROOT / dir_name
-        if not scan_dir.exists():
-            continue
-        for py_file in scan_dir.rglob("*.py"):
-            try:
-                content = py_file.read_text(encoding="utf-8")
-            except OSError:
-                continue
-            # Require DB/ORM context specifically — not just any .save() call
-            if ("password" in content.lower() and
-                    any(store in content for store in db_storage_patterns) and
-                    not any(h in content for h in hashing_libs)):
-                password_storage_found = True
-
-    if password_storage_found:
-        return TestResult(
-            "T3b", "CRITICAL",
-            "Potential plaintext password storage in database/ORM detected",
-            "Found password + database storage operations without a recognized hashing library"
-        )
-
-    return TestResult("T3b", "INFO",
-                      "No plaintext password storage detected",
-                      "App has no user account system — expected result")
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# T4: Path Traversal
-# ─────────────────────────────────────────────────────────────────────────────
-
-def test_t4a_path_traversal() -> TestResult:
-    """
-    Verify static file serving uses send_from_directory (safe) rather than
-    open() with user-supplied paths. Also checks for extractall() calls that
-    lack the is_relative_to() guard.
-    """
-    issues: list[str] = []
-
-    app_file = PROJECT_ROOT / "web_interface" / "app.py"
-    if app_file.exists():
-        content = app_file.read_text(encoding="utf-8")
-        # The file-serve route should use send_from_directory or commonpath
-        if "send_from_directory" not in content and "commonpath" not in content:
-            issues.append("app.py: file-serve routes may not use send_from_directory/commonpath")
-
-    # Check all extractall() calls have a preceding is_relative_to guard
-    for py_file in (PROJECT_ROOT / "src").rglob("*.py"):
-        try:
-            content = py_file.read_text(encoding="utf-8")
-        except OSError:
-            continue
-        if "extractall(" in content and "is_relative_to" not in content:
-            rel = py_file.relative_to(PROJECT_ROOT)
-            issues.append(f"{rel}: extractall() without is_relative_to() guard")
-
-    if issues:
-        return TestResult(
-            "T4a", "WARNING",
-            f"Potential path traversal patterns found ({len(issues)})",
-            "; ".join(issues)
-        )
-
-    return TestResult("T4a", "PASS",
-                      "Path traversal mitigations verified",
-                      "send_from_directory/commonpath used for file serving; "
-                      "extractall() calls have is_relative_to() guards")
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# T5: Auth Bypass Patterns
-# ─────────────────────────────────────────────────────────────────────────────
-
-def test_t5a_auth_bypass_patterns() -> TestResult:
-    """
-    Look for broken auth bypass patterns — not the intentional no-auth design
-    (T2a covers that), but patterns that suggest auth was INTENDED to exist
-    but has an exploitable bypass: broad substring matching, debug-mode skips,
-    or if-True conditions.
-    """
-    bypass_signals = [
-        (r'if\s+True\s*:', "if True: bypass"),
-        (r'if\s+debug\s*:', "debug-mode auth skip"),
-        (r'request\.path\s+in\s+', "substring path matching in auth (Huntarr pattern)"),
-        (r'EXEMPT_ROUTES\s*=', "exempt routes list"),
-    ]
-
-    findings: list[str] = []
-
-    for dir_name in ["src", "web_interface"]:
-        scan_dir = PROJECT_ROOT / dir_name
-        if not scan_dir.exists():
-            continue
-        for py_file in scan_dir.rglob("*.py"):
-            try:
-                content = py_file.read_text(encoding="utf-8")
-            except OSError:
-                continue
-            for pattern, label in bypass_signals:
-                if re.search(pattern, content):
-                    # Only flag if the file also contains auth-related terms
-                    if any(auth in content.lower() for auth in
-                           ["auth", "login", "authenticate", "token", "permission"]):
-                        rel = py_file.relative_to(PROJECT_ROOT)
-                        findings.append(f"{rel}: {label}")
-
-    if findings:
-        return TestResult(
-            "T5a", "WARNING",
-            f"Potential auth bypass patterns found ({len(findings)})",
-            "; ".join(findings[:5])
-        )
-
-    return TestResult("T5a", "PASS",
-                      "No auth bypass patterns detected",
-                      "Checked src/ and web_interface/ for bypass signals")
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# T6: Docker / Container Hardening
-# ─────────────────────────────────────────────────────────────────────────────
-
-def test_t6_docker_hardening() -> TestResult:
-    """Container security — skipped if no Dockerfile exists."""
-    dockerfile = PROJECT_ROOT / "Dockerfile"
-    if not dockerfile.exists():
-        return TestResult("T6", "SKIP",
-                          "No Dockerfile found — container security scan not applicable",
-                          "If Docker support is added in future, enable hadolint/trivy scanning "
-                          "in .github/workflows/security-audit.yml")
-
-    content = dockerfile.read_text(encoding="utf-8")
-    issues: list[str] = []
-
-    # Check for non-root USER directive
-    user_lines = [l for l in content.splitlines() if l.strip().startswith("USER")]
-    if not user_lines or user_lines[-1].strip() == "USER root":
-        issues.append("Container runs as root — use USER directive to drop privileges")
-
-    # Check for pinned base image tags. A tag (even a specific version, not
-    # just :latest) is mutable -- the same tag can point to a different
-    # image later. Only a @sha256 digest is truly immutable/reproducible.
-    from_lines = [line for line in content.splitlines() if line.strip().startswith("FROM")]
-    for from_line in from_lines:
-        parts = from_line.split()
-        # FROM [--platform=<platform>] <image> [AS <name>] -- skip an
-        # optional --platform= flag so it's never mistaken for the image
-        # token itself (which would falsely report it as unpinned).
-        image_parts = [p for p in parts[1:] if not p.startswith("--platform=")]
-        if image_parts:
-            image = image_parts[0]
-            if "@sha256:" not in image:
-                issues.append(f"Base image not pinned to a digest: {image}")
-
-    if issues:
-        return TestResult("T6", "WARNING",
-                          f"Dockerfile hardening issues ({len(issues)})",
-                          "; ".join(issues))
-
-    return TestResult("T6", "PASS", "Dockerfile hardening checks passed", "")
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Runner
-# ─────────────────────────────────────────────────────────────────────────────
-
-def main() -> int:
-    parser = argparse.ArgumentParser(
-        description="LEDMatrix security proof tests",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    parser.add_argument("--output", "-o", default=None,
-                        help="Write JSON results to this file")
-    parser.add_argument("--verbose", "-v", action="store_true",
-                        help="Show details for each check")
-    args = parser.parse_args()
-
-    print("=" * 60)
-    print("LEDMatrix Security Proof Tests")
-    print(f"Project root: {PROJECT_ROOT}")
-    print("=" * 60)
-
-    all_results: list[TestResult] = []
-
-    # Run all test groups
-    all_results.append(test_t1a_zip_slip_protection())
-    all_results.extend(test_t1b_dangerous_plugin_calls())
-    all_results.append(test_t2a_api_surface_inventory())
-    all_results.append(test_t3a_hardcoded_secrets())
-    all_results.append(test_t3b_plaintext_password_storage())
-    all_results.append(test_t4a_path_traversal())
-    all_results.append(test_t5a_auth_bypass_patterns())
-    all_results.append(test_t6_docker_hardening())
-
-    # Print results
-    print()
-    for r in all_results:
-        line = f"  {r.icon} [{r.severity:<8}] {r.test_id}: {r.message}"
-        print(line)
-        if args.verbose and r.details:
-            print(f"             {r.details}")
-
-    # Tally
-    critical = [r for r in all_results if r.severity == "CRITICAL"]
-    warnings = [r for r in all_results if r.severity == "WARNING"]
-    passed = [r for r in all_results if r.severity == "PASS"]
-    skipped = [r for r in all_results if r.severity == "SKIP"]
-
-    print()
-    print(f"  Results: {len(passed)} PASS  {len(warnings)} WARN  "
-          f"{len(critical)} CRITICAL  {len(skipped)} SKIP")
-
-    # Write JSON output
-    if args.output:
-        output_data = [r.to_dict() for r in all_results]
-        Path(args.output).write_text(
-            json.dumps(output_data, indent=2), encoding="utf-8"
-        )
-        print(f"  Results written to: {args.output}")
-
-    if critical:
-        print(f"\n  🚨 {len(critical)} CRITICAL issue(s) found — blocking")
-        return 1
-
-    if warnings:
-        print(f"\n  ⚠️  {len(warnings)} warning(s) found — non-blocking")
-
-    print("\n  ✅ All checks passed (warnings are non-blocking)")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

scripts/remove_plugin_backups.sh

@@ -0,0 +1,117 @@
+#!/bin/bash
+
+# Script to safely remove plugin backup directories
+# These were created during the plugin-to-submodule conversion
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+PLUGINS_DIR="$PROJECT_ROOT/plugins"
+
+# Colors
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m'
+
+log_info() {
+    echo -e "${GREEN}[INFO]${NC} $1"
+}
+
+log_warn() {
+    echo -e "${YELLOW}[WARN]${NC} $1"
+}
+
+log_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# Verify submodules are working
+verify_submodules() {
+    log_info "Verifying submodules are working..."
+    local issues=0
+    
+    for submod in football-scoreboard hockey-scoreboard ledmatrix-flights \
+                  ledmatrix-leaderboard ledmatrix-stocks ledmatrix-weather \
+                  mqtt-notifications; do
+        if [ ! -d "$PLUGINS_DIR/$submod" ]; then
+            log_error "Submodule directory missing: $submod"
+            issues=$((issues + 1))
+        elif [ ! -f "$PLUGINS_DIR/$submod/.git" ]; then
+            log_error "Submodule .git file missing: $submod"
+            issues=$((issues + 1))
+        elif [ ! -f "$PLUGINS_DIR/$submod/manifest.json" ]; then
+            log_warn "Submodule manifest missing: $submod (may be OK)"
+        fi
+    done
+    
+    if [ $issues -eq 0 ]; then
+        log_info "All submodules verified ✓"
+        return 0
+    else
+        log_error "Found $issues issues with submodules"
+        return 1
+    fi
+}
+
+# Remove backup directories
+remove_backups() {
+    log_info "Removing backup directories..."
+    
+    local removed=0
+    local total_size=0
+    
+    for backup in "$PLUGINS_DIR"/*.backup*; do
+        if [ -d "$backup" ]; then
+            local name=$(basename "$backup")
+            local size=$(du -sb "$backup" 2>/dev/null | awk '{print $1}')
+            total_size=$((total_size + size))
+            
+            log_info "Removing: $name"
+            rm -rf "$backup"
+            removed=$((removed + 1))
+        fi
+    done
+    
+    if [ $removed -gt 0 ]; then
+        log_info "Removed $removed backup directory(ies)"
+        log_info "Freed approximately $(numfmt --to=iec-i --suffix=B $total_size 2>/dev/null || echo "$total_size bytes")"
+    else
+        log_info "No backup directories found"
+    fi
+}
+
+# Main
+main() {
+    cd "$PROJECT_ROOT"
+    
+    echo "=== Plugin Backup Removal Script ==="
+    echo
+    
+    # Verify submodules first
+    if ! verify_submodules; then
+        log_error "Submodule verification failed. Not removing backups."
+        log_warn "Please fix submodule issues before removing backups."
+        exit 1
+    fi
+    
+    echo
+    log_warn "This will permanently delete backup directories:"
+    ls -1d "$PLUGINS_DIR"/*.backup* 2>/dev/null | sed 's|.*/|  - |' || echo "  (none found)"
+    echo
+    
+    read -p "Continue? (y/N): " -n 1 -r
+    echo
+    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+        log_info "Aborted"
+        exit 0
+    fi
+    
+    remove_backups
+    
+    log_info "Done!"
+}
+
+main "$@"
+

scripts/render_plugin.py

@@ -28,7 +28,7 @@ os.environ['EMULATOR'] = 'true'
 # Import logger after path setup so src.logging_config is importable
 from src.logging_config import get_logger  # noqa: E402
 from src.plugin_system.testing.loading import (  # noqa: E402
-    build_full_config, find_plugin_dir, load_manifest,
+    find_plugin_dir, load_manifest, load_config_defaults,
 )
 logger = get_logger("[Render Plugin]")
 
@@ -83,13 +83,16 @@ def main() -> int:
     manifest = load_manifest(Path(plugin_dir))
 
     # Parse config: start with schema defaults, then apply overrides
+    config_defaults = load_config_defaults(Path(plugin_dir))
     try:
         user_config = json.loads(args.config)
     except json.JSONDecodeError as e:
         logger.error("Invalid JSON config: %s", e)
         return 1
 
-    config = build_full_config(Path(plugin_dir), cli_config=user_config)
+    config = {'enabled': True}
+    config.update(config_defaults)
+    config.update(user_config)
 
     # Load mock data if provided
     mock_data = {}

scripts/templates/dev_preview.html

@@ -209,11 +209,6 @@
                            onchange="onConfigChange()">
                     <span class="text-xs ml-2" style="color: var(--text-secondary);">px</span>
                 </div>
-                <select id="sizePreset" onchange="applySizePreset()"
-                        class="w-full mt-2 px-2 py-1.5 rounded text-xs"
-                        style="background: var(--bg-primary); color: var(--text-secondary); border: 1px solid var(--border-color);">
-                    <option value="">Preset sizes…</option>
-                </select>
             </div>
 
             <!-- Config form -->
@@ -247,18 +242,13 @@
                 </div>
             </details>
 
-            <!-- Render buttons -->
+            <!-- Render button -->
             <div class="flex gap-2">
                 <button onclick="renderPlugin()" id="renderBtn"
                         class="flex-1 px-4 py-2.5 rounded-lg text-sm font-medium text-white"
                         style="background: var(--accent);">
                     Render
                 </button>
-                <button onclick="renderAllSizes()" id="renderAllBtn" title="Render at every harness test size"
-                        class="px-4 py-2.5 rounded-lg text-sm font-medium"
-                        style="background: var(--bg-tertiary); color: var(--text-primary); border: 1px solid var(--border-color);">
-                    All Sizes
-                </button>
             </div>
         </div>
 
@@ -321,15 +311,6 @@
             <div id="messagesPanel" class="panel p-3 hidden">
                 <div id="messagesList" class="text-xs font-mono space-y-1"></div>
             </div>
-
-            <!-- Multi-size gallery -->
-            <div id="galleryPanel" class="panel p-4 hidden">
-                <div class="flex items-center justify-between mb-3">
-                    <span class="text-xs font-medium" style="color: var(--text-secondary);">All Sizes</span>
-                    <span class="text-xs" style="color: var(--text-secondary);" id="galleryStatus"></span>
-                </div>
-                <div id="galleryGrid" class="flex flex-wrap gap-4 items-start"></div>
-            </div>
         </div>
     </div>
 
@@ -359,30 +340,8 @@
                 opt.textContent = `${p.name} (${p.id})`;
                 select.appendChild(opt);
             });
-
-            // Load harness size presets
-            try {
-                const sizesRes = await fetch('/api/sizes');
-                const sizesData = await sizesRes.json();
-                const preset = document.getElementById('sizePreset');
-                (sizesData.sizes || []).forEach(([w, h]) => {
-                    const opt = document.createElement('option');
-                    opt.value = `${w}x${h}`;
-                    opt.textContent = `${w} x ${h}`;
-                    preset.appendChild(opt);
-                });
-            } catch (e) { /* presets are a convenience; ignore */ }
         });
 
-        function applySizePreset() {
-            const value = document.getElementById('sizePreset').value;
-            if (!value) return;
-            const [w, h] = value.split('x');
-            document.getElementById('displayWidth').value = w;
-            document.getElementById('displayHeight').value = h;
-            onConfigChange();
-        }
-
         // ---------- Plugin selection ----------
         async function onPluginChange() {
             const pluginId = document.getElementById('pluginSelect').value;
@@ -526,89 +485,6 @@
             }
         }
 
-        // ---------- Multi-size gallery ----------
-        async function renderAllSizes() {
-            if (!currentPluginId) return;
-
-            const btn = document.getElementById('renderAllBtn');
-            const panel = document.getElementById('galleryPanel');
-            const grid = document.getElementById('galleryGrid');
-            const status = document.getElementById('galleryStatus');
-            btn.disabled = true;
-            btn.textContent = 'Rendering…';
-            panel.classList.remove('hidden');
-            grid.innerHTML = '';
-            status.textContent = 'Rendering at all harness sizes…';
-
-            const config = jsonEditor ? jsonEditor.getValue() : {};
-            config.enabled = true;
-            let mockData = {};
-            const mockInput = document.getElementById('mockDataInput').value.trim();
-            if (mockInput) {
-                try { mockData = JSON.parse(mockInput); }
-                catch (e) { showMessages([], [`Mock data JSON error: ${e.message}`]); }
-            }
-
-            try {
-                const res = await fetch('/api/render-matrix', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        plugin_id: currentPluginId,
-                        config: config,
-                        mock_data: mockData,
-                    }),
-                });
-                const data = await res.json();
-                if (data.error) {
-                    status.textContent = data.error;
-                    return;
-                }
-
-                let failures = 0;
-                (data.results || []).forEach(r => {
-                    const cell = document.createElement('div');
-                    cell.style.cssText = 'display:flex;flex-direction:column;gap:4px;';
-                    const failed = (r.errors || []).length > 0 || !r.image;
-                    if (failed) failures++;
-
-                    const label = document.createElement('span');
-                    label.className = 'text-xs font-mono';
-                    label.style.color = failed ? '#f87171' : 'var(--text-secondary)';
-                    label.textContent = `${r.width}x${r.height} · ${r.render_time_ms}ms`;
-                    cell.appendChild(label);
-
-                    if (r.image) {
-                        const img = document.createElement('img');
-                        img.src = r.image;
-                        // Small panels get 2x zoom so they stay legible in the grid
-                        const zoom = r.height >= 128 ? 1 : 2;
-                        img.style.cssText =
-                            `image-rendering: pixelated; width:${r.width * zoom}px; ` +
-                            `height:${r.height * zoom}px; ` +
-                            `border:1px solid ${failed ? '#f87171' : 'var(--border-color)'};`;
-                        cell.appendChild(img);
-                    }
-                    if (failed) {
-                        const err = document.createElement('span');
-                        err.className = 'text-xs font-mono';
-                        err.style.color = '#f87171';
-                        err.textContent = (r.errors || ['render failed']).join('; ');
-                        cell.appendChild(err);
-                    }
-                    grid.appendChild(cell);
-                });
-                status.textContent = failures
-                    ? `${failures} size(s) failed`
-                    : `${(data.results || []).length} sizes rendered`;
-            } catch (e) {
-                status.textContent = `Network error: ${e.message}`;
-            } finally {
-                btn.disabled = false;
-                btn.textContent = 'All Sizes';
-            }
-        }
-
         // ---------- Zoom ----------
         function updateZoom() {
             const zoom = parseInt(document.getElementById('zoomSlider').value);

scripts/utils/clear_cache.py

@@ -8,10 +8,10 @@ import os
 import sys
 import argparse
 
-# Add the project root to the path so we can import our modules
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+# Add the src directory to the path so we can import our modules
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
 
-from src.cache_manager import CacheManager
+from cache_manager import CacheManager
 
 def list_cache_keys(cache_manager):
     """List all available cache keys."""

scripts/utils/wifi_monitor_daemon.py

@@ -78,17 +78,21 @@ class WiFiMonitorDaemon:
         
         while self.running:
             try:
-                # One combined check that also returns the state it observed —
-                # the previous flow fetched status before AND after the check
-                # on top of the check's own internal fetch, each one several
-                # nmcli subprocess forks, every 30s, forever.
-                (state_changed, updated_status, updated_ethernet,
-                 ap_active) = self.wifi_manager.check_and_manage_ap_mode_with_state()
-
+                # Get current status before checking
+                status = self.wifi_manager.get_wifi_status()
+                ethernet_connected = self.wifi_manager._is_ethernet_connected()
+                
+                # Check WiFi status and manage AP mode
+                state_changed = self.wifi_manager.check_and_manage_ap_mode()
+                
+                # Get updated status after check
+                updated_status = self.wifi_manager.get_wifi_status()
+                updated_ethernet = self.wifi_manager._is_ethernet_connected()
+                
                 current_state = {
                     'connected': updated_status.connected,
                     'ethernet_connected': updated_ethernet,
-                    'ap_active': ap_active,
+                    'ap_active': updated_status.ap_mode_active,
                     'ssid': updated_status.ssid
                 }
                 
@@ -105,7 +109,7 @@ class WiFiMonitorDaemon:
                     else:
                         logger.debug("Ethernet not connected")
                     
-                    if ap_active:
+                    if updated_status.ap_mode_active:
                         logger.info(f"AP mode ACTIVE - SSID: {ap_ssid} (IP: 192.168.4.1)")
                     else:
                         logger.debug("AP mode inactive")
@@ -119,16 +123,16 @@ class WiFiMonitorDaemon:
                     # Log periodic status (less verbose)
                     if updated_status.connected:
                         logger.debug(f"Status check: WiFi={updated_status.ssid} ({updated_status.signal}%), "
-                                   f"Ethernet={updated_ethernet}, AP={ap_active}")
+                                   f"Ethernet={updated_ethernet}, AP={updated_status.ap_mode_active}")
                     else:
-                        logger.debug(f"Status check: WiFi=disconnected, Ethernet={updated_ethernet}, AP={ap_active}")
+                        logger.debug(f"Status check: WiFi=disconnected, Ethernet={updated_ethernet}, AP={updated_status.ap_mode_active}")
                 
                 # Escalating recovery: if nmcli reports connected but actual internet
                 # is unreachable for several consecutive checks, restart NetworkManager.
                 # This is done HERE (not inside check_and_manage_ap_mode) to keep the
                 # AP-enable trigger clean and avoid false-positive AP enables from
                 # transient packet loss on otherwise working WiFi.
-                if updated_status.connected and not ap_active:
+                if updated_status.connected and not updated_status.ap_mode_active:
                     if not self.wifi_manager.check_internet_connectivity():
                         self._consecutive_internet_failures += 1
                         logger.warning(

scripts/validate_skin.py

@@ -1,248 +0,0 @@
-#!/usr/bin/env python3
-"""
-Headless skin validator — render a skin against bundled fixture games at
-multiple panel sizes without hardware, a network, or a running service.
-
-    python scripts/validate_skin.py --skin my-skin
-    python scripts/validate_skin.py --skin my-skin --sport baseball \
-        --size 128x32 --size 64x32 --output-dir /tmp/skin_renders
-
-For each (mode x size) it checks: the manifest loads and its API version
-matches, the render raises no exception, the canvas isn't blank, and the
-render finishes inside a time budget (warn — the live renderer runs every
-display-loop pass, and a Pi is far slower than your dev machine). PNGs are
-saved (native plus 4x nearest-neighbor previews) so you can eyeball the
-result. Exit code is non-zero when any check fails.
-"""
-
-import argparse
-import json
-import logging
-import sys
-import time
-from pathlib import Path
-
-PROJECT_ROOT = Path(__file__).resolve().parents[1]
-sys.path.insert(0, str(PROJECT_ROOT))
-
-from PIL import Image, ImageDraw, ImageFont  # noqa: E402
-
-FIXTURES_DIR = PROJECT_ROOT / "src" / "skin_system" / "fixtures"
-MODES = ("live", "recent", "upcoming")
-SPORTS = ("baseball", "basketball", "football", "hockey")
-RENDER_BUDGET_S = 0.100
-
-
-class FixtureHost:
-    """Stands in for a SportsCore instance: fonts, logger, logo loading,
-    outlined text — everything build_context needs, no network."""
-
-    def __init__(self, sport: str, skin_options: dict) -> None:
-        self.sport = sport
-        self.sport_key = sport
-        self.skin_options = skin_options
-        self.logger = logging.getLogger(f"validate_skin.{sport}")
-        self.fonts = self._load_fonts()
-        self._logo_cache = {}
-        self.display_manager = None  # build_context is always given a size
-
-    def _load_fonts(self) -> dict:
-        """Load the SportsCore font set (TTF, with PIL default fallback)."""
-        fonts = {}
-        try:
-            press = str(PROJECT_ROOT / "assets/fonts/PressStart2P-Regular.ttf")
-            small = str(PROJECT_ROOT / "assets/fonts/4x6-font.ttf")
-            fonts['score'] = ImageFont.truetype(press, 10)
-            fonts['time'] = ImageFont.truetype(press, 8)
-            fonts['team'] = ImageFont.truetype(press, 8)
-            fonts['status'] = ImageFont.truetype(small, 6)
-            fonts['detail'] = ImageFont.truetype(small, 6)
-            fonts['rank'] = ImageFont.truetype(press, 10)
-        except IOError:
-            default = ImageFont.load_default()
-            for key in ('score', 'time', 'team', 'status', 'detail', 'rank'):
-                fonts[key] = default
-        return fonts
-
-    def _load_and_resize_logo(self, team_id: str, team_abbrev: str,
-                              logo_path, logo_url) -> "Image.Image | None":
-        """Load a fixture logo from disk (no downloads), cached per team."""
-        if team_abbrev in self._logo_cache:
-            return self._logo_cache[team_abbrev]
-        path = Path(logo_path)
-        if not path.is_absolute():
-            path = PROJECT_ROOT / path
-        if not path.exists():
-            return None
-        logo = Image.open(path).convert('RGBA')
-        self._logo_cache[team_abbrev] = logo
-        return logo
-
-    def _draw_text_with_outline(self, draw: "ImageDraw.ImageDraw", text: str,
-                                position: tuple, font,
-                                fill: tuple = (255, 255, 255),
-                                outline_color: tuple = (0, 0, 0)) -> None:
-        """Classic outlined scorebug text, same as SportsCore's helper."""
-        x, y = position
-        for dx, dy in [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1),
-                       (1, -1), (1, 0), (1, 1)]:
-            draw.text((x + dx, y + dy), text, font=font, fill=outline_color)
-        draw.text((x, y), text, font=font, fill=fill)
-
-
-def load_fixture(sport: str, mode: str) -> dict:
-    with open(FIXTURES_DIR / f"{sport}_{mode}.json", encoding="utf-8") as f:
-        game = json.load(f)
-    # Real view models carry start_time_utc as a UTC datetime, not a string.
-    if isinstance(game.get("start_time_utc"), str):
-        from datetime import datetime
-        game["start_time_utc"] = datetime.fromisoformat(game["start_time_utc"])
-    return game
-
-
-def parse_size(value: str) -> "tuple[int, int]":
-    try:
-        w_text, h_text = value.lower().split("x")
-        w, h = int(w_text), int(h_text)
-    except ValueError as exc:
-        raise argparse.ArgumentTypeError(f"size must look like 128x32, got {value!r}") from exc
-    if w <= 0 or h <= 0:
-        raise argparse.ArgumentTypeError(f"size dimensions must be positive, got {value!r}")
-    return w, h
-
-
-def parse_options(value: str) -> dict:
-    try:
-        options = json.loads(value)
-    except json.JSONDecodeError as exc:
-        raise argparse.ArgumentTypeError(f"options must be valid JSON: {exc.msg}") from exc
-    if not isinstance(options, dict):
-        raise argparse.ArgumentTypeError("options must be a JSON object")
-    return options
-
-
-def display_path(path: Path) -> str:
-    """Repo-relative when inside the repo, absolute otherwise (--output-dir
-    may point anywhere, e.g. /tmp/skin_renders)."""
-    try:
-        return str(path.relative_to(PROJECT_ROOT))
-    except ValueError:
-        return str(path)
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__,
-                                     formatter_class=argparse.RawDescriptionHelpFormatter)
-    parser.add_argument("--skin", required=True, help="skin id (directory name under skins/)")
-    parser.add_argument("--sport", choices=SPORTS,
-                        help="fixture sport (default: first sport the skin targets, else baseball)")
-    parser.add_argument("--size", action="append", type=parse_size, dest="sizes",
-                        metavar="WxH", help="panel size to render at (repeatable; default 128x32 and 64x32)")
-    parser.add_argument("--output-dir", type=Path,
-                        default=PROJECT_ROOT / "skin_renders",
-                        help="where rendered PNGs are written")
-    parser.add_argument("--options", type=parse_options, default={},
-                        help="skin_options JSON to pass the skin")
-    args = parser.parse_args()
-    sizes = args.sizes or [(128, 32), (64, 32)]
-
-    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
-
-    from src.skin_system import skin_runtime
-    from src.skin_system.skin_base import SKIN_API_VERSION
-
-    skins = skin_runtime.discover_skins()
-    manifest = skins.get(args.skin)
-    if manifest is None:
-        print(f"FAIL: skin '{args.skin}' not found under {skin_runtime.get_skins_directory()}")
-        if skins:
-            print(f"      installed skins: {', '.join(sorted(skins))}")
-        return 1
-
-    sport = args.sport
-    if sport is None:
-        declared = skin_runtime.skin_targets(manifest)[0]
-        sport = next((s for s in declared if s in SPORTS), "baseball")
-
-    skin = skin_runtime.load_skin(args.skin, sport=sport, sport_key=sport,
-                                  options=args.options)
-    if skin is None:
-        print(f"FAIL: skin '{args.skin}' did not load "
-              f"(see log above; host API is {SKIN_API_VERSION})")
-        return 1
-
-    host = FixtureHost(sport, args.options)
-    args.output_dir.mkdir(parents=True, exist_ok=True)
-    failures = 0
-    rendered = 0
-
-    for mode in MODES:
-        game = load_fixture(sport, mode)
-        render = getattr(skin, f"render_{mode}")
-        for width, height in sizes:
-            label = f"{mode}@{width}x{height}"
-            try:
-                # Warm-up render absorbs one-time font/image loads, second
-                # render is the one timed against the budget.
-                ctx = skin_runtime.build_context(host, game, size=(width, height))
-                handled = render(ctx, dict(game))
-                if handled:
-                    ctx = skin_runtime.build_context(host, game, size=(width, height))
-                    started = time.monotonic()
-                    handled = render(ctx, dict(game))
-                    elapsed = time.monotonic() - started
-                else:
-                    elapsed = 0.0
-            except Exception as e:
-                print(f"FAIL {label}: render raised {type(e).__name__}: {e}")
-                import traceback
-                traceback.print_exc()
-                failures += 1
-                continue
-
-            if not handled:
-                print(f"skip {label}: render_{mode} returned False (built-in renderer would be used)")
-                continue
-
-            if ctx.canvas.size != (width, height):
-                print(f"FAIL {label}: canvas was replaced/resized to {ctx.canvas.size} — draw onto ctx.canvas, never reassign it")
-                failures += 1
-                continue
-            if ctx.canvas.convert("L").getbbox() is None:
-                print(f"FAIL {label}: canvas is blank — render returned True but drew nothing")
-                failures += 1
-                continue
-            if elapsed > RENDER_BUDGET_S:
-                print(f"WARN {label}: render took {elapsed * 1000:.0f}ms "
-                      f"(budget {RENDER_BUDGET_S * 1000:.0f}ms; a Pi is much slower than this machine)")
-
-            out = args.output_dir / f"{args.skin}_{sport}_{mode}_{width}x{height}.png"
-            ctx.canvas.save(out)
-            preview = ctx.canvas.resize((width * 4, height * 4), Image.NEAREST)
-            preview.save(out.with_name(out.stem + "_x4.png"))
-            print(f"ok   {label}: {elapsed * 1000:.0f}ms -> {display_path(out)}")
-            rendered += 1
-
-        # Vegas card, once per mode at the first size (optional API)
-        try:
-            width, height = sizes[0]
-            ctx = skin_runtime.build_context(host, game, size=(width, height))
-            card = skin.render_vegas_card(ctx, dict(game))
-            if card is not None:
-                out = args.output_dir / f"{args.skin}_{sport}_{mode}_vegas.png"
-                card.save(out)
-                print(f"ok   {mode} vegas card -> {display_path(out)}")
-        except Exception as e:
-            print(f"FAIL {mode} vegas card: {type(e).__name__}: {e}")
-            failures += 1
-
-    if rendered == 0 and failures == 0:
-        print(f"FAIL: skin '{args.skin}' rendered nothing — no render_<mode> returned True")
-        return 1
-    print(f"\n{'FAILED' if failures else 'PASSED'}: {rendered} renders, {failures} failures "
-          f"(PNGs in {args.output_dir})")
-    return 1 if failures else 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

skins/README.md

@@ -1,23 +0,0 @@
-# skins/
-
-User-installable **visual skins** for the sports scoreboards. Each
-subdirectory is one skin:
-
-```text
-skins/<skin-id>/
-  skin.json     # manifest
-  skin.py       # renderer (a ScoreboardSkin subclass)
-  preview.png   # optional
-```
-
-- Install a skin: `git clone <skin repo> skins/<skin-id>` (or via the Plugin
-  Store for registry entries with `"type": "skin"`).
-- Select it: set `"skin": "<skin-id>"` in the plugin's section of
-  `config/config.json`, or use the web UI's Visual Skin dropdown.
-- Build one: start from `example-classic-baseball/` and read
-  [docs/CREATING_SKINS.md](../docs/CREATING_SKINS.md). Validate with
-  `python scripts/validate_skin.py --skin <skin-id>`.
-
-Skins survive plugin reinstalls/updates (that's why they live here and not in
-the plugin's directory). A skin is Python at the same trust level as a
-plugin — review before installing.