Merge remote-tracking branch 'origin/main' into HEAD

# Conflicts:
#	CHANGELOG.md

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

@@ -36,6 +36,12 @@ jobs:
         uses: anthropics/claude-code-action@v1
         with:
           claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          # Review PRs opened by the Claude GitHub App. Without this the action
+          # aborts before reading the diff ("Workflow initiated by non-human
+          # actor"), so every such PR shows this check red. Named rather than
+          # '*': the allow-list is matched against the triggering actor, so
+          # this admits claude[bot] alone and no other app.
+          allowed_bots: 'claude'
           plugin_marketplaces: 'https://github.com/anthropics/claude-code.git'
           plugins: 'code-review@claude-code-plugins'
           prompt: '/code-review:code-review ${{ github.repository }}/pull/${{ github.event.pull_request.number }}'

.gitignore

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

CHANGELOG.md

@@ -17,8 +17,854 @@ release that ships it.
 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`.
 
+## Unreleased
+
+- The web service (`ledmatrix-web`) logs through `src.logging_config` like the
+  display service, so `journalctl -p err -u ledmatrix-web` works. Successful
+  GET/HEAD/OPTIONS requests (the UI's polling) are logged at DEBUG instead of
+  INFO; 4xx at WARNING, 5xx at ERROR. `LEDMATRIX_DEBUG=true` shows them again.
+  `web_interface/logging_config.py` is removed. The web cache
+  (`web_interface/cache.py`) now honours the TTL a value was stored with and is
+  thread-safe.
+
+- One plugin-directory resolver, `src/plugin_system/plugin_dirs.py`, behind
+  discovery, `PluginManager.get_plugin_directory`, `PluginLoader`, the store and
+  state reconciliation. A manifest's `id` wins over a directory merely named for
+  the id; hidden and `.standalone-backup-` directories are never treated as
+  plugins (auto-update could previously try to update a backup); ids like
+  `a/b` or `..` resolve to nothing everywhere. Installs where each directory is
+  named for its manifest id, the installer's layout, behave as before.
+
+- `FontManager.get_font()` returns a BDF font at its native size when asked for
+  a size the file doesn't contain (5x7.bdf at 8 or 10px, say). It used to
+  return PIL's default font, a different typeface, so a plugin that relied on
+  that will now render the font it asked for.
+- `src.wifi_manager.get_wifi_status_path()` — where WiFi status messages for
+  the display are written (`config/wifi_status.json`).
+- `src.device_location` — a blank `Location` field on a Starlark (Tidbyt) app
+  now renders at the device's City / State / Country (geocoded once via
+  Open-Meteo and cached) instead of the app author's hard-coded default,
+  usually San Francisco. A location saved on the app still wins. With no
+  device city set, or when the lookup fails or finds no match, the app keeps
+  its own default (a failed lookup is retried after 30 minutes). Clearing an
+  app's location in the web UI now actually clears it; the save used to drop
+  the blank field, so the old value stayed.
+- `src.common.bdf_font` — `load_bdf_face(path, size)` (a cached
+  `freetype.Face` plus the pixel size it really renders at, falling back to
+  the file's native strike) and `draw_bdf_text(draw, text, x, y, face, color)`.
+  `DisplayManager`, `FontManager`, `element_style` and the plugin test harness
+  now all load and draw BDF text through it; the panel's pixels are unchanged
+  and BDF text draws 10-250x faster. The plugin test harness's
+  `calendar_font` / `bdf_5x7_font` now has the panel's 7px size set: it used
+  to be an unsized face, so in golden images and `check_plugin` /
+  `dev_server` previews its text sat 6px above where the panel draws it (off
+  the canvas entirely near the top) and `get_font_height()` returned 0.
+
+- The web UI's Fonts tab has a **Used by** column: the loaded plugins that
+  registered each font with `FontManager.register_manager_font()`, published
+  by the display service to the shared cache (`src/font_usage.py`) and merged
+  into `GET /api/v3/fonts/catalog` as `used_by`. Deleting a font a plugin
+  uses now names those plugins in the confirmation (it is not blocked).
+  `FontManager.forget_manager_fonts()` is new; unloading a plugin calls it.
+
+Deprecated, removed in 3.7.0 (each logs a warning on first use; see
+`docs/PLUGIN_API_REFERENCE.md#deprecated-apis` for replacements). Nothing in
+core, the monorepo or the registry's third-party plugins calls them:
+
+- `CacheManager`: `has_data_changed`, `update_cache`, `setup_persistent_cache`,
+  `get_sport_live_interval`, `get_sport_key_from_cache_key`,
+  `get_background_cached_data`, `is_background_data_available`,
+  `record_cache_hit`, `record_cache_miss`, `record_fetch_time`,
+  `get_cache_metrics`, `log_cache_metrics`, `get_memory_cache_stats`.
+- `DisplayManager`: `draw_weather_icon`, `draw_sun`, `draw_cloud`, `draw_rain`,
+  `draw_snow`, `draw_text_with_icons`, `get_scrolling_stats`.
+- `FontManager`: `set_override`, `remove_override`, `get_overrides`,
+  `add_font`, `remove_font`, `validate_font`, `get_font_catalog`,
+  `get_available_fonts`, `get_size_tokens`, `get_performance_stats`,
+  `get_manager_fonts`, `get_detected_fonts`, `get_plugin_fonts`,
+  `unregister_plugin_fonts`.
+- `PluginManager.get_enabled_plugins`.
+
+### Config writes
+
+- A power cut or crash mid-save can no longer leave `config/config.json`
+  truncated. `ConfigManager.save_config()` wrote the file in place; it,
+  `save_config_atomic()`, `save_raw_file_content()` and backup rollback now
+  share one writer (`atomic_write_text` in `src/config_manager_atomic.py`)
+  that fsyncs a temp file, renames it into place and fsyncs the directory.
+- `save_config_atomic()` no longer rewrites `config_secrets.json` on every
+  save, only when its content changes, and rotating backups no longer re-reads
+  every backup. The backups themselves are unchanged:
+  `config/backups/config.json.backup.<version>` plus its paired secrets
+  backup, five newest kept.
+- A save by the root-run display service keeps the file's previous owner
+  instead of handing `config.json` to root, and an install path with
+  "secrets" in a directory name no longer makes `config.json` mode 0640.
+
+New names in existing modules (no new modules; a plugin importing these must
+floor on the release that ships them):
+
+- `src.common.api_helper`: `USER_AGENT`, `DEFAULT_HTTP_HEADERS` (read-only).
+- `src.logo_downloader`: `fetch_logo`, `save_png_atomically`,
+  `shared_downloader`.
+- `src.common.sports_card.unshare_element_fonts` takes an optional third
+  argument, `element_for_font` (default: the module's `ELEMENT_FOR_FONT`, so
+  existing calls are unchanged).
+
+### Sports twins
+
+- The `SportsCoreSharedMixin` helpers that behave identically to their
+  `sports_card` twins (`_card_option`, `_vs_text`, `_format_game_time`,
+  `_coerce_rgb`, `_crisp_size`, `_unshare_element_fonts`, the colour/month/
+  weekday/font-grid tables) are now thin wrappers over the `sports_card`
+  functions, and `_format_game_date` / `_schema_font_size` share its
+  formatting body and schema parser. No method was removed or renamed and
+  nothing renders differently: `test/test_sports_twins.py` checks each pair
+  against the same inputs, and the old and new mixin agree on every input
+  there. The pairs that do differ -- favourite-result colours on nested
+  payloads, the weekday's timezone, the element-name map, per-mode colours --
+  are left as they are and pinned in that test.
+
+### Logo downloads
+
+- `download_missing_logo` / `LogoDownloader.download_logo` (the path the
+  scoreboard plugins use) now stream the logo with a 10 MB cap, accept only an
+  `image/*` response that Pillow can decode, and move the finished RGBA PNG
+  into place atomically. A failed, oversized or non-image download no longer
+  leaves a partial file behind, and no longer replaces a logo already on disk.
+  `LogoHelper._download_logo` goes through the same code. Signatures and return
+  values are unchanged; saved files are pixel-identical to before.
+- `download_missing_logo` reuses one downloader (one `requests.Session`) per
+  thread instead of building a new one for every logo.
+- Placeholder logos are written atomically, without the `test_write.tmp`
+  probe file.
+
+### HTTP headers
+
+- The logo downloader and the background data service send the real
+  `LEDMatrix/1.0 (+https://github.com/ChuckBuilds/LEDMatrix)` User-Agent
+  instead of a `yourusername` / `contact@example.com` placeholder, and no
+  longer set `Accept-Encoding: ... br` by hand (brotli is not installed, so a
+  `br` response could not be decoded); requests picks the encodings.
+
+### Plugin error reporting
+
+- `/api/v3/errors/summary` and `/api/v3/errors/plugin/<id>` report the errors
+  the display service recorded. They used to read the web process's own error
+  aggregator, which never records anything, so they always answered "no
+  errors". The display service now publishes a bounded snapshot to the shared
+  cache (`plugin_error_snapshot`, at most every 10 seconds and only on change;
+  `src/error_aggregator.py`, started from `DisplayController.__init__`).
+  Responses keep their shape and add `snapshot_available`, `generated_at` and
+  `clear_pending`; exception text has credentials redacted.
+- `POST /api/v3/errors/clear` records a request (`plugin_error_clear_request`)
+  the display service applies within about 5 seconds; reads hide the cleared
+  errors at once. It accepts `"all": true`, and `cleared_count` can be `null`
+  when the count is only known to the display service.
+- The Logs tab has a **Plugin errors** panel: per-plugin counts, repeating
+  errors and a Clear button.
+- Credential redaction in exception text (`src/redaction.py`) takes time
+  proportional to the text, not its square. Two patterns were quadratic: URL
+  `user:password@`, on a long unbroken run of letters or digits (a hex digest,
+  an ID), and `Authorization:` followed by a long run of whitespace. Either
+  used to stall every thread of the display service for up to seconds each
+  time the snapshot was published: about 0.5s for 20k characters of hex, 8s
+  for 20k spaces. What gets redacted is unchanged.
+
+### Removed
+
+- **The skin system.** Skins never rendered with the current scoreboard
+  plugins, so they are gone rather than "not supported yet": `src/skin_system/`,
+  `skins/`, `scripts/validate_skin.py`, `GET /api/v3/skins`, the store's
+  `"type": "skin"` handling and `docs/SKIN_SYSTEM.md` / `docs/CREATING_SKINS.md`.
+  A `skin` or `skin_options` key left in a plugin's saved config still loads
+  and saves without a validation error; it is ignored, and the next save of
+  that plugin's settings removes it (unless the plugin's own schema declares
+  the key).
+- **`src/base_classes/`** (`SportsCore`, the sport and mode classes,
+  `CelebrationMixin`, the rotation strategies, `data_sources`,
+  `api_extractors`). No known plugin imports it. A plugin that does must use
+  `src.common` or its own copy of the code.
+
+## 3.5.0
+
+New modules a plugin may import via `src.*` (floor on 3.5.0):
+
+- `src/common/sports_helpers.py` — the helpers the scoreboards' `sports.py`
+  carry byte-identical copies of: `clamp_window`, `clamp_seconds`,
+  `logo_needs_refresh`, `spread_weighted_order` (+ `MIN_WINDOW_DAYS`,
+  `MAX_WINDOW_DAYS`), and `SportsHelpersMixin` with `_mode_customization`,
+  `_setting_int`, `_reset_dwell_on_reentry`, `_next_switch_index`,
+  `_spread_weighted_order`, `_odds_color`, `_upcoming_date_and_time_text` under
+  the plugins' names and signatures, plus the `_favorite_key` override point.
+  Constructor-free; keeps lazy state on its host (see the module docstring,
+  which also gives the host contract).
+  A new module rather than more methods on `sports_shared`: a plugin that
+  deletes a copy and leans on an older module having grown the method fails at
+  runtime with `AttributeError`, which no load-time check sees, while a missing
+  module fails at load. Nothing in core uses it yet.
+- `test/test_common_is_hardware_free.py` — `src/common` must import without
+  `rgbmatrix` and never import `src.base_classes`, `src.display_manager` or
+  `src.plugin_system` at module level.
+- `src/common/espn_dates.py` — `fetch_espn_scoreboard`,
+  `fetch_espn_date_chunks`, `espn_date_chunks`, `clamp_espn_limit`,
+  `ESPN_MAX_LIMIT`: fetch an ESPN scoreboard date range now that ESPN rejects
+  ranges (see Sports data below). Plugins bundle a copy of it.
+
+### Config saves and plugin config preparation
+
+- A JSON `POST /api/v3/config/main` changes only the keys it sends. The MQTT
+  bridge's brightness slider used to turn off `disable_hardware_pulsing`,
+  `inverse_colors`, `show_refresh_rate` and `use_short_date_format`, and a
+  timezone- or location-only save turned off web-UI autostart and weekly
+  automatic updates. Missing checkboxes still save as unchecked for the
+  settings forms (they now send a hidden `__form_section` field) and for
+  form-encoded posts.
+- A partial JSON `POST /api/v3/plugins/config` merges onto the plugin's stored
+  settings instead of resetting everything it didn't send to the schema
+  defaults, and keeps a submitted `skin`, `skin_options`, `vegas_width_pct`,
+  `vegas_overflow` or `vegas_max_width_screens` (they were silently dropped).
+- Plugin sections posted to `/config/main` are validated and prepared exactly
+  like `/plugins/config`; a value that endpoint rejects is rejected here too,
+  and nothing is saved.
+- Legacy boolean settings (#588) are read as `{"enabled": ...}` objects
+  everywhere, not just when the plugin loads: `GET /plugins/config` returns
+  the object, posting it back saves, and hot reload hands plugins the same
+  shape (schema defaults included) they were constructed with.
+  `schema_manager.prepare_plugin_config` is the one implementation.
+- A plugin's settings tab shows schema defaults for options its saved config
+  doesn't have yet. A boolean added with `"default": true` in a plugin update
+  (geochron 1.2.0's `show_date` and `show_date_line`) used to render unchecked,
+  and the next save of that tab stored it as `false`. Enum dropdowns likewise
+  showed their first option instead of the default. The partial now runs the
+  stored section through `prepare_plugin_config` like `GET /plugins/config`
+  (secrets are still masked, after the merge), and the form falls back to a
+  field's own `default` inside objects that declare a default of their own.
+- `scripts/dev_server.py`, `check_plugin.py`, `render_plugin.py` and the plugin
+  harness build configs the way a device does: nested defaults are included,
+  a schema `enabled: false` no longer beats the forced `enabled: true` in the
+  dev server, and nested overrides such as `{"nhl": {"enabled": true}}` keep
+  the other defaults of that section.
+- Clearing Vegas "Min/Max Cycle Time" no longer rejects the whole Display save,
+  and those fields no longer add junk entries to `display.display_durations`.
+- Turning automatic updates on from the Raw JSON editor finishes their setup
+  like the General tab does, instead of waiting for the next display restart.
+- `POST /config/schedule` and `/config/dim-schedule` accept the per-day
+  `days.<day>.{enabled,start_time,end_time}` shape their GETs return, as well
+  as the flat form keys.
+- The startup check no longer warns that `auto_update` or `dim_schedule` is
+  "enabled but not found in plugins directory", and plugin ids that collide
+  with any core config section are flagged: the last private copies of the
+  core-key list now use `src/core_config_keys.py`.
+
+### Sports data
+
+- Since 2026-09-15 ESPN answers `dates=YYYYMMDD-YYYYMMDD` scoreboard queries
+  with `400 Bad Request` for every sport, so season schedules, the weeks window
+  and today's games all failed ("400 Client Error" from the NFL/NCAAFB managers
+  and `src.background_data_service`). A rejected range is now re-fetched as
+  whole months (`dates=YYYYMM`) plus the leftover days at each end, which cover
+  the window exactly: a football season is 8 requests. A month that returns
+  exactly 500 events is truncated and is re-fetched day by day.
+- Scoreboard requests send `limit=500` at most. Above 500 ESPN silently returns
+  a short list: college football gave 25 of 68 games for one Saturday at the
+  `limit=1000` everything used to send.
+- `BackgroundDataService.handles_espn_date_ranges` is `True`. Plugins check it
+  to decide whether to submit a season range to the service or fetch it
+  themselves on an older core.
+- A league with no live games no longer backs its poll off past the next
+  kickoff. The escalation counted empty looks and nothing else, so a league
+  three hours before kickoff was indistinguishable from one out of season and
+  both reached `live_idle_max_interval`: measured gaps of up to 928 seconds,
+  and a rig that sat for a quarter of an hour with eight NFL games in progress
+  without noticing any of them. The wait is now clamped so it cannot run past
+  the earliest start still ahead, which the live fetch already downloads, so
+  it costs no extra request. Just after a kickoff the live cadence is held for
+  a grace window, because a provider that has not yet flipped the status would
+  otherwise read as another empty check and escalate the back-off again.
+- ESPN date chunks are fetched six at a time (`ESPN_CHUNK_WORKERS`) in two
+  passes: months and edge days first, then the days of any month that came
+  back at the cap. A cold college-baseball season is about 130 requests, and
+  they went out one at a time; March and April measured on a Pi 4 (63
+  requests, 3101 events) went from 11.2s to 1.6s. Merged events still follow
+  `espn_date_chunks` order, so the payload does not depend on which request
+  won the race, and a capped month's payload is dropped before its days are
+  fetched, which keeps the peak memory of a four-capped-month fetch to about
+  16 MB over the sequential path rather than 43 MB — `docs/LOW_MEMORY_BOARDS.md`
+  puts a 1 GB Pi 3B+ at under 200 MB of headroom.
+- `ESPNDataSource.fetch_standings` asks each league the endpoint that league
+  actually publishes. It tried `/standings` first whatever the league and fell
+  back to `/rankings` only on a 404, but college leagues answer `/standings`
+  with a 200 that carries no poll, so the fallback never fired: the rank badge
+  simply never appeared and anything keyed off rankings quietly did nothing.
+  Endpoints are now ordered by whether the league publishes a poll, and a 200
+  that lacks the key counts as a miss, so a league answering both still ends up
+  with whichever carries the poll. Only a 404 is routine — that is how a league
+  says it has none; a connection error, a timeout or an unparseable body is
+  logged as an error again, and a bug raised while inspecting the payload is no
+  longer swallowed as a missing poll. This is the implementation the football,
+  baseball and hockey boards already ship; core was the last copy on the old
+  one.
+
+### Scrolling
+
+- **Scoreboard scroll speed no longer changes with the General tab's "Scroll
+  Frame Rate" (`target_fps`).** Scoreboards on `src.common.sports_scroll`
+  computed their speed for that rate while the panel kept presenting at its
+  real refresh, so on a 100 Hz panel 60 ran a 50 px/s scoreboard at 100 px/s
+  and 200 ran it at 25 px/s. Speed now comes from `scroll_speed` and the panel
+  refresh only. The field is labelled legacy: nothing in core scrolling reads
+  it. Anyone who lowered it will see scoreboards scroll slower than before --
+  at the speed they configured.
+- `scripts/scroll_speeds.py --measure` / `--demo` open the panel with the
+  display service's own options (`DisplayManager.apply_matrix_options`), so
+  `display.runtime.gpio_slowdown`, `rp1_rio`, `panel_type` and orientation are
+  honoured; the script used to read `gpio_slowdown` from `display.hardware`.
+  Its closing advice now gives the `scroll_speed` + `scroll_delay` pair
+  instead of `scroll_pixels_per_second`, which the resolver ignores whenever
+  the pair is present.
+- The frame-stats log no longer opens a scroll with a one-frame window for
+  scrollers that never call `reset_scroll()`.
+- Removed dead scroll code: the optional scipy import (`HAS_SCIPY`),
+  `ScrollHelper._last_integer_position` and `frame_time_target`.
+  `ScrollHelper.target_fps` / `set_target_fps()` remain, documented as
+  informational.
+- Docs describe the fixed-step scroll model: `PLUGIN_API_REFERENCE.md`
+  documents `set_scrolling_state(..., frame_hold)` (omitting the hold runs a
+  scroll `frame_hold` times too fast), `SCROLL_PERFORMANCE.md` no longer reads a
+  held 20 ms frame as missed refreshes, and Vegas `frame_based_scrolling` /
+  `scroll_delay` are described as the speed clamp they are rather than frame
+  stepping. Scoreboard `scroll_delay` is documented as ignored for pacing.
+
+### Web interface
+
+- The plugin settings form honours `"x-display": "hidden"` in config schemas:
+  the property gets no control at any depth (top level, nested objects, array
+  rows, Advanced Settings), and saving the form never changes its stored value.
+  JSON API saves are unaffected. Lets plugins keep deprecated or internal keys
+  declared, e.g. countdown's row `id` and weather's `api_key` / `radar_zoom`.
+  See `docs/widget-guide.md`.
+- Display settings no longer silently cut values on save: columns were capped
+  at 128, chain length at 24 and PWM LSB nanoseconds at 500. Columns have no
+  upper limit, chain length is 1–255 and rows must be even and 8–64 (see
+  "Display hardware settings the library refuses" below);
+  parallel is 1–3 and PWM dither bits 0–2, matching the library. A stored GPIO
+  slowdown, PWM dither bits or refresh-rate cap of 0 no longer shows (and
+  re-saves) as 3, 1 or 120, and the refresh cap accepts 0 (no cap). The config
+  API rejects out-of-range or non-integer `rows`, `cols`, `chain_length`,
+  `parallel`, `brightness`, `scan_mode`, `pwm_bits`, `pwm_dither_bits`,
+  `pwm_lsb_nanoseconds`, `limit_refresh_rate_hz`, `row_address_type`,
+  `multiplexing` and `gpio_slowdown` with a 400 (JSON `true` or `5.5` used to
+  save as 1 or 5) instead of saving a config the matrix refuses to start with.
+- Display setting help tips and README / config-reference entries corrected
+  and completed: `panel_type` and `rp1_rio` are documented,
+  `show_refresh_rate` prints to the console rather than drawing on the panel,
+  PWM dither bits raise the refresh rate rather than lowering it, and every
+  numeric setting states its range.
+- Row Address Type offers 5, the SM5368 / B707 row shift register. The
+  Waveshare 96x48 V2 panel (back silkscreen `24S-A1`) needs it with RGB
+  sequence BGR and, on a Pi 4, a GPIO slowdown of 6–8. Panels with FM6124
+  column drivers need no Panel Type.
+- On a Raspberry Pi 5 the pinned rgbmatrix library can drive only row address
+  types 0 and 2, parallel 1–3 and the standard mappings. For anything else it
+  returns no matrix, which the Python binding doesn't catch, so the display
+  service crashed and restarted every 10 seconds. `DisplayManager` now refuses
+  those settings before creating the matrix (logged, reported by
+  `/api/v3/hardware/status`, fallback mode), the config API rejects them, and
+  the Display form offers only row address types 0 and 2 on a Pi 5. The rule
+  lives in `src/pi5_matrix_support.py` and must be re-checked when the
+  submodule is bumped.
+- The Plugin Config Warning no longer lists core settings as plugins that are
+  "in config but not installed" (seen as `auto_update` on 3.4.0, where the
+  advice would have deleted the weekly-update setting). Core top-level config
+  keys now live in one list, `src/core_config_keys.py`, which reconciliation
+  uses and tests pin to `config.template.json` and the settings save endpoint.
+  A stored warning is also dropped once its entry is no longer a plugin in
+  config, so an old verdict clears without a restart.
+- **Check & Update All** no longer sends installed Starlark apps
+  (`starlark:<app_id>` entries in `/plugins/installed`) to the plugin updater,
+  which answered each with a 500 "plugin not found". `POST /plugins/update`
+  now answers a `starlark:` id with a 400 saying it is a Starlark app. A
+  request that gets no HTTP answer (e.g. the web service restarting mid-run) is
+  re-sent with backoff instead of being counted as failed and skipped — that is
+  how a disabled plugin with an update waiting was silently left out.
+- Three routes consulted the web process's plugin manifests without
+  discovering plugins first, so they misbehaved from every `ledmatrix-web`
+  restart until something else ran a discovery — in practice until someone
+  opened the dashboard, measured at over three minutes on one rig.
+  `POST /display/on-demand/start` and `POST /plugins/toggle` answered 404
+  "Plugin not found", and `POST /config/main` did not recognise a plugin
+  section, so it skipped secret separation and wrote the plugin's API key to
+  `config.json` in plain text instead of `config_secrets.json`. The routes now
+  discover when nothing has been discovered yet, and rescan once when a
+  specific plugin id (or, for on-demand by mode, a mode) is not found, so a
+  plugin installed since the last scan is found too.
+
+### Security (request paths and inline handlers, siblings of #561)
+
+- `POST /api/v3/plugins/assets/upload`, `GET .../assets/list` and
+  `POST .../assets/delete` validate `plugin_id` with `src/common/path_safety`
+  and answer 400 otherwise. A `plugin_id` of `../../config` used to create an
+  `uploads/` directory outside `assets/plugins`, write images and
+  `.metadata.json` there, list it, and delete whatever file a metadata entry
+  named. Delete now unlinks only a path that resolves inside that plugin's
+  uploads directory (any other entry is dropped without touching a file).
+- `PluginManager.get_plugin_directory()` returns `None` for anything but a
+  plain name, so `POST /api/v3/plugins/action` can no longer run a manifest
+  script from a directory outside the plugins directory (`../elsewhere`); the
+  route also rejects such ids with 400.
+- Plugin Store, saved-repository and custom-registry buttons escape registry
+  values for their inline `onclick` handlers (`jsStringAttr` in
+  `plugins_manager.js`). An entry id containing `'` used to close the attribute
+  and add its own script. The store's View button opens only `http(s)` links.
+- The uploaded-images list escapes each file's original name, path and ids; a
+  name like `<img src=x onerror=...>.png` was inserted as markup.
+
+### Display hardware settings the library refuses
+
+- The rgbmatrix library answers several settings with no matrix or `abort()`
+  rather than an error, on every board, so the display service crash-looped
+  instead of falling back: rows above 64, `chain_length` above 255 (the Python
+  binding stores it in one byte; this was documented as "no upper limit"), a
+  misspelled `hardware_mapping`, and `parallel` 2–3 on a mapping with one output
+  (`adafruit-hat`, `adafruit-hat-pwm`, `regular-pi1`, `classic-pi1`) — the last
+  one reachable from the Display form on the default mapping. The config API
+  now refuses them with a 400 naming the setting, and `DisplayManager` refuses
+  a hand-edited one before creating the matrix: logged, fallback mode, reported
+  by `/api/v3/hardware/status`. The rules, including the Pi 5 ones, live in
+  `src/matrix_support.py` and must be re-checked when the submodule is bumped.
+- `/api/v3/hardware/status` adds `cause`: `"settings"` when LEDMatrix refused
+  the config, `"library"` when the library failed. The Display tab banner and
+  the fallback log line give the Pi 5 rebuild hint only for a library failure;
+  they used to follow every failure with it and with GPIO slowdown advice.
+- The Display form offers the `classic` and `classic-pi1` mappings and the
+  `90` / `270` orientations, and renders any other stored mapping selected with
+  a warning. With no option selected the browser posted the first one, so one
+  unrelated save rewrote those settings. The API accepts orientation `90` and
+  `270`, which `DisplayManager` already applied.
+- The display size the web preview, Starlark magnify default and
+  `scripts/dev/vegas_audit.py` compute (`src/display_geometry.py`) now applies
+  `orientation` and `pixel_mapper_config` as the library does: `Rotate:90`
+  swaps width and height, `U-mapper` folds the chain.
+- One Raspberry Pi 5 GPIO slowdown recommendation everywhere: 1–3 in PIO mode,
+  starting at 1. README and the config reference now describe the template
+  values as the defaults; the "code default" values they listed never apply,
+  because config migration fills missing keys from the template.
+
+### Plugin system
+
+- A plugin no longer starts with a schema warning and a degraded flag because
+  config.json still holds a boolean where its schema now has an object with an
+  `enabled` property (news' `global.dynamic_duration: true`). The loader reads
+  the boolean as `{"enabled": <bool>}` before merging schema defaults and
+  validating, the same rule the settings form already applies
+  (`legacy_bool_as_object` in `src/plugin_system/schema_manager.py`). Nothing
+  is written at load; the next save of that plugin's settings stores the object.
+  Other type mismatches still warn.
+
+### Core
+
+- `ConfigManager.load_config()` no longer raises on a host without the POSIX
+  ownership APIs. The self-heal that chgrp's `config_secrets.json` to the
+  shared group (added in #416) looked up `os.geteuid` unguarded; that name does
+  not exist on Windows, and the resulting `AttributeError` is not an `OSError`,
+  so it escaped the helper's own "best-effort" handling and every caller's.
+  Any Windows checkout with a `config/config_secrets.json` got a `ConfigError`
+  from every config load and could not `import web_interface.app` at all.
+  `ensure_shared_group_ownership()` now returns immediately when `os.geteuid`
+  or `os.chown` is missing. No behaviour change on the Pi.
+- Restoring a backup on Windows no longer fails over files that already exist.
+  The restore carries each replaced file's owner across with `os.chown`, which
+  does not exist on Windows; the `AttributeError` escaped the per-file error
+  handling, so the restore stopped at `config.json` with nothing restored. The
+  ownership step is now skipped where `os.chown` is missing. No behaviour
+  change on the Pi.
+
+### Cache permissions
+
+- The web interface can read what the display service caches again.
+  `ledmatrix-web.service` carried `CacheDirectory=ledmatrix`, and systemd
+  re-owns `/var/cache/ledmatrix` and its contents to the unit's `User=`
+  whenever the directory's owner differs, which erased the `root:ledmatrix`
+  setgid layout the installers set up: every file the root display service
+  wrote afterwards was `root:root` 0660 and unreadable by the web interface
+  (392 unreadable files on one rig, with display status, on-demand state and
+  plugin health empty). Since #547 the web unit is rendered from its template
+  on every install, so every fresh install hit this.
+  `DiskCache.set` now gives each file the directory's group (when that
+  directory is group-writable) and 0660 on the open descriptor before the
+  rename, independent of setgid, which also closes a window where a fresh
+  file was visible as mkstemp's 0600. `DiskCache.share_existing_files`
+  repairs files an older version left behind, once per process, through
+  `O_NOFOLLOW` descriptors, skipping hard links and other users' files.
+  Existing installs only ever receive `git pull`, so that repair is the fix
+  for them; new installs also drop `CacheDirectory=` and
+  `CacheDirectoryMode=` from the web unit.
+- `install_web_service.sh` replaces an existing cache directory's group
+  whenever the installing user is not in it. It used to replace only root's,
+  so a `root:ledmatrix` directory belonging to a user outside that group was
+  left alone and everything root wrote there stayed unreadable.
+- `/display/on-demand/status` and the current-display status read the display
+  service's keys with `memory_ttl=0`, as every other cross-process reader
+  already does. They served the first copy the web process had read for the
+  full 120s `max_age`, so on-demand reported "active" for over 100 seconds
+  after the file on disk said "idle".
+
+### Automatic updates and Update Code
+
+- An update that changes `web_interface/requirements.txt` is no longer rolled
+  back on every auto-updating device. `safe_pip_install.sh` allowed only the
+  root `requirements.txt`, so the install Update Code and the health check run
+  for the web requirements was refused, and the health check rolls back any
+  update whose dependencies failed (Install Base Requirements failed the same
+  way). The wrapper now allows both core requirement files; a core requirement
+  file symlinked out of the project is refused.
+- The automatic update's local-change check and Update Code now count changes
+  the same way (`auto_update.local_changes`): permission-only changes and
+  anything under `plugins/` or `plugin-repos/` don't count, and a core path
+  that merely contains `plugins/` does. Such edits used to pass the check and
+  then be stashed by the pull and never restored, despite "will not stash your
+  changes". The pull's `--autostash` now carries them across. Update Code
+  still stashes other edits; the automatic update refuses instead.
+- When the automatic update's own rollback fails (a partial pull, or a health
+  check that never started), plugins are no longer updated and the display is
+  not restarted, as the 3.4.0 notes promised.
+- The health check's dependency reinstall no longer retries pip failures or
+  timeouts with a second bash path, and all reinstalls share a 10-minute
+  budget, so a rollback finishes inside the unit's 30-minute limit instead of
+  being killed mid-way.
+
+### Installers
+
+- The generated `ledmatrix_web` sudoers rules are parsed before they are
+  installed. Both installers built the drop-in from `which` lookups and copied
+  it into `/etc/sudoers.d` without ever checking it, and a malformed file there
+  makes sudo refuse every command for every user — on a headless Pi, that is
+  unrecoverable over SSH. `first_time_install.sh` now runs `visudo -c` on the
+  generated file and, if it does not parse, prints what visudo said and leaves
+  the installed file untouched instead of replacing it with a broken one;
+  `configure_web_sudo.sh` does the same before offering the rules for
+  confirmation. `first_time_install.sh` also built that file at a fixed `/tmp`
+  path as root; `mktemp` now picks the name.
+
+### Small fixes (update-all, plugin system settings, scripts)
+
+- **Check & Update All** counts a plugin that had nothing to update as
+  "already up to date" instead of "updated". ZIP-installed monorepo plugins
+  (most official ones) already at the registry version were called "updated
+  successfully" on every run. `POST /plugins/update` now returns
+  `data.update_status` (`updated`, `up_to_date`, `local_only`).
+- An update request that got an HTTP error answer without an `error_code`, or
+  a body that is not JSON (e.g. a reverse proxy's 502 page), is no longer
+  classified as `NETWORK_ERROR` and re-sent five times. Only a request that got
+  no HTTP answer is retried; the rest are `API_ERROR` with the HTTP status.
+- The General tab no longer shows Auto Discover Plugins, Auto Load Enabled
+  Plugins or Development Mode. Nothing read `plugin_system.auto_discover`,
+  `auto_load_enabled` or `development_mode`: every enabled plugin was always
+  discovered and loaded. Stored values are kept, and saving the General tab no
+  longer rewrites them to `false`.
+- `BackgroundDataService` shares the 6-hour "ESPN rejects date ranges" memo
+  with `fetch_espn_scoreboard`, so a background season fetch no longer spends a
+  doomed range request first once either path has seen a rejection.
+- `scripts/install_plugin_dependencies.sh` installs from the configured
+  `plugin_system.plugins_directory` (default `plugin-repos`, where the Plugin
+  Store installs) and also scans `plugins/` for dev symlinks. It used to scan
+  only `plugins/` and find nothing. A failed `pip install` is now reported as a
+  failure instead of being hidden by `tee`.
+- `scripts/verify_installation.sh` no longer fails a healthy install: it
+  checked for the removed `web_interface_v2.py` and port 5001. It and
+  `scripts/verify_web_ui.sh` now check port 5000, where the web interface
+  listens.
+- `scripts/install/install_service.sh --help` prints usage and exits without
+  changes. It used to ignore the flag and reinstall and restart every service.
+  Unknown arguments are rejected before anything runs.
+- `scripts/diagnose_web_ui.sh`, `scripts/diagnose_web_interface.sh` and
+  `scripts/debug/debug_web_manual.py` apply the launcher's own autostart rule
+  (only an explicit `web_display_autostart: false` keeps the web interface
+  down), so a missing key no longer shows as disabled. The shell scripts also
+  check `web_interface/blueprints/api_v3/`, which became a package, instead of
+  reporting `api_v3.py` as missing.
+
+### Docs and developer tools
+
+- `docs/REST_API_REFERENCE.md` rechecked against every handler: request
+  fields that made documented calls fail (`repo_url`, `action_id`/`params`,
+  `files`/`image_id`, `font_file`+`font_family`, `?font=`, cache `key`,
+  `auto_enable_ap_mode`, plugin limit keys) and response shapes are fixed, the
+  removed font-override endpoints are gone, and the 26 undocumented routes
+  (backup, git/auto-update, WiFi radio, Starlark editor, MQTT bridge, status
+  endpoints, skins) are listed. Store search is `/plugins/store/list?query=`.
+- `FONT_MANAGER.md` no longer tells plugins to read
+  `display_manager.font_manager`, which does not exist; use
+  `plugin_manager.font_manager` / `BasePlugin._get_font_manager()`.
+- Plugin docs, `DisplayManager` docstrings and the bundled `starlark-apps`
+  plugin now all read the display size from `display_manager.width/height`,
+  which works in fallback mode where `matrix` is `None`.
+- `scripts/dev/dev_plugin_setup.sh link-github <name>` links the plugin from a
+  clone of the `ledmatrix-plugins` monorepo (per-plugin `ledmatrix-<name>`
+  repositories no longer exist). `dev_plugins.json` honours `github_user`,
+  `plugins_repo` and `plugins_branch`; `dev_plugins.json.example` ships and
+  `dev_plugins.json` is git-ignored. `update`/`status` handle monorepo links,
+  and `status` no longer exits 1 when nothing is broken.
+- Rewritten for current behaviour: plugin dependency installation (web service
+  runs as the installing user and installs through `safe_pip_install.sh`),
+  `PLUGIN_CONFIG_ARCHITECTURE.md`, `MULTI_ROOT_WORKSPACE_SETUP.md`; stale
+  `app.py` line numbers, `api_v3.py` paths, StreamManager method names,
+  nonexistent version-bump scripts and `ledmatrix` service user references
+  removed.
+
+## 3.4.0
+
+Plugin-facing changes since 3.3.0 (tag `v3.3.1`) not covered further down:
+
+- `BasePlugin.get_update_interval()` (#555) — return seconds to override the
+  manifest's `update_interval` at runtime (e.g. poll fast only while a game is
+  live), or `None` to keep it. Clamped to at least 5 seconds; a raising or
+  non-numeric return is ignored. Called every scheduling tick, so keep it
+  cheap. Older cores never call it. See `docs/PLUGIN_API_REFERENCE.md`.
+- `src.common.scroll_config` (#523) — turns a plugin's scroll config into a
+  configured `ScrollHelper` in one place, replacing per-plugin resolution that
+  disagreed between tickers, and warns when a speed won't advance whole pixels
+  per panel refresh. Floor on 3.4.0 to import it.
+- **Skins are marked unsupported.** No current scoreboard plugin builds on
+  `src.base_classes`, so the skin hook (`SportsCore._render_game`) never runs.
+  The web UI no longer shows the Visual Skin dropdown, the store hides and
+  refuses `"type": "skin"` entries, and `GET /api/v3/skins` reports
+  `"supported": false`. Saved `skin` config values still load and save.
+  `src/skin_system/` is unchanged.
+- **Web preview size** now comes from `src/display_geometry.py`, the same
+  computation `DisplayManager` uses: double-sided setups preview one screen,
+  and a missing `chain_length` defaults to 2 everywhere (the Starlark magnify
+  default and the sync handshake used 1). The module is core-internal: plugins
+  keep reading `display_manager.width`/`height`.
+- `src.common.font_layout` (#539, #565) — `load_truetype()` is
+  `ImageFont.truetype` with the layout engine pinned, so text lays out the same
+  whether or not the host's Pillow was built with libraqm; `crisp_size()` and
+  `FONT_PIXEL_GRID` give the size a bundled face renders on whole pixels at
+  (`sports_card` still re-exports them); `resolve_asset_path()` resolves
+  `assets/fonts/...` against the install root, not the working directory.
+  Floor on 3.4.0 to import it. Relatedly, `DisplayManager` now draws text
+  1-bit (#521), so golden images recorded against 3.3.x may need regenerating.
+
+### Install and updates
+
+**Weekly automatic updates (#581), off by default.** Switching on
+*Automatically check for and install updates once a week* on the General tab
+(or `first_time_install.sh --enable-auto-update` / `LEDMATRIX_AUTO_UPDATE=1`)
+updates the core and then every installed plugin once a week, preferably 2–5 AM
+local time. It follows the branch the checkout tracks — `main` on a standard
+install — so a device gets whatever has merged there, not only tagged releases.
+See `docs/WEB_INTERFACE_GUIDE.md`.
+
+- The core step is skipped, with the reason shown, when the checkout has local
+  edits or commits, a rebase or merge is in progress, the branch has no
+  upstream, less than 300 MB is free, or that commit was already rolled back.
+- After pulling, `ledmatrix-update-verify.service` restarts the services and
+  requires the web interface to answer and the display to stay up. If they
+  don't, or the new requirements fail to install, it resets to the previous
+  commit, reinstalls its requirements and restarts again. Anything but success
+  shows under the toggle and as a banner on Overview.
+- Plugins update through the Plugin Store even when the core step is skipped,
+  fails or is rolled back. A plugin version whose `ledmatrix_min_version` is
+  above the device's core is held back, not installed. When the core did
+  update, plugins wait for its health check, and are left alone if that check
+  never reports or the rollback fails.
+- No SSH is needed: switching the toggle on restarts the display service, which
+  installs the health-check units (`src/auto_update_setup.py`, core-internal
+  and not a plugin API).
+
+Installer and service fixes:
+
+- rgbmatrix builds on ARMv6 boards (Pi Zero, Pi 1); an existing checkout is
+  moved forward to the new pin and no longer left root-owned (#577).
+- `first_time_install.sh` grants the web user `safe_pip_install.sh`, as
+  `configure_web_sudo.sh` already did, so plugin requirements install where
+  the display service can see them (#579).
+- The web interface starts when `web_display_autostart` is missing or
+  `config.json` is unreadable; only an explicit `false` keeps it down (#556).
+- Installers render every systemd unit from its `systemd/` template, so the
+  boot-time unit-drift warning can clear, non-root installs included (#547).
+
+### Scrolling
+
+- **Frame pacing (#523).** The loop waits only for the rest of each panel
+  refresh instead of a flat 8 ms: 44–46 fps → 100 fps, and slow frames 14% →
+  0.02%, on a 2×128×64 chain. Sub-pixel blending is off by default again (it
+  shimmered on pixel fonts; Vegas mode still opts in).
+- **Whole-pixel steps (#545).** At a speed `scroll_config` can render in whole
+  pixels, every frame advances by exactly the same amount, removing about six
+  hitches a second. A loop that can't keep up now scrolls slightly slow rather
+  than jumping.
+- The eight sports scoreboards scroll through `scroll_config` too (#542): the
+  default 50 px/s holds each frame for two refreshes instead of alternating
+  0 px and 1 px steps.
+- **Frame stats ignore the pause between scrolls (#582).** The `Scroll frame
+  stats` log line counted the idle wait before each scroll as one frame,
+  inflating `max` and the stall rate. `docs/SCROLL_PERFORMANCE.md` now
+  describes the line actually logged.
+
+### Plugins
+
+- `FontManager` registers the bundled `tom_thumb` font, so plugins no longer
+  need a private loader (#534).
+- The test harness's `set_scrolling_state()` accepts `frame_hold`, as
+  `DisplayManager`'s does (#534).
+- A `display()` with nothing to draw should return `False`, the only value the
+  controller skips on; starlark-apps now does, rather than holding a black
+  panel (#534).
+- Starlark apps may set `render_width`/`render_height` in their `config.json`
+  to render at their own canvas size instead of Pixlet's 64×32 (#552).
+- `scripts/render_plugin.py --display-mode <mode>` renders one mode of a
+  multi-mode plugin; scoreboards previously rendered blank (#522).
+- Scoreboards resolve their own directory under the real plugin loader
+  (declare `_PLUGIN_DIR`), so 4x6 text snaps to its 7px grid instead of
+  rendering a pixel narrow, and an unreadable schema is logged (#519, #520).
+  `DisplayManager` loads 4x6 on that grid too (#565).
+- The 5x7 BDF face reports a real height, so rows stacked by
+  `get_font_height()` no longer overlap (#539).
+- `LogoHelper` remembers a missing logo instead of warning every rotation
+  (#548), and the decoded sports logo cache is bounded (#559).
+
+### Web interface
+
+- Installed Plugins has search, All / Enabled / Disabled / Updates filters and
+  sort (#540).
+- Hardened and polished per the September 2026 audit (#568): utility classes
+  such as `.hidden` actually exist, focus rings, labels and modal focus
+  trapping, dark theme throughout, no overflow at phone width, and background
+  streams pause when hidden, with first-load JS/CSS down from 1358 KB to 291 KB.
+- WiFi Connect works from the LEDMatrix-Setup hotspot: the page is answered
+  before the hotspot drops, and reopening it shows why an attempt failed (#571).
+- Pixlet install, the Starlark app store and app toggles work again (#535,
+  #537); the store uses the configured GitHub token and reports a rate limit
+  instead of drawing a blank grid (#541).
+- Plugin config: geochron and news saves no longer always fail (#575), the page
+  survives stored values the schema outgrew (#578), the form uses the full page
+  height (#573), and file-manager widgets show the script's error (#574).
+- The live status stream reports real disk usage and available memory (#558);
+  a system action refused for want of passwordless sudo says so and names
+  `configure_web_sudo.sh` (#560).
+
+### Tools and security
+
+- **CodeQL triage (#561):** 129 of 134 alerts fixed. Three were exploitable
+  path-handling flaws in the web interface and are closed; web UI escapers now
+  escape quotes, and URL fields refuse script schemes. Path checks share
+  `src/common/path_safety.py` (core-internal).
+- **Home Assistant MQTT bridge** (`integrations/mqtt_bridge`, #538): mode
+  select, stop, power and brightness over MQTT Discovery.
+- **Tools tab** manages the MQTT bridge and the Pixlet editor (#554); the
+  editor stays on loopback when `PIXLET_EDITOR_HOST` says so.
+
+### Fixes
+
+- Updating a plugin whose directory is named for its manifest id (leaderboard,
+  music, stocks, weather) silently did nothing (#536).
+- Plugin reconciliation no longer reports working plugins as stale or replaces
+  their config with a stub, and the Overview banner advises each case correctly
+  (#557).
+- Two config saves in the same second no longer share one backup, so rollback
+  restores the version asked for (#564).
+- On-demand: a second request is honoured without a restart (#534), a pinned
+  request stays on its mode, and restarting mid-session loads every plugin
+  again (#538).
+- `/health` and `/display/current` report real state, and the preview no longer
+  freezes on a leftover snapshot temp file (#534).
+
+### Per-element display customization
+
+**Per-element display customization, and the last mile of it into the web UI.**
+A user can set the font, size, colour, position, visibility and alignment of
+individual display elements per plugin -- and, where a plugin has display
+modes, separately per mode.
+
+New public API a plugin may import via `src.*` (floor on the release that
+ships this):
+
+- `src.element_style.layout_offset(config, element, axis, default, mode)` and
+  `element_color(config, element, default, mode)` — the stateless reads the
+  scoreboard helpers share. There were three copies of the offset read and two
+  of the colour read; these are the one implementation, and they carry the
+  element-name aliasing and the per-mode lookup.
+- `src.element_style.alias_keys(element)` — the names one element may be stored
+  under. The style block names elements `score_text` while the layout block
+  says `score`, and `records`/`record` and `status_text`/`status` split seven
+  to two across the published schemas. A lookup tries the exact name first, so
+  this is inert for a config that already matches.
+- `src.element_style.element_visible(config, element, default, mode)`,
+  `element_align(...)` and `element_scale(...)` — the stateless reads for the
+  three knobs the resolver already understood but no draw path consumed, so an
+  element could be marked hidden in the web UI and still render.
+- `SportsCoreSharedMixin._draw_text_with_outline(..., element="score_text")` —
+  naming the element resolves its colour by name and honours its visibility
+  toggle. Without a name the colour is inferred from font-object identity,
+  which cannot separate two elements sharing a face; that is the case every
+  bitmap font is in, because a `freetype.Face` cannot be re-instantiated, and
+  it is how a BDF-rendered element silently lost a configured colour. Shared
+  faces now resolve when exactly one sharer has a colour set.
+- `LogoHelper.load_logo(..., scale=)` — applies a user's image scale, and keys
+  the cache on the scaled box so two elements scaled differently cannot be
+  served each other's image.
+- `src.element_style.native_bdf_size(font)` — the one pixel size a bitmap font
+  can render at, or None for a scalable one. The web UI needs this to know
+  whether a size control can take effect at all.
+- `ElementStyleResolver(config, defaults, mode=...)` plus `visible`, `align`
+  and `scale` on `ElementStyle`. The mode binds to the resolver rather than
+  being passed per call, so a plugin with one instance per mode makes every
+  existing lookup mode-aware by setting one class attribute.
+- `BasePlugin.styles` / `styles_for(mode)` / `STYLE_MODE` — the accessor every
+  plugin inherits, so adopting this is no longer a guarded import plus schema
+  discovery plus resolver invalidation in each plugin.
+- `SportsCoreSharedMixin._get_layout_offset` — promoted from the plugins'
+  bundled copies. Each still carries its own, which wins by MRO, so adopting
+  it is a deletion.
+
+Schema and web UI:
+
+- A `customization` block is now rendered by a composite style editor: one row
+  per element rather than nested accordions, with a tab per declared mode.
+  Plugins that hand-wrote their style blocks get it without a plugin release;
+  `x-style-elements` and `x-style-modes` declare it compactly.
+- Font fields become a real picker rather than a hardcoded `enum`, so a font
+  the user uploads is selectable. Bitmap fonts taller than the element's
+  declared size ceiling are filtered out, because a bitmap font ignores
+  `font_size` and renders at its own size.
+- `/static/plugin-widgets/<plugin>/<widget>.js` serves a plugin's own web-UI
+  widgets. The client half and the docs already existed; nothing served them.
+
+Fixed:
+
+- A bitmap font asked for a size it has no strike for fell back to
+  *PressStart2P* — a different typeface — rather than to its own native size.
+  32 of the 35 shipped fonts are bitmap, so this was reachable for most font
+  choices.
+- The plugin config form read `config_schema.json` directly while the save
+  route read it through `SchemaManager`. Only the latter expands a compact
+  `x-style-elements` declaration, so a plugin using that form had a
+  customization section that rendered as empty space.
+- `unshare_element_fonts` rebuilt faces through bare `ImageFont.truetype`,
+  bypassing the layout engine `src/common/font_layout.py` pins. These were the
+  only two call sites in `src/` doing so.
+- The form parser compared a schema type to a bare string, so a nullable field
+  (`["array", "null"]`) never had its indexed colour inputs recombined, and a
+  blank one became `[]` rather than null.
+
+Removed:
+
+- The Fonts tab's "Element Font Overrides" panel and its three endpoints. They
+  reported success and saved nothing, and the element keys the panel offered
+  (`nfl.live.score`, `clock.time`) are read by no plugin, so wiring them to the
+  real `FontManager` methods would still have changed nothing on the panel.
+  Per-element font choice now lives in each plugin's own config editor.
+- "Detected Manager Fonts", which listed every installed font with a hardcoded
+  usage count.
+- Two dead client-side config-form renderers in `app-shell.js` (~580 lines) and
+  the legacy `plugins/config_manager.js`, superseded by server-side rendering.
+
 ## 3.3.0
 
+Historical note: tags `v3.3.0` and `v3.3.1` both report `__version__` "3.3.0" and both ship `src/common/sports_shared.py`, so a "3.3.0" floor always means a core with `sports_shared`.
+
 **The release the sports scoreboards floor on to delete their bundled copies.**
 3.2.0 shipped the unified sports library and made `ledmatrix_min_version`
 enforceable; this ships the last three shared modules and completes the store

CLAUDE.md

@@ -6,7 +6,7 @@
 - `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`).
   Not gitignored.
 - `plugins/` — Legacy/dev plugin location. Gitignored (`plugins/*`).
   Used by `scripts/dev/dev_plugin_setup.sh` for symlinks. The plugin
@@ -23,14 +23,14 @@
 - Each plugin needs: `manifest.json`, `config_schema.json`, `manager.py`, `requirements.txt`
 - Plugin instantiation args: `plugin_id, config, display_manager, cache_manager, plugin_manager`
 - Config schemas use JSON Schema Draft-7
-- Display dimensions: always read dynamically from `self.display_manager.matrix.width/height`
+- Display dimensions: always read dynamically from `self.display_manager.width/height` — not `display_manager.matrix.width/height`, because `matrix` is `None` when hardware init fails (the properties fall back to the canvas size)
 - Secrets: namespaced by plugin id in `config/config_secrets.json`, declared
   via `"x-secret": true` in the plugin's config schema, and deep-merged into
   the plugin's config dict at load time — plugins read them with plain
   `config.get(...)`, never a separate accessor
 
 ## Dev Workflow
-- Link a plugin for development: `./scripts/dev/dev_plugin_setup.sh link-github <name>` (or `link <name> <path>`); symlinks land in `plugins/` — set `plugin_system.plugins_directory` to `plugins` so discovery picks them up
+- Link a plugin for development: `./scripts/dev/dev_plugin_setup.sh link-github <name>` clones the `ledmatrix-plugins` monorepo into `~/.ledmatrix-dev-plugins/` and links its `plugins/<name>` under the manifest id (add a repo URL for a plugin with its own repo; or `link <name> <path>`); symlinks land in `plugins/` — set `plugin_system.plugins_directory` to `plugins` so discovery picks them up. Fork/location overrides: `dev_plugins.json` (from `dev_plugins.json.example`)
 - Browser preview without the display loop: `python3 scripts/dev_server.py` → http://localhost:5001
 - Full display in emulator mode: `python3 run.py -e` (or `EMULATOR=true python3 run.py`)
 - Validate one plugin headlessly: `python3 scripts/check_plugin.py --plugin <id>`
@@ -45,14 +45,6 @@
 - 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()`
@@ -60,3 +52,4 @@
   `self.display_manager.image.paste(img, (x, y))` then `update_display()`
   (use a mask for transparency: `image.paste(rgba, (x, y), rgba)`)
 - When modifying a plugin in the monorepo, you MUST bump `version` in its `manifest.json` and run `python update_registry.py` — otherwise users won't receive the update
+- `src/pi5_matrix_support.py` hardcodes what the pinned `rpi-rgb-led-matrix-master` can drive on a Raspberry Pi 5 (`Rp1PioConfigSupported()` in `lib/rp1/rp1_pio_backend.cc`). Re-check it whenever the submodule is bumped: a stale rule blocks Pi 5 settings the new library supports, and a missing one lets the display service crash-loop. `src/matrix_support.py` holds the same kind of rules for every board (rows, chain length, mapping names, parallel per mapping) and needs the same re-check

PRODUCT.md

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

README.md

@@ -140,21 +140,20 @@ The system supports live, recent, and upcoming game information for multiple spo
 | This project can be finnicky! RGB LED Matrix displays are not built the same or to a high-quality standard. We have seen many displays arrive dead or partially working in our discord. Please purchase from a reputable vendor. |
 
 ### Raspberry Pi
-- Raspberry Pi Zero's don't have enough processing power for this project.
-- **Raspberry Pi 3B, 4, or 5**
+- **Raspberry Pi 3B, 4, or 5** (a Pi Zero 2 W also works, with the limits described under the 1GB/low-memory bullet below; the original Pi Zero / Zero W doesn't have enough processing power for this project)
   [Amazon Affiliate Link – Raspberry Pi 4 4GB RAM](https://amzn.to/4dJixuX)
   [Amazon Affiliate Link – Raspberry Pi 4 8GB RAM](https://amzn.to/4qbqY7F)
   - **Pi 5 users**: the installer automatically detects Pi 5 and builds the `rpi-rgb-led-matrix` library with RP1 support. If you previously installed on a Pi 4 and migrated the SD card, or if you see `mmap` errors in the logs, force a fresh library build:
     ```bash
     sudo RPI_RGB_FORCE_REBUILD=1 ./first_time_install.sh
     ```
-  - Pi 5 config: leave `rp1_rio` at `0` (PIO mode, default) and 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`.
+  - Pi 5 config: leave `rp1_rio` at `0` (PIO mode, default) and start `gpio_slowdown` at `1`, raising it a step at a time if the image flickers or shows garbage (see `gpio_slowdown` under Display Settings).
+  - **1GB models (Pi 3B / 3B+), the 512MB Pi Zero 2 W and other low-memory boards**: supported, but the `rpi-rgb-led-matrix` C++ build needs more memory than the Pi has. The installer detects this automatically, compiles with fewer parallel jobs, and adds a temporary swapfile for the build which it removes afterwards. Expect that step to take 15-25 minutes instead of 2-5, and leave at least **3GB free** on the SD card. If you manage swap yourself, opt out with `--skip-swap`. To pin the compiler down further, use `--build-jobs 1`. Once running, keep an eye on memory: see [docs/LOW_MEMORY_BOARDS.md](docs/LOW_MEMORY_BOARDS.md).
 
 
 ### RGB Matrix Bonnet / HAT
 - [Adafruit RGB Matrix Bonnet/HAT](https://www.adafruit.com/product/3211) – supports one “chain” of horizontally connected displays  
-- [Adafruit Triple LED Matrix Bonnet](https://www.adafruit.com/product/6358) – supports up to 3 vertical “chains” of horizontally connected displays *(use `regular-pi1` as hardware mapping)*  
+- [Adafruit Triple LED Matrix Bonnet](https://www.adafruit.com/product/6358) – supports up to 3 vertical “chains” of horizontally connected displays *(use `regular` as hardware mapping)*  
 - [Electrodragon RGB HAT](https://www.electrodragon.com/product/rgb-matrix-panel-drive-board-raspberry-pi/) – supports up to 3 vertical “chains”  
 - [Seengreat Matrix Adapter Board](https://amzn.to/3KsnT3j) – single-chain LED Matrix *(use `regular` as hardware mapping)*  
 
@@ -173,7 +172,7 @@ The system supports live, recent, and upcoming game information for multiple spo
 
 ## Optional but recommended mod for Adafruit RGB Matrix Bonnet
 - By soldering a jumper between pins 4 and 18, you can run a specialized command for polling the matrix display. This provides better brightness, less flicker, and better color.
-- If you do the mod, we will use the default config with led-gpio-mapping=adafruit-hat-pwm, otherwise just adjust your mapping in config.json to adafruit-hat
+- The default config uses `hardware_mapping` `adafruit-hat`. If you do the mod, change it to `adafruit-hat-pwm` (Display settings in the web interface, or `config.json`)
 - More information available: https://github.com/hzeller/rpi-rgb-led-matrix/tree/master?tab=readme-ov-file
 ![DSC00079](https://github.com/user-attachments/assets/4282d07d-dfa2-4546-8422-ff1f3a9c0703)
 
@@ -347,10 +346,10 @@ If you prefer to install manually or the one-shot installer doesn't work for you
 ssh ledpi@ledpi
 ```
 
-2. Update repositories, upgrade Raspberry Pi OS, and install prerequisites:
+2. Update repositories, upgrade Raspberry Pi OS, and install git (`first_time_install.sh` installs the build dependencies itself: `python3-pip`, `python-dev-is-python3`, `build-essential`, `cmake`, `ninja-build` and the rest):
 ```bash
 sudo apt update && sudo apt upgrade -y
-sudo apt install -y git python3-pip cython3 build-essential python3-dev python3-pillow scons
+sudo apt install -y git
 ```
 
 3. Clone this repository:
@@ -400,7 +399,7 @@ If you need to manually edit your config file, you can follow the steps below:
 <summary>Manual Config.json editing </summary>
 
   1. **First-time setup**:
-     The previous "First_time_install.sh" script should've already copied the template to create your config.json:
+     The previous `first_time_install.sh` script should've already copied the template to create your config.json:
 
   2. **Edit your configuration**: 
    ```bash
@@ -459,19 +458,9 @@ You can also install plugins directly from GitHub repositories:
 
 See the [Plugin Store documentation](https://github.com/ChuckBuilds/ledmatrix-plugins) for detailed installation instructions.
 
-For plugin development, check out the [Hello World Plugin](https://github.com/ChuckBuilds/ledmatrix-hello-world) repository as a starter template.
+For plugin development, the `plugins/hello-world/` plugin in the [ledmatrix-plugins](https://github.com/ChuckBuilds/ledmatrix-plugins) repository is 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.
+**Built-in Managers Deprecated**: The built-in managers (hockey, football, stocks, etc.) are now deprecated and have been moved to the plugin system. **You must install replacement plugins from the Plugin Store** in the web interface instead. The plugin system provides the same functionality with better maintainability and extensibility.
 </details>
 
 ## Detailed Information
@@ -486,6 +475,10 @@ If you are copying my exact setup, you can likely leave the defaults alone. Howe
 
 The display settings are located in `config/config.json` under the `"display"` key and are organized into three main sections: `hardware`, `runtime`, and `display_durations`.
 
+The defaults below are the values in `config/config.template.json`. They are what applies when you haven't set a key: on every load, LEDMatrix adds any key your `config.json` lacks from the template, so `DisplayManager`'s own fallbacks are never reached on a normal install.
+
+The web UI and the config API refuse values the rgbmatrix library can't start with. If one is written into `config.json` by hand anyway, the display logs which setting it is (`Failed to initialize RGB Matrix` in `sudo journalctl -u ledmatrix`), runs in fallback mode, and the Display tab shows the message.
+
 ### Hardware Configuration (`display.hardware`)
 
 These settings control the physical hardware configuration and how the matrix is driven.
@@ -495,15 +488,18 @@ These settings control the physical hardware configuration and how the matrix is
 - **`rows`** (integer, default: 32)
   - Number of LED rows (vertical pixels) in each panel
   - Common values: 16, 32, 48, 64
+  - An even number from 8 to 64, the most the rgbmatrix library drives per panel
   - Must match your physical panel configuration
 
 - **`cols`** (integer, default: 64)
   - Number of LED columns (horizontal pixels) in each panel
   - Common values: 32, 64, 96, 128
+  - At least 16, with no upper limit
   - Must match your physical panel configuration
 
 - **`chain_length`** (integer, default: 2)
   - Number of LED panels chained together horizontally
+  - 1 to 255 (the library's Python binding stores it in one byte); longer chains lower the refresh rate
   - If you have 2 panels side-by-side, set to 2
   - If you have 4 panels in a row, set to 4
   - Total display width = `cols × chain_length`
@@ -512,68 +508,70 @@ These settings control the physical hardware configuration and how the matrix is
   - Number of parallel chains (panels stacked vertically)
   - Use 1 for a single row of panels
   - Use 2 if you have panels stacked in two rows
+  - 1–3, and no more than your `hardware_mapping` has outputs: `regular` and `classic` have 3 (e.g. the Adafruit Triple LED Matrix Bonnet); `adafruit-hat`, `adafruit-hat-pwm`, `regular-pi1` and `classic-pi1` have 1. The library stops the display service outright on a mismatch, so it is refused
   - Total display height = `rows × parallel`
 
 #### Brightness and Visual Settings
 
-- **`brightness`** (integer, 0-100, default: 90)
+- **`brightness`** (integer, 1-100, default: 90)
   - Display brightness level
-  - Lower values (0-50) are dimmer, higher values (50-100) are brighter
+  - Lower values (1-50) are dimmer, higher values (50-100) are brighter
   - Recommended: 70-90 for indoor use, 90-100 for bright environments
   - Very high brightness may cause distortion or require more power
 
 #### Hardware Mapping
 
-- **`hardware_mapping`** (string, default: "adafruit-hat-pwm")
+- **`hardware_mapping`** (string, default: "adafruit-hat")
   - Specifies which GPIO pin mapping to use for your hardware
   - **`"adafruit-hat-pwm"`**: Use this for Adafruit RGB Matrix Bonnet/HAT WITH the jumper mod (PWM enabled). This is the recommended setting for Adafruit hardware with the PWM jumper soldered.
   - **`"adafruit-hat"`**: Use this for Adafruit RGB Matrix Bonnet/HAT WITHOUT the jumper mod (no PWM). Remove `-pwm` from the value if you did not solder the jumper.
-  - **`"regular"`**: Standard GPIO pin mapping for direct GPIO connections (Generic)
+  - **`"regular"`**: Standard GPIO pin mapping for direct GPIO connections (Generic). Also the right choice for the Adafruit Triple LED Matrix Bonnet
   - **`"regular-pi1"`**: Standard GPIO pin mapping for Raspberry Pi 1 (older hardware or non-standard hat mapping)
+  - **`"classic"`** / **`"classic-pi1"`**: the library's original pin-outs, for old adapter boards wired to them. Not used by current HATs
+  - Any other name is refused. `compute-module` is only compiled in when the library is built with `ENABLE_WIDE_GPIO_COMPUTE_MODULE`, which the installer doesn't do. On a Raspberry Pi 5, `classic-pi1` isn't supported
   - Choose the option that matches your specific hardware setup, if aren't sure try them all.
+  - Hardware pulsing (see `disable_hardware_pulsing`) needs the panel's OE line on GPIO 18, which `adafruit-hat-pwm` and `regular` provide and `adafruit-hat` does not
 
 #### PWM (Pulse Width Modulation) Settings
 
 These settings affect color fidelity and smoothness of color transitions:
 
-- **`pwm_bits`** (integer, default: 9)
-  - Number of bits used for PWM (affects color depth)
-  - Higher values (9-11) = more color levels, smoother gradients
-  - Lower values (7-8) = fewer color levels, but may improve stability on some hardware
-  - Range: 1-11, recommended: 9-10
+- **`pwm_bits`** (integer, 1-11, default: 9)
+  - Color depth per channel: how many brightness levels each LED gets
+  - Higher values (9-11) = more color levels, smoother gradients, lower refresh rate
+  - Lower values (7-8) = the subtlest shades are dropped for a higher refresh rate; `1` gives 8 colors
+  - Recommended: 9-10
 
-- **`pwm_dither_bits`** (integer, default: 1)
-  - Additional dithering bits for smoother color transitions
-  - Helps reduce color banding in gradients
-  - Higher values (1-2) = smoother gradients but may impact performance
-  - Range: 0-2, recommended: 1
+- **`pwm_dither_bits`** (integer, 0-2, default: 1)
+  - Time-dithers the lowest color bits: their brightness comes from showing them on only some frames
+  - Raises the refresh rate; the cost is that dark shades can shimmer slightly
+  - `0` = steadiest dim colors, `2` = fastest
+  - The rgbmatrix library accepts only 0-2; a higher value stops the display starting
 
-- **`pwm_lsb_nanoseconds`** (integer, default: 130)
-  - Least significant bit timing in nanoseconds
-  - Controls the base timing for PWM signals
-  - Lower values = faster PWM, higher values = slower PWM
+- **`pwm_lsb_nanoseconds`** (integer, 50-3000, default: 130)
+  - On-time of the least significant color bit; each higher bit doubles it
+  - Lower values = higher refresh rate, but can cost color accuracy or add ghosting on some panels
+  - Higher values = less ghosting (faint trails behind bright text on black), lower refresh rate
   - Typical range: 100-300 nanoseconds
-  - May need adjustment if you see flickering or color issues
 
 #### Advanced Hardware Settings
 
-- **`scan_mode`** (integer, default: 0)
-  - Panel scan mode (how rows are addressed)
-  - Common values: 0 (progressive), 1 (interlaced)
-  - Most panels use 0, but some require 1
-  - Check your panel datasheet if colors appear incorrect
+- **`scan_mode`** (integer, 0-1, default: 0)
+  - Order the rows are refreshed in: `0` = progressive, `1` = interlaced
+  - Interlaced can look a little smoother when the refresh rate is very low, but usually shows a comb effect on anything moving
+  - Leave at `0` unless you are tuning a slow setup
 
 - **`limit_refresh_rate_hz`** (integer, default: 100)
-  - Maximum refresh rate in Hz (frames per second)
-  - Caps the refresh rate for better stability
-  - Lower values (60-80) = more stable, less CPU usage
-  - Higher values (100-120) = smoother animations, more CPU usage
-  - Recommended: 80-100 for most setups
+  - Caps the panel refresh rate in Hz; `0` = no cap
+  - A steady cap reduces flicker caused by other activity on the Pi, and in camera recordings
+  - Scroll speeds are worked out against this value (against 100 Hz when it is `0`), so a cap the panel can actually hold keeps scrolling even
+  - Recommended: 80-120. `sudo python3 scripts/scroll_speeds.py --measure` reports the rate your panel really achieves
 
 - **`disable_hardware_pulsing`** (boolean, default: false)
-  - Disables hardware pulsing (usually leave as false)
-  - Set to `true` only if you experience timing issues
-  - Most users should leave this as `false`
+  - `false` = the Pi's hardware PWM times each brightness pulse; `true` = software timing
+  - Leave `false` where possible. Software timing is less exact, so a row, or the whole panel, can briefly flash brighter
+  - Hardware pulsing needs the panel's OE line on GPIO 18 (`adafruit-hat-pwm`, `regular`, the Adafruit Triple LED Matrix Bonnet). With `adafruit-hat` the library uses software timing anyway
+  - It also needs the Pi's onboard sound driver (`snd_bcm2835`) disabled, which `first_time_install.sh` does. Set `true` only if you need the Pi's own audio
 
 - **`inverse_colors`** (boolean, default: false)
   - Inverts all colors (red becomes cyan, etc.)
@@ -581,9 +579,9 @@ These settings affect color fidelity and smoothness of color transitions:
   - Set to `true` only if colors appear inverted
 
 - **`show_refresh_rate`** (boolean, default: false)
-  - Displays the current refresh rate on the matrix (for debugging)
-  - Set to `true` to see FPS on the display
-  - Useful for troubleshooting performance issues
+  - Prints the live refresh rate to the console; nothing is drawn on the panel
+  - Readable when you stop the service and run `sudo python3 run.py` in a terminal; under the service the output is buffered
+  - `sudo python3 scripts/scroll_speeds.py --measure` is an easier way to see the real refresh rate
 
 #### Advanced Panel Configuration (Advanced Users Only)
 
@@ -593,6 +591,7 @@ These settings are typically only needed for non-standard panels or custom confi
   - Color channel order for your LED panel
   - Common values: "RGB", "RBG", "GRB", "GBR", "BRG", "BGR"
   - Most panels use "RGB", but some use "GRB" or other orders
+  - If red shows as blue, try "BGR" (the Waveshare 96x48 V2 needs it)
   - Check your panel datasheet if colors appear wrong
 
 - **`pixel_mapper_config`** (string, default: "")
@@ -607,35 +606,68 @@ These settings are typically only needed for non-standard panels or custom confi
   - Set to `"180"` (or use the "Upside Down" option in the web UI's Display
     settings) if the panel is mounted upside down — useful for optimizing
     where the Raspberry Pi and wiring sit relative to the mounting location
+  - `"90"` and `"270"` are for a panel mounted on its side; they swap the
+    display's width and height
   - Applied independently of `pixel_mapper_config` (appended as a trailing
-    `Rotate:180` mapper), so custom mapper configs keep working alongside it
+    `Rotate:<degrees>` mapper), so custom mapper configs keep working alongside it
 
 - **`row_address_type`** (integer, default: 0)
   - How rows are addressed on the panel
   - Most panels use 0 (direct addressing)
-  - Some panels require 1 (AB addressing) or 2 (ABC addressing)
+  - 1 = AB-addressed, 2 = direct row select, 3 = ABC-addressed,
+    4 = ABC shift + DE direct (SM5266), 5 = SM5368 / B707 row shift register
+  - ABC panels (no E line, e.g. many 128x64 FM6124 panels) use 3
+  - Panels with SM5368 row drivers use 5 with `led_rgb_sequence` `"BGR"` —
+    e.g. the Waveshare 96x48 V2 (back silkscreen `24S-A1`; the V1, `24S-A2.1`,
+    uses the defaults). This is what Waveshare's `96X48_1_24_SM5368` panel
+    type sets in their library fork.
+  - SM5368 row drivers are timing-sensitive: if rows jump up and down or the
+    bottom row shows a copy of other rows, raise `gpio_slowdown`. On a Pi 4
+    with an Adafruit Triple LED Matrix Bonnet, 4 left rows jumping; 6–8 gave a
+    stable image.
+  - On a Raspberry Pi 5 the rgbmatrix library currently supports only 0 and 2
+    (and `parallel` 1-3). Anything else would crash the display service, so on
+    a Pi 5 the web UI offers only 0 and 2, the config API refuses the others,
+    and if one is set in `config.json` anyway the display logs why and runs in
+    fallback mode
   - Check your panel datasheet if display appears corrupted
 
-- **`multiplexing`** (integer, default: 0)
-  - Panel multiplexing type
-  - 0 = no multiplexing (standard panels)
-  - Higher values for panels with different multiplexing schemes
-  - Check your panel datasheet for the correct value
+- **`multiplexing`** (integer, 0-22, default: 0)
+  - How pixels are wired on outdoor/specialty panels (P10, P8, P4 and P3 outdoor modules and similar) whose LEDs aren't laid out in straight rows
+  - `0` = direct (standard indoor panels)
+  - `1` Stripe, `2` Checkered, `3` Spiral, `4` ZStripe, `5` ZnMirrorZStripe,
+    `6` Coreman, `7` Kaler2Scan, `8` ZStripeUneven, `9` P10-128x4-Z,
+    `10` QiangLiQ8, `11` InversedZStripe, `12`–`14` P10Outdoor1R1G1B v1–v3,
+    `15` P10CoremanMapper, `16` P8Outdoor1R1G1B, `17` FlippedStripe,
+    `18` P10-32x16-HalfScan, `19` P10-32x16-QuarterScan, `20` P3Outdoor-64x64,
+    `21` DoubleZMultiplex, `22` P4Outdoor-80x40
+  - If the image is scrambled in a repeating pattern, try the value named after your panel first
+
+- **`panel_type`** (string, default: `""`)
+  - Sends a start-up initialization sequence to driver chips that need one
+  - `""` = Standard (no initialization) — right for most panels, including FM6124 / FM6124D / FM6124DJ
+  - `"FM6126A"` or `"FM6127"` for panels with those chips; try `"FM6126A"` if the panel stays dark or lights only the first pixel on Standard
 
 ### Runtime Configuration (`display.runtime`)
 
 These settings control runtime behavior and GPIO timing:
 
 - **`gpio_slowdown`** (integer, default: 3)
-  - GPIO timing slowdown factor
-  - **Critical setting**: Must match your Raspberry Pi model for stability
-  - **Raspberry Pi 3**: Use 3
-  - **Raspberry Pi 4**: Use 4
-  - **Raspberry Pi 5**: Use 1–2 in PIO mode (`rp1_rio: 0`, the default); start with `1` and increase if you see flickering
-  - **Raspberry Pi Zero/1**: Use 1-2
-  - Incorrect values can cause display corruption, flickering, or system instability
+  - GPIO timing slowdown factor (0-10): slows GPIO writes so the panel electronics keep up. Higher is more reliable but lowers the refresh rate
+  - **Critical setting**: depends on your Raspberry Pi model and your panel
+  - **Raspberry Pi Zero/1**: 0-1
+  - **Raspberry Pi 2/3**: 1-3
+  - **Raspberry Pi 4**: 2-4 (the config template ships 3)
+  - **Raspberry Pi 5**: 1–3 in PIO mode (`rp1_rio: 0`, the default). Start at `1` (the library treats `0` as `1` there) and raise it a step at a time if the image flickers or shows garbage — chained panels are the likeliest to need it
+  - Panels on `row_address_type` 5 (SM5368 row drivers) can need 6-8 on a Pi 4
+  - Too low: garbage, flicker or rows jumping. Too high: a lower refresh rate
   - If you experience issues, try adjusting this value up or down by 1
 
+- **`rp1_rio`** (integer, 0 or 1, default: 0) — Raspberry Pi 5 only
+  - Which driver the Pi 5's RP1 chip uses: `0` = PIO (default, less CPU), `1` = RIO (registered I/O, can reach a higher refresh rate)
+  - In RIO mode the effect of `gpio_slowdown` is inverted: higher values may be faster
+  - Ignored on a Pi 0-4, and applied only if the installed rgbmatrix library supports it
+
 ### Display Durations (`display.display_durations`)
 
 Controls how long each installed plugin stays visible in seconds before switching to the next one, keyed by plugin id.
@@ -668,7 +700,7 @@ Controls how long each installed plugin stays visible in seconds before switchin
   - Some plugins can automatically adjust their display time based on content
   - This setting limits how long they can extend (prevents one display from dominating)
   - Example: If set to 60, a plugin can extend up to 60 seconds even if it requests longer
-  - Leave unset to use the default cap (typically 90 seconds)
+  - Leave unset to use the default cap (180 seconds; the web UI accepts 30-1800)
 
 ### Example Configuration
 
@@ -715,6 +747,14 @@ Controls how long each installed plugin stays visible in seconds before switchin
 - Verify `hardware_mapping` matches your HAT/connection type
 - Try adjusting `gpio_slowdown`
 - Ensure your display doesn't need the E-Addressable line
+- If it went blank right after a settings change, the Display tab shows a "simulation mode" banner, and `sudo journalctl -u ledmatrix` shows `Failed to initialize RGB Matrix` followed by the reason. When LEDMatrix refused the settings (for example more than 64 `rows`, `parallel` 2 on an `adafruit-hat` mapping, a misspelled `hardware_mapping`, or on a Raspberry Pi 5 a `row_address_type` other than 0 or 2), the message names each one: change them, save, and restart the display service. Otherwise the library itself failed, and its own message just before names the problem
+- A repeating scramble points at `row_address_type` or `multiplexing`; a panel that stays dark, at `panel_type`
+
+**Rows jump up and down, or the bottom row repeats other rows:**
+- Raise `gpio_slowdown` a step at a time (SM5368 panels on `row_address_type` 5 can need 6-8 on a Pi 4)
+
+**A row or the whole panel briefly flashes brighter:**
+- Set `disable_hardware_pulsing` to `false` (needs the OE line on GPIO 18; see `hardware_mapping`)
 
 **Colors are wrong or inverted:**
 - Check `led_rgb_sequence` (try "GRB" if "RGB" doesn't work)
@@ -789,9 +829,11 @@ sudo ./scripts/install/install_service.sh
 
 The script will:
 - Detect your user account and home directory
-- Install the service file with the correct paths
-- Enable the service to start on boot
-- Start the service immediately
+- Install `ledmatrix.service` (display, runs as root), `ledmatrix-web.service`
+  (web interface, runs as your user) and the `ledmatrix-update-verify` units,
+  with the correct paths
+- Enable them to start on boot
+- Start them immediately
 
 ### Managing the Service
 

config/config.template.json

@@ -1,5 +1,8 @@
 {
     "web_display_autostart": true,
+    "auto_update": {
+        "enabled": false
+    },
     "schedule": {
         "enabled": false,
         "mode": "per-day",
@@ -130,9 +133,9 @@
         "plugin_rotation_order": [],
         "use_short_date_format": true,
         "vegas_scroll": {
-      "live_in_ticker": false,
-      "live_weight": 3,
-      "favorite_live_weight": 5,
+            "live_in_ticker": false,
+            "live_weight": 3,
+            "favorite_live_weight": 5,
             "enabled": false,
             "scroll_speed": 50,
             "separator_width": 32,
@@ -168,10 +171,7 @@
         "follower_position": "left"
     },
     "plugin_system": {
-        "plugins_directory": "plugin-repos",
-        "auto_discover": true,
-        "auto_load_enabled": true,
-        "development_mode": false
+        "plugins_directory": "plugin-repos"
     },
     "web-ui-info": {
         "enabled": true,

dev_plugins.json.example

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

docs/ADAPTIVE_LAYOUT.md

@@ -223,8 +223,8 @@ 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
+python scripts/check_plugin.py --plugin <plugin-id> --sizes 64x32,128x32,96x48,128x64,256x64
+python scripts/render_plugin.py --plugin <plugin-id> --width 96 --height 48
 ```
 
 `BoundsCheckingDisplayManager` flags right/bottom overflow and now records

docs/ADVANCED_FEATURES.md

@@ -377,9 +377,16 @@ Vegas mode consists of four core components working together to provide smooth 1
 5. Compose into continuous stream with separators
 
 **Key Methods:**
-- `get_stream_content()` - Returns current stream content as PIL Image
-- `advance_stream(pixels)` - Advances stream by N pixels
-- `refresh_stream()` - Regenerates stream from current plugins
+- `get_next_segment()` - Returns the next buffered `ContentSegment` (or `None`)
+- `take_next_group(count=None, offscreen_only=False)` - Hands over the next
+  slice of the rotation as `(plugin_id, images)` groups
+- `get_grouped_content_for_composition()` - Buffered images grouped by plugin
+- `mark_plugin_updated(plugin_id)` / `process_updates()` - Refresh one
+  plugin's segment in place when its data changes
+- `refresh()` - Re-read the plugin list and config
+- `advance_cycle()` - Clear the active buffer when a scroll cycle completes
+
+(`src/vegas_mode/stream_manager.py`)
 
 #### 3. PluginAdapter
 
@@ -433,10 +440,14 @@ Vegas mode consists of four core components working together to provide smooth 1
 - **Frame Rate Control:** Precise timing to maintain 125 FPS
 - **Pre-rendered Content:** Plugins pre-render during update()
 
-**Scroll Speed Calculation:**
+**Scroll Speed Calculation:** motion is by elapsed time; `target_fps` paces
+the render loop, not the speed.
 ```python
-pixels_per_frame = (scroll_speed / target_fps)
-scroll_position += pixels_per_frame * elapsed_time
+# frame_based_scrolling: false
+scroll_position += scroll_speed * elapsed_time            # scroll_speed in px/s
+# frame_based_scrolling: true (the default) -- not stepping, just a clamp
+applied = clamp(scroll_speed * scroll_delay, 0.1, 5) / scroll_delay
+scroll_position += applied * elapsed_time
 ```
 
 #### Component Interactions
@@ -552,7 +563,8 @@ 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` (the `api_v3` blueprint, registered in
+`web_interface/app.py`). Full details: [REST_API_REFERENCE.md](REST_API_REFERENCE.md#display-control).
 
 #### Start On-Demand Display
 
@@ -608,20 +620,30 @@ curl http://localhost:5000/api/v3/display/on-demand/status
 
 # Response:
 {
-  "active": true,
-  "plugin_id": "weather",
-  "mode": "weather",
-  "remaining": 25.5,
-  "pinned": false,
-  "status": "active"
+  "status": "success",
+  "data": {
+    "state": {
+      "active": true,
+      "plugin_id": "weather",
+      "mode": "weather",
+      "duration": 30,
+      "pinned": false,
+      "status": "running",
+      "last_updated": 1234567890.1
+    },
+    "service": {"active": true, "returncode": 0, "stdout": "active", "stderr": ""}
+  }
 }
 ```
 
+When nothing is running on demand, `data.state` is
+`{"active": false, "status": "idle", "last_updated": null}`.
+
 > There is no public Python on-demand API. The display controller's
 > on-demand machinery is internal — drive it through the REST endpoints
 > above (or the web UI buttons). The API handlers
 > (`start_on_demand_display()` / `stop_on_demand_display()` in
-> `web_interface/blueprints/api_v3.py`) write a request into the cache
+> `web_interface/blueprints/api_v3/display.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
@@ -864,7 +886,13 @@ Cache Check → Background Fetch → Partial Data → Completion → Cache
 
 ### Configuration
 
-Enable background service per plugin in `config/config.json`:
+Core does not read a `background_service` config block: the service itself
+(`src/background_data_service.py`) is a process-wide singleton, and its
+worker count is whatever the first caller of `get_background_service()`
+passes. The sports scoreboard plugins read their own
+`background_service` settings and pass them to it, so the exact keys and
+where they sit (top level or per league) are defined by each plugin's
+`config_schema.json`. A typical block looks like:
 
 ```json
 {
@@ -885,11 +913,11 @@ Enable background service per plugin in `config/config.json`:
 
 | Setting | Default | Description |
 |---------|---------|-------------|
-| `enabled` | `false` | Enable background service for this plugin |
+| `enabled` | plugin-defined | Use the background service for this plugin's fetches |
 | `max_workers` | `3` | Max concurrent background tasks |
 | `request_timeout` | `30` | Timeout per API request (seconds) |
 | `max_retries` | `3` | Retry attempts on failure |
-| `priority` | `1` | Task priority (1=highest, 10=lowest) |
+| `priority` | `1` | Stored on each request (higher number = higher priority, per `FetchRequest`), but the service runs requests in submission order; it does not reorder by priority |
 
 ### Performance Impact
 
@@ -906,9 +934,9 @@ Enable background service per plugin in `config/config.json`:
 
 The background data service is used by all of the sports scoreboard
 plugins (football, hockey, baseball/MLB, basketball, soccer, lacrosse,
-F1, UFC), the odds ticker, and the leaderboard plugin. Each plugin's
-`background_service` block (under its own config namespace) follows the
-same shape as the example above.
+F1, UFC), the odds ticker, and the leaderboard plugin. Each plugin reads
+its own `background_service` block (under its own config namespace); check
+that plugin's `config_schema.json` for the keys it accepts.
 
 ### Error Handling & Fallback
 

docs/ADVANCED_PLUGIN_DEVELOPMENT.md

@@ -97,31 +97,53 @@ For plugins that scroll content (tickers, news feeds, etc.), use scrolling state
 
 ### Basic Scrolling Implementation
 
+Scroll with `ScrollHelper`, configured by `src.common.scroll_config`, and
+render one frame per `display()` call. Don't pace the scroll with
+`time.sleep()`: `update_display()` blocks on the panel's
+vsync, which is what paces a scroll. Pass the `frame_hold` that
+`scroll_config.configure()` returned to `set_scrolling_state()`, or the
+scroll runs faster than the configured speed (see
+`set_scrolling_state()` in [PLUGIN_API_REFERENCE.md](PLUGIN_API_REFERENCE.md)).
+
 ```python
+from PIL import Image, ImageDraw
+
+from src.common import scroll_config
+from src.common.scroll_helper import ScrollHelper
+
+def __init__(self, *args, **kwargs):
+    super().__init__(*args, **kwargs)
+    self.scroll_helper = ScrollHelper(
+        self.display_manager.width, self.display_manager.height, self.logger)
+    self.scroll_settings = scroll_config.configure(
+        self.scroll_helper,
+        plugin_config=self.config,
+        global_config=self.global_config,
+        display_manager=self.display_manager,
+        plugin_logger=self.logger,
+    )
+
+def _build_scroll_image(self, text):
+    font = self.display_manager.regular_font
+    width = self.display_manager.get_text_width(text, font)
+    img = Image.new("RGB", (width, self.display_manager.height))
+    ImageDraw.Draw(img).text((0, 0), text, font=font, fill=(255, 255, 255))
+    self.scroll_helper.set_scrolling_image(img)
+
 def display(self, force_clear=False):
-    if force_clear:
-        self.display_manager.clear()
-    
-    # Mark as scrolling
-    self.display_manager.set_scrolling_state(True)
-    
-    try:
-        # Scroll content
-        text = "This is a long scrolling message that needs to scroll across the display..."
-        text_width = self.display_manager.get_text_width(text, self.display_manager.regular_font)
-        display_width = self.display_manager.width
-        
-        # Scroll from right to left
-        for x in range(display_width, -text_width, -2):
-            self.display_manager.clear()
-            self.display_manager.draw_text(text, x=x, y=16, color=(255, 255, 255))
-            self.display_manager.update_display()
-            time.sleep(0.05)
-            
-            # Update scroll activity timestamp
-            self.display_manager.set_scrolling_state(True)
-    finally:
-        # Always mark as not scrolling when done
+    if force_clear or self.scroll_helper.cached_image is None:
+        self._build_scroll_image(
+            "This is a long scrolling message that needs to scroll across the display...")
+
+    # Mark as scrolling (calling it every frame is fine)
+    self.display_manager.set_scrolling_state(
+        True, frame_hold=self.scroll_settings.frame_hold)
+    self.scroll_helper.update_scroll_position()
+    self.display_manager.image = self.scroll_helper.get_visible_portion()
+    self.display_manager.update_display()
+
+    if self.scroll_helper.is_scroll_complete():
+        # Mark as not scrolling when done
         self.display_manager.set_scrolling_state(False)
 ```
 

docs/CONFIG_DEBUGGING.md

@@ -250,14 +250,21 @@ WARNING - Plugin ID 'Football-Scoreboard' may conflict with 'football-scoreboard
 
 ## Checking Configuration via API
 
-The API blueprint mounts at `/api/v3` (`web_interface/app.py:144`).
+The API blueprint (`web_interface/blueprints/api_v3/`) is registered at
+`/api/v3` in `web_interface/app.py`.
 
 ```bash
-# Get full main config (includes all plugin sections)
+# Get full main config (includes all plugin sections; credential-named
+# fields are blanked in the response)
 curl http://localhost:5000/api/v3/config/main
 
-# Save updated main config
+# Change some settings: only the keys you send are changed
 curl -X POST http://localhost:5000/api/v3/config/main \
+  -H "Content-Type: application/json" \
+  -d '{"timezone": "America/Chicago", "brightness": 80}'
+
+# Replace config.json wholesale (advanced)
+curl -X POST http://localhost:5000/api/v3/config/raw/main \
   -H "Content-Type: application/json" \
   -d @new-config.json
 
@@ -269,8 +276,10 @@ curl "http://localhost:5000/api/v3/plugins/config?plugin_id=football-scoreboard"
 ```
 
 > There is no dedicated `/config/plugin/<id>` or `/config/validate`
-> endpoint — config validation runs server-side automatically when you
-> POST to `/config/main` or `/plugins/config`. See
+> endpoint. `POST /plugins/config` validates against the plugin's schema
+> and rejects an invalid config with `400`; `POST /config/main` checks the
+> individual fields it knows (display hardware values, durations, Vegas
+> and sync settings). See
 > [REST_API_REFERENCE.md](REST_API_REFERENCE.md) for the full list.
 
 ## Backup and Recovery
@@ -283,9 +292,12 @@ cp config/config.json config/config.backup.json
 
 ### Automatic Backups
 
-LEDMatrix creates backups before saves:
+LEDMatrix creates backups before saves (`src/config_manager_atomic.py`):
 - Location: `config/backups/`
-- Format: `config_YYYYMMDD_HHMMSS.json`
+- Format: `config.json.backup.YYYYMMDD_HHMMSS_ffffff` (microseconds last),
+  plus a matching `config_secrets.json.backup.<timestamp>` when a secrets
+  file exists
+- The five most recent are kept
 
 ### Recovery
 
@@ -294,7 +306,7 @@ LEDMatrix creates backups before saves:
 ls -la config/backups/
 
 # Restore from backup
-cp config/backups/config_20240115_120000.json config/config.json
+cp config/backups/config.json.backup.20240115_120000_000000 config/config.json
 ```
 
 ## Troubleshooting Checklist

docs/CONFIG_REFERENCE.md

@@ -16,9 +16,10 @@ tooling against it.
 | Key | Type / default | Meaning | Read by |
 |---|---|---|---|
 | `web_display_autostart` | bool, `true` | Whether the web interface service starts with the system | `scripts/utils/start_web_conditionally.py` |
+| `auto_update.enabled` | bool, `false` | Weekly automatic updates: LEDMatrix code first (health-checked, rolled back on failure), then installed plugins. Toggle in the General tab or install with `first_time_install.sh --enable-auto-update` | `web_interface/auto_update.py`, `src/auto_update_setup.py` (`is_enabled()`) |
 | `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`. Supplies the **default** for a plugin's own `location_city` / `location_state` / `location_country` setting, so weather, radar and friends follow this device without being configured twice. A value saved on the plugin itself still overrides it. | `SchemaManager.apply_device_location()`, then plugins via merged config |
+| `target_fps` | int, `100` | Legacy "Scroll Frame Rate". Core scrolling no longer reads it: scroll frames are presented at `display.hardware.limit_refresh_rate_hz` divided by each scroll's frame hold, and speed comes from each plugin's scroll settings. Still exposed to plugins via `BasePlugin.global_config` | `src/plugin_system/base_plugin.py` |
+| `location` | object | `city` / `state` / `country`. Supplies the **default** for a plugin's own `location_city` / `location_state` / `location_country` setting, so weather, radar and friends follow this device without being configured twice. A value saved on the plugin itself still overrides it. Starlark (Tidbyt) apps get the same treatment: a `Location` field left blank on the app renders at this city (geocoded once via Open-Meteo, coordinates cached permanently) instead of the app author's default, which is usually San Francisco. If the city can't be looked up (no match, or the geocoder is unreachable; retried after 30 minutes), the app keeps its own default. | `SchemaManager.apply_device_location()`, then plugins via merged config; `src/device_location.py` for Starlark apps |
 
 ## `schedule` — display on/off hours
 
@@ -29,57 +30,62 @@ tooling against it.
 | `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.
+Read by `DisplayController._check_schedule()` (`src/display_controller.py`).
+Managed in the web UI under Schedule.
 
 ## `dim_schedule` — scheduled brightness dimming
 
-Same shape as `schedule`, plus:
+Same shape as `schedule` (the template sets its `mode` to `"global"`), plus:
 
 | Key | Type / default | Meaning |
 |---|---|---|
 | `dim_brightness` | int, `30` | Brightness percentage applied while the dim window is active |
 
-Read by `DisplayController` (`src/display_controller.py` around line 770;
+Read by `DisplayController._check_dim_schedule()` (`src/display_controller.py`;
 saved via `POST /api/v3/config/dim-schedule`). The display returns to
 `display.hardware.brightness` outside the window.
 
 ## `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).
+in `DisplayManager._setup_matrix` (`src/display_manager.py`). Defaults are the
+`config/config.template.json` values: `ConfigManager` adds any key missing from
+`config.json` from the template on load, so `DisplayManager`'s own fallbacks
+don't apply on a normal install.
+
+The ranges are what the pinned rgbmatrix library and its Python binding accept
+(`src/matrix_support.py`). The config API refuses anything else; a value
+hand-edited into `config.json` makes the display log the setting and run in
+fallback mode instead of starting the matrix.
 
 | Key | Type / default |
 |---|---|
-| `rows` / `cols` | int, `32` / `64` |
-| `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` |
+| `rows` / `cols` | int, `32` / `64` — rows: even, 8–64; cols: at least 16 |
+| `chain_length` | int, `2` — 1–255 (the Python binding stores it in one byte) |
+| `parallel` | int, `1` — 1–3, and no more than `hardware_mapping` has outputs (`regular`, `classic`: 3; the others: 1) |
+| `brightness` | int, `90` — 1–100 |
+| `hardware_mapping` | string, `"adafruit-hat"` — `"adafruit-hat-pwm"`, `"adafruit-hat"`, `"regular"`, `"regular-pi1"`, `"classic"` or `"classic-pi1"` (case-insensitive; `compute-module` isn't in the installed build). A Pi 5 doesn't support `"classic-pi1"` |
+| `scan_mode` | int, `0` — `0` progressive, `1` interlaced |
+| `pwm_bits` | int, `9` — 1–11 |
+| `pwm_dither_bits` | int, `1` — 0–2 |
+| `pwm_lsb_nanoseconds` | int, `130` — 50–3000 |
+| `disable_hardware_pulsing` | bool, `false` — `true` times brightness pulses in software (less exact); hardware pulsing needs the OE line on GPIO 18 and the Pi's onboard sound driver off |
 | `inverse_colors` | bool, `false` |
-| `show_refresh_rate` | bool, `false` |
-| `led_rgb_sequence` | string, `"RGB"` |
-| `limit_refresh_rate_hz` | int, `100` (code default 90) |
-| `pixel_mapper_config` | string, `""` — e.g. `"U-mapper"` / `"Rotate:90"` |
-| `orientation` | string, `"normal"` — `"180"` rotates the rendered image 180° for panels physically mounted upside down (e.g. to move the Pi/wiring to a more convenient side); composed onto `pixel_mapper_config` as a trailing `Rotate:180` mapper, so it stays independent of any custom `pixel_mapper_config` value |
-| `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.
+| `show_refresh_rate` | bool, `false` — prints the refresh rate to stdout; draws nothing on the panel |
+| `led_rgb_sequence` | string, `"RGB"` — `"RGB"`, `"RBG"`, `"GRB"`, `"GBR"`, `"BRG"` or `"BGR"` |
+| `limit_refresh_rate_hz` | int, `100` — `0` = no cap; scroll timing assumes 100 Hz when `0` |
+| `pixel_mapper_config` | string, `""` — e.g. `"U-mapper"` / `"Rotate:90"`; mappers that rotate or fold the chain change the display size plugins and the web preview see |
+| `orientation` | string, `"normal"` — `"180"` rotates the rendered image 180° for panels physically mounted upside down (e.g. to move the Pi/wiring to a more convenient side); `"90"` / `"270"` for a panel on its side, swapping width and height; composed onto `pixel_mapper_config` as a trailing `Rotate:<degrees>` mapper, so it stays independent of any custom `pixel_mapper_config` value |
+| `row_address_type` | int, `0` — non-standard panel row addressing: `1` AB, `2` direct row select, `3` ABC, `4` ABC shift + DE direct, `5` SM5368 / B707 row shift register (e.g. Waveshare 96x48 V2, with `led_rgb_sequence` `"BGR"`). On a Pi 5 the library supports only `0` and `2`, and LEDMatrix enforces that (`src/pi5_matrix_support.py`) |
+| `multiplexing` | int, `0` — 0–22, pixel wiring scheme for outdoor/specialty panels (names listed in the README) |
+| `panel_type` | string, `""` — set to `"FM6126A"` or `"FM6127"` for panels needing init; FM6124 / FM6124D / FM6124DJ panels need none, so leave it `""` |
 
 ## `display.runtime`
 
 | Key | Type / default | Meaning |
 |---|---|---|
-| `gpio_slowdown` | int, `3` | GPIO timing slowdown for faster Pis |
-| `rp1_rio` | int, `0` | RP1 RIO mode on Pi 5 (applied only if the installed matrix library supports it) |
+| `gpio_slowdown` | int, `3` | GPIO timing slowdown for faster Pis (0–10). On a Pi 5 in PIO mode start at `1` (`0` acts as `1`) and raise it if the image flickers or shows garbage. Panels on `row_address_type` `5` (SM5368 row drivers) can need 6–8 on a Pi 4 — lower values make rows jump |
+| `rp1_rio` | int, `0` | Pi 5 only: `0` = PIO (less CPU), `1` = RIO (higher refresh; `gpio_slowdown` effect inverted). Applied only if the installed matrix library supports it |
 
 ## `display.double_sided`
 
@@ -96,10 +102,10 @@ logical image to multiple chained physical panels.
 
 | 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_durations` | object, `{}` | Per-plugin display duration in seconds, keyed by plugin id (e.g. `"clock": 15`) | `DisplayController._get_display_duration()` (`src/display_controller.py`) |
+| `plugin_rotation_order` | array, `[]` | Explicit rotation order of plugin ids; empty = all enabled plugins in discovery order | `DisplayController._apply_plugin_rotation_order()` (`src/display_controller.py`) |
+| `use_short_date_format` | bool, `true` | Compact date rendering in sports scoreboards | Nothing since `src/base_classes` was removed; scoreboards read `display.use_short_date_format` from their own plugin config |
+| `dynamic_duration.max_duration_seconds` | int, optional | Cap for plugins that request dynamic display time | `DisplayController._get_global_dynamic_cap()` (`src/display_controller.py`) |
 
 ## `display.vegas_scroll` — continuous scroll mode
 
@@ -134,8 +140,8 @@ Read by `src/vegas_mode/config.py` (`VegasScrollConfig.from_config`). See
 | `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) |
+| `frame_based_scrolling` | bool, `true` — does not step or set a frame rate; motion is by elapsed time either way. When `true`, `scroll_speed` passes through a clamp of 0.1–5 px per `scroll_delay` (see next row) |
+| `scroll_delay` | float, `0.02` — not a frame period. Only used with `frame_based_scrolling`: the applied speed is `clamp(scroll_speed × scroll_delay, 0.1, 5) / scroll_delay` px/s, so at `0.02` speeds under 5 px/s run at 5, and at `0.001` nothing runs slower than 100 px/s |
 | `live_in_ticker` | bool, `false` — keep scrolling during live games instead of handing the display to a full-screen scoreboard |
 | `live_weight` | int, `3` (1–10) — slots per cycle for a plugin with live content |
 | `favorite_live_weight` | int, `5` (1–10) — slots per cycle when a plugin reports a favorite team is live |
@@ -148,18 +154,14 @@ Read by `src/common/sync_manager.py` and `src/display_controller.py`.
 |---|---|---|
 | `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`) |
+| `follower_position` | `"left"` (default) or `"right"` | Which half of the combined image this follower renders (`src/display_controller.py`) |
 
 ## `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) |
+| `plugins_directory` | string, `"plugin-repos"` | Where the Plugin Store installs plugins and the only directory the plugin loader scans. Read by `PluginManager` and `PluginStoreManager` (`src/plugin_system/`); editable under General settings |
+| `auto_discover`, `auto_load_enabled`, `development_mode` | bool | **Unused.** Legacy keys, read by nothing and no longer in the template; older configs may still carry them. Plugins are always discovered, and every plugin with `enabled: true` is loaded — to keep a plugin installed but dormant, set its own `enabled` to `false`. Not shown in the web UI; may be left in or removed from config.json |
 
 ## Plugin config blocks
 
@@ -173,5 +175,5 @@ See [PLUGIN_CONFIG_CORE_PROPERTIES.md](PLUGIN_CONFIG_CORE_PROPERTIES.md).
 
 | Key | Meaning |
 |---|---|
-| `github.api_token` | Optional GitHub token the Plugin Store uses to avoid API rate limits (`src/plugin_system/store_manager.py:348`) |
+| `github.api_token` | Optional GitHub token the Plugin Store uses to avoid API rate limits (`src/plugin_system/store_manager.py`) |
 | `<plugin-id>.*` | Secrets a plugin declares with `"x-secret": true` in its config schema; merged into that plugin's config at load time |

docs/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/DEVELOPMENT.md

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

docs/FONT_MANAGER.md

@@ -12,10 +12,28 @@
 The enhanced FontManager provides comprehensive font management for the LEDMatrix application with support for:
 - Manager font registration and detection
 - Plugin font management
-- Manual font overrides via web interface
+- Programmatic per-element font overrides
 - Performance monitoring and caching
 - Dynamic font discovery
 
+## Getting the FontManager
+
+There is one shared FontManager per display process. The display controller
+creates it and hands it to the `PluginManager`, so a plugin reaches it
+through its `plugin_manager`:
+
+```python
+class MyPlugin(BasePlugin):
+    def __init__(self, plugin_id, config, display_manager, cache_manager, plugin_manager):
+        super().__init__(plugin_id, config, display_manager, cache_manager, plugin_manager)
+        self.font_manager = self._get_font_manager()
+```
+
+`BasePlugin._get_font_manager()` returns `plugin_manager.font_manager`, or a
+standalone FontManager when none is available (test harnesses, mocks).
+`DisplayManager` has **no** `font_manager` attribute —
+`display_manager.font_manager` raises `AttributeError`.
+
 ## Architecture
 
 ### Manager-Centric Design
@@ -40,8 +58,9 @@ Manager requests font → Check manual overrides → Apply manager choice → Ca
 from src.font_manager import FontManager
 
 class MyManager:
-    def __init__(self, config, display_manager, cache_manager):
-        self.font_manager = display_manager.font_manager  # Access shared FontManager
+    def __init__(self, config, display_manager, cache_manager, plugin_manager):
+        self.display_manager = display_manager
+        self.font_manager = plugin_manager.font_manager  # Shared FontManager
         self.manager_id = "my_manager"
         
     def display(self):
@@ -80,8 +99,9 @@ class MyManager:
 
 ```python
 class AdvancedManager:
-    def __init__(self, config, display_manager, cache_manager):
-        self.font_manager = display_manager.font_manager
+    def __init__(self, config, display_manager, cache_manager, plugin_manager):
+        self.display_manager = display_manager
+        self.font_manager = plugin_manager.font_manager
         self.manager_id = "advanced_manager"
         
         # Define your font specifications
@@ -152,19 +172,15 @@ font = self.font_manager.resolve_font(
 > URIs documented below are resolved relative to the plugin's
 > install directory.
 >
-> The **Fonts** tab in the web UI that lists detected
-> manager-registered fonts is still a **placeholder
-> implementation** — fonts that managers register through
-> `register_manager_font()` do not yet appear there. The
-> programmatic per-element override workflow described in
-> [Manual Font Overrides](#manual-font-overrides) below
-> (`set_override()` / `remove_override()` / the
-> `config/font_overrides.json` store) **does** work today and is
-> the supported way to override a font for an element until the
-> Fonts tab is wired up. If you can't wait and need a workaround
-> right now, you can also just load the font directly with PIL
-> (or `freetype-py` for BDF) inside your plugin's `manager.py`
-> and skip the override system entirely.
+> The web UI's **Fonts** tab lists, uploads, previews and deletes the
+> font files in `assets/fonts/`. Its **Used by** column shows which
+> loaded plugins registered each file through `register_manager_font()`
+> (see [Font usage in the web UI](#font-usage-in-the-web-ui)), and it
+> warns before deleting one of them. It has no override editor (the
+> override panels and `/api/v3/fonts/overrides` endpoints were removed).
+> The programmatic override workflow in
+> [Manual Font Overrides](#manual-font-overrides) below still works.
+> Let users pick fonts through your plugin's own config schema.
 
 ### Plugin Font Registration
 
@@ -200,10 +216,10 @@ In your plugin's `manifest.json`:
 ### Using Plugin Fonts
 
 ```python
-class PluginManager:
-    def __init__(self, config, display_manager, cache_manager, plugin_id):
-        self.font_manager = display_manager.font_manager
-        self.plugin_id = plugin_id
+class MyPlugin(BasePlugin):
+    def __init__(self, plugin_id, config, display_manager, cache_manager, plugin_manager):
+        super().__init__(plugin_id, config, display_manager, cache_manager, plugin_manager)
+        self.font_manager = self._get_font_manager()
         
     def display(self):
         # Use plugin font (automatically namespaced)
@@ -219,17 +235,8 @@ class PluginManager:
 
 ## Manual Font Overrides
 
-Users can override any font through the web interface:
-
-1. Navigate to **Fonts** tab
-2. View **Detected Manager Fonts** to see what's currently in use
-3. In **Element Overrides** section:
-   - Select the element (e.g., "nfl.live.score")
-   - Choose a different font family
-   - Choose a different size
-   - Click **Add Override**
-
-Overrides are stored in `config/font_overrides.json` and persist across restarts.
+Overrides are set in code (there is no web UI or REST endpoint for them).
+They are stored in `config/font_overrides.json` and persist across restarts.
 
 ### Programmatic Overrides
 
@@ -271,6 +278,31 @@ Place font files in `assets/fonts/` directory:
 - Font family name is derived from filename (without extension)
 - Will be automatically discovered on next initialization
 
+## Font usage in the web UI
+
+The web interface runs in its own process and has no FontManager, so the
+display service publishes which plugin uses which font
+(`src/font_usage.py`), and the Fonts tab's **Used by** column reads it:
+
+- **Source**: `register_manager_font()` registrations of the loaded
+  plugins. `get_font()` and `resolve_font()` do not know the calling plugin
+  and are not counted, and neither is a plugin that opens a font file
+  directly with PIL — register the fonts your plugin draws with if you want
+  them listed.
+- **Names**: a family, alias (`press_start`, `four_by_six`,
+  `five_by_seven`, `tom_thumb`) or path is resolved through
+  `font_catalog` to the file it loads and reported under that file's name
+  without extension (`PressStart2P-Regular`, `4x6-font`, `5x7`,
+  `tom-thumb`), which is how the Fonts tab keys its rows. Fonts outside
+  `assets/fonts/` (a plugin's own `plugin_id::family` fonts) and families
+  that resolve to nothing are left out.
+- **When**: a daemon thread started once plugins have loaded checks every
+  10 seconds and writes the `font_usage_snapshot` cache key only when the
+  usage changed (and once a day, so the cache's cleanup never expires it).
+  Unloading a plugin drops its registrations (`forget_manager_fonts`).
+- **Unknown**: until the display service has published, the column reads
+  "unknown" and `GET /api/v3/fonts/catalog` returns `used_by: null`.
+
 ## Performance Monitoring
 
 ```python
@@ -369,6 +401,7 @@ self.font = self.font_manager.resolve_font(
 ### FontManager Methods
 
 - `register_manager_font(manager_id, element_key, family, size_px, color=None)` - Register font usage
+- `forget_manager_fonts(manager_id)` - Drop a manager's registrations (core calls it when a plugin unloads)
 - `resolve_font(element_key, family, size_px, plugin_id=None)` - Get font with override support
 - `get_font(family, size_px)` - Get font directly (bypasses overrides)
 - `measure_text(text, font)` - Measure text dimensions
@@ -388,7 +421,5 @@ self.font = self.font_manager.resolve_font(
 ## Example: Complete Manager Implementation
 
 For a working example of the font manager API in use, see
-`src/font_manager.py` itself and the bundled scoreboard base classes
-in `src/base_classes/` (e.g., `hockey.py`, `football.py`) which
-register and resolve fonts via the patterns documented above.
+`src/font_manager.py` itself.
 

docs/GETTING_STARTED.md

@@ -83,10 +83,10 @@ You should see:
 
 1. Open the **Display** tab
 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
-     panel hardware ships with
+   - **Rows**: match your panel — commonly 32 or 64; any even number
+     from 8 to 64
+   - **Columns**: match your panel — commonly 64 or 96; at least 16,
+     with no upper limit
    - **Chain Length**: Number of panels chained horizontally
    - **Hardware Mapping**: usually `adafruit-hat-pwm` (with the PWM jumper
      mod) or `adafruit-hat` (without). See the root README for the full list.

docs/HOW_TO_RUN_TESTS.md

@@ -60,20 +60,18 @@ pytest test/test_display_controller.py::TestDisplayControllerModeRotation::test_
 
 ### Run Tests by Marker
 
-The tests use markers to categorize them:
+`pytest.ini` declares the markers `unit`, `integration`, `hardware`, `slow`
+and `plugin` (with `--strict-markers`, so a typo in a marker name is an
+error). Few tests are marked: only a handful carry `unit`, and none currently
+carry `integration`, `slow` or `hardware`, so `-m integration` and `-m slow`
+select nothing. Select tests by file, directory or `-k` instead.
 
 ```bash
-# Run only unit tests (fast, isolated)
-pytest -m unit
+# What CI runs for the core suites (excludes anything marked hardware)
+pytest -m "not hardware" test/ --ignore=test/plugins
 
-# Run only integration tests
-pytest -m integration
-
-# Run tests that don't require hardware
-pytest -m "not hardware"
-
-# Run slow tests
-pytest -m slow
+# Tests whose name matches an expression
+pytest -k "config and not secrets"
 ```
 
 ### Run Tests in a Directory
@@ -138,58 +136,35 @@ pytest -sv
 
 ## Coverage Reports
 
-The test suite is configured to generate coverage reports.
-
-### View Coverage in Terminal
+Coverage is not collected by a plain `pytest` run: `pytest.ini` deliberately
+has no coverage flags, so local runs stay fast. Ask for it explicitly
+(needs `pytest-cov`, which is in `requirements-test.txt`):
 
 ```bash
-# Coverage is automatically shown when running pytest
-pytest
+# Terminal summary
+pytest --cov=src --cov=web_interface --cov-report=term test/ --ignore=test/plugins
 
-# The output will show something like:
-# ----------- coverage: platform linux, python 3.11.5 -----------
-# Name                                    Stmts   Miss  Cover   Missing
-# ---------------------------------------------------------------------
-# src/display_controller.py                 450     120    73%   45-67, 89-102
+# HTML report in htmlcov/
+pytest --cov=src --cov=web_interface --cov-report=html test/ --ignore=test/plugins
 ```
 
-### Generate HTML Coverage Report
-
-```bash
-# HTML report is automatically generated in htmlcov/
-pytest
-
-# Then open the report in your browser
-# On Linux:
-xdg-open htmlcov/index.html
-
-# On macOS:
-open htmlcov/index.html
-
-# On Windows:
-start htmlcov/index.html
-```
-
-The HTML report shows:
-- Line-by-line coverage
-- Files with low coverage highlighted
-- Interactive navigation
+Then open `htmlcov/index.html` in your browser (`xdg-open` on Linux, `open`
+on macOS, `start` on Windows).
 
 ### Coverage Threshold
 
-The tests are configured to fail if coverage drops below 30%. To change this, edit `pytest.ini`:
-
-```ini
---cov-fail-under=30  # Change this value
-```
+The only threshold is in CI: the core unit-test job in
+[`.github/workflows/test.yml`](../.github/workflows/test.yml) runs with
+`--cov-fail-under=52`. To check it locally, add that flag to the command
+above.
 
 ## Common Test Scenarios
 
 ### Run Tests After Making Changes
 
 ```bash
-# Quick test run (just unit tests)
-pytest -m unit
+# Quick run: just the tests for the area you changed
+pytest test/test_config_manager.py
 
 # Full test suite
 pytest
@@ -250,15 +225,10 @@ test/
 ├── test_error_aggregator.py             # Error aggregation tests
 ├── test_schema_manager.py               # Schema manager tests
 ├── test_web_api.py                      # Web API tests
-├── plugins/                             # Per-plugin test suites
-│   ├── test_clock_simple.py
-│   ├── test_calendar.py
-│   ├── test_basketball_scoreboard.py
-│   ├── test_soccer_scoreboard.py
-│   ├── test_odds_ticker.py
-│   ├── test_text_display.py
-│   ├── test_visual_rendering.py
-│   └── test_plugin_base.py
+├── plugins/                             # Plugin rendering suites
+│   ├── test_plugin_matrix.py            # Every discovered plugin, across panel sizes
+│   ├── test_harness.py
+│   └── test_visual_rendering.py
 └── web_interface/
     ├── test_config_manager_atomic.py
     ├── test_state_reconciliation.py
@@ -283,8 +253,8 @@ test/
 If you see import errors:
 
 ```bash
-# Make sure you're in the project root
-cd /home/chuck/Github/LEDMatrix
+# Make sure you're in the project root (wherever you cloned it)
+cd ~/LEDMatrix
 
 # Check Python path
 python -c "import sys; print(sys.path)"
@@ -325,18 +295,18 @@ If coverage reports aren't generating:
 # Make sure pytest-cov is installed
 pip install pytest-cov
 
-# Run with explicit coverage
-pytest --cov=src --cov-report=html
+# Coverage is opt-in; ask for it explicitly
+pytest --cov=src --cov=web_interface --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
+push and pull request: a plugin-safety job that runs `test/plugins/`, and a
+core unit-test job that runs the whole `test/` tree except `test/plugins/`
+with `-m "not hardware"` and enforces coverage (`--cov-fail-under=52`). New
+test files are picked up automatically. Release version consistency is checked by
 [`.github/workflows/release-version-check.yml`](../.github/workflows/release-version-check.yml).
 Bandit, flake8, mypy and gitleaks run as pre-commit hooks (see
 `.pre-commit-config.yaml`), not in CI.
@@ -345,17 +315,17 @@ Bandit, flake8, mypy and gitleaks run as pre-commit hooks (see
 
 1. **Run tests before committing**:
    ```bash
-   pytest -m unit  # Quick check
+   pytest test/test_<area>.py  # Quick check of what you touched
    ```
 
 2. **Run full suite before pushing**:
    ```bash
-   pytest  # Full test suite with coverage
+   pytest  # Full test suite (add --cov flags for coverage)
    ```
 
 3. **Fix failing tests immediately** - Don't let them accumulate
 
-4. **Keep coverage above threshold** - Aim for 70%+ coverage
+4. **Keep coverage above threshold** - CI fails below 52%
 
 5. **Write tests for new features** - Add tests when adding new functionality
 
@@ -363,9 +333,9 @@ Bandit, flake8, mypy and gitleaks run as pre-commit hooks (see
 
 ```bash
 # Most common commands
-pytest                    # Run all tests with coverage
+pytest                    # Run all tests (no coverage)
 pytest -v                 # Verbose output
-pytest -m unit           # Run only unit tests
+pytest test/test_x.py     # Run one file
 pytest -k "test_name"    # Run tests matching pattern
 pytest --cov=src         # Generate coverage report
 pytest -x                # Stop on first failure

docs/MIGRATION_GUIDE.md

@@ -19,7 +19,6 @@ All installation scripts have been moved from the project root to `scripts/insta
 | `install_wifi_monitor.sh` | `scripts/install/install_wifi_monitor.sh` |
 | `setup_cache.sh` | `scripts/install/setup_cache.sh` |
 | `configure_web_sudo.sh` | `scripts/install/configure_web_sudo.sh` |
-| `migrate_config.sh` | `scripts/install/migrate_config.sh` |
 
 #### Permission Fix Scripts
 
@@ -59,9 +58,12 @@ sudo ./scripts/install/install_service.sh
 After updating your scripts, verify they still work:
 
 ```bash
-# Test installation scripts (if needed)
+# Check the installation scripts are at their new paths
 ls scripts/install/*.sh
-sudo ./scripts/install/install_service.sh --help
+./scripts/install/install_service.sh --help   # prints usage only
+# Note: running install_service.sh for real (with sudo, no --help)
+# reinstalls, enables and restarts ledmatrix.service, ledmatrix-web.service
+# and the update-verify units.
 
 # Test permission scripts
 ls scripts/fix_perms/*.sh

docs/MULTI_ROOT_WORKSPACE_SETUP.md

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

docs/PLUGIN_API_REFERENCE.md

@@ -13,6 +13,7 @@ Complete API reference for plugin developers. This document describes all method
 - [Display Manager](#display-manager)
 - [Cache Manager](#cache-manager)
 - [Plugin Manager](#plugin-manager)
+- [Deprecated APIs](#deprecated-apis)
 
 ---
 
@@ -36,7 +37,11 @@ self.enabled            # Boolean enabled status
 
 #### `update() -> None`
 
-Fetch/update data for this plugin. Called based on `update_interval` specified in the plugin's manifest.
+Fetch/update data for this plugin. Called on the plugin's update interval:
+the value `get_update_interval()` returns when it returns a number, otherwise
+the static interval: the `update_interval` in the plugin's manifest, else
+`update_interval` in the plugin's section of `config.json`, else 60 seconds
+(see [`get_update_interval()`](#get_update_interval---optionalfloat) below).
 
 **Example**:
 ```python
@@ -109,6 +114,46 @@ Called when plugin is enabled.
 
 Called when plugin is disabled.
 
+#### `get_update_interval() -> Optional[float]`
+
+How often this plugin wants `update()` called right now, in seconds. The
+manifest's `update_interval` is one static number; override this when the
+right cadence depends on state only the plugin knows, e.g. poll every 15s
+while a game is live and fall back to the manifest value otherwise.
+
+**Returns**: seconds as a number, or `None` (the default) for no opinion.
+
+How `PluginManager` (`_get_plugin_update_interval` in
+`src/plugin_system/plugin_manager.py`) resolves the interval on each
+scheduling tick:
+
+1. It calls `get_update_interval()`. A number wins over everything below.
+   Values under `PluginManager.MIN_DYNAMIC_UPDATE_INTERVAL` (5 seconds) are
+   raised to it.
+2. If the hook returns `None`, raises, or returns something that isn't a
+   finite number (a `bool`, a string, NaN, infinity), it is ignored and the
+   static interval applies: the manifest's `update_interval`, else
+   `update_interval` in the plugin's section of `config.json`, else 60
+   seconds.
+
+The static value is cached per plugin until the plugin is loaded or
+unloaded again, so editing `update_interval` in config takes effect on the
+next reload. The hook's return value is never cached: it is called on every
+tick of the display loop, so keep it to attribute reads (no config lookups,
+no I/O, no locks a fetch might hold) and don't let it raise.
+
+**Example**:
+```python
+def get_update_interval(self):
+    # Fast while something is live, manifest default otherwise.
+    if any(m.live_games for m in self._live_managers):
+        return self.config.get("live_update_interval", 15)
+    return None
+```
+
+Added in core 3.4.0; older cores never call it, so a plugin that relies on
+it should floor `ledmatrix_min_version` at `3.4.0`.
+
 #### `get_display_duration() -> float`
 
 Get display duration for this plugin. Can be overridden for dynamic durations.
@@ -385,9 +430,7 @@ self.display_manager.image.paste(icon, (5, 5), icon)
 self.display_manager.update_display()
 ```
 
-This is the same pattern the bundled scoreboard base classes
-(`src/base_classes/baseball.py`, `basketball.py`, `football.py`,
-`hockey.py`) use, so it's the canonical way to render arbitrary images.
+This is the canonical way to render arbitrary images.
 
 ### Weather Icons
 
@@ -470,21 +513,59 @@ self.display_manager.draw_text_with_icons(
 
 For plugins that implement scrolling content, use these methods to coordinate with the display system.
 
-#### `set_scrolling_state(is_scrolling: bool) -> None`
+#### `set_scrolling_state(is_scrolling: bool, frame_hold: int = 1) -> None`
 
-Mark the display as scrolling or not scrolling. Call when scrolling starts/stops.
+Mark the display as scrolling or not scrolling, and set this scroll's frame
+pacing. Call it when a scroll starts (calling it on every scroll frame is fine)
+and with `False` when it stops.
 
 **Parameters**:
 - `is_scrolling` (bool): True if currently scrolling, False otherwise
+- `frame_hold` (int, default 1): how many panel refreshes each pushed frame is
+  held for (clamped to 1-255; ignored when `is_scrolling` is False, which
+  resets it to 1). Pass the `frame_hold` of the settings
+  `src.common.scroll_config.configure()` returned. Added in core 3.4.0.
+
+**Why `frame_hold` matters**: `scroll_config.configure()` snaps the speed to
+one the panel can show in whole pixels and sets the `ScrollHelper` to advance a
+fixed number of pixels on every presented frame -- no clock is consulted. The
+panel presents frames at its refresh rate divided by the hold, so the hold is
+part of the speed. Omit it and a 50 px/s scroll (1px every 2nd refresh on a
+100 Hz panel) runs at 100 px/s. The hold is not applied by `configure()`
+because it must not outlive the scroll: plugins share one display manager.
 
 **Example**:
 ```python
+from src.common import scroll_config
+from src.common.scroll_helper import ScrollHelper
+
+def __init__(self, *args, **kwargs):
+    super().__init__(*args, **kwargs)
+    self.scroll_helper = ScrollHelper(
+        self.display_manager.width, self.display_manager.height, self.logger)
+    # ...later, hand it content with self.scroll_helper.set_scrolling_image(img)
+    self.scroll_settings = scroll_config.configure(
+        self.scroll_helper,
+        plugin_config=self.config,
+        global_config=self.global_config,
+        display_manager=self.display_manager,
+        plugin_logger=self.logger,
+    )
+
 def display(self, force_clear=False):
-    self.display_manager.set_scrolling_state(True)
-    # Scroll content...
-    self.display_manager.set_scrolling_state(False)
+    self.display_manager.set_scrolling_state(
+        True, frame_hold=self.scroll_settings.frame_hold)
+    self.scroll_helper.update_scroll_position()
+    self.display_manager.image = self.scroll_helper.get_visible_portion()
+    self.display_manager.update_display()
+    if self.scroll_helper.is_scroll_complete():
+        self.display_manager.set_scrolling_state(False)
 ```
 
+Don't pace the loop with `time.sleep()`: `update_display()` blocks on the
+panel's vsync, which is what paces a scroll. See `docs/SCROLL_PERFORMANCE.md`
+for choosing a speed.
+
 #### `is_currently_scrolling() -> bool`
 
 Check if the display is currently in a scrolling state.
@@ -538,7 +619,7 @@ The Display Manager provides several pre-loaded fonts:
 display_manager.regular_font      # Press Start 2P, size 8
 display_manager.small_font        # Press Start 2P, size 8
 display_manager.calendar_font     # 5x7 BDF font
-display_manager.extra_small_font  # 4x6 TTF font, size 6
+display_manager.extra_small_font  # 4x6 TTF font, size 7 (6 snapped to its pixel grid)
 display_manager.bdf_5x7_font     # Alias for calendar_font
 ```
 
@@ -772,12 +853,12 @@ for file_info in files:
 
 Get cache performance metrics.
 
-**Returns**: Dictionary with cache statistics (hits, misses, hit rate, etc.)
+**Returns**: Dictionary with cache statistics (`total_requests`, `cache_hit_rate`, `background_hit_rate`, `api_calls_saved`, `average_fetch_time`, etc.)
 
 **Example**:
 ```python
 metrics = self.cache_manager.get_cache_metrics()
-self.logger.info(f"Cache hit rate: {metrics['hit_rate']:.2%}")
+self.logger.info(f"Cache hit rate: {metrics['cache_hit_rate']:.2%}")
 ```
 
 #### `get_memory_cache_stats() -> Dict[str, Any]`
@@ -954,9 +1035,10 @@ if "weather" in enabled_plugins:
        self.display_manager.update_display()
    ```
 
-3. **Handle scrolling state**: If your plugin scrolls, use scrolling state methods
+3. **Handle scrolling state**: If your plugin scrolls, use scrolling state methods,
+   passing the frame hold `scroll_config.configure()` returned
    ```python
-   self.display_manager.set_scrolling_state(True)
+   self.display_manager.set_scrolling_state(True, frame_hold=settings.frame_hold)
    # Scroll content...
    self.display_manager.set_scrolling_state(False)
    ```
@@ -991,3 +1073,23 @@ if "weather" in enabled_plugins:
 - [Plugin Development Guide](PLUGIN_DEVELOPMENT_GUIDE.md) - Complete development guide
 - [Advanced Plugin Development](ADVANCED_PLUGIN_DEVELOPMENT.md) - Advanced patterns and examples
 
+---
+
+## Deprecated APIs
+
+These still work in 3.6 but log a warning the first time they are called
+(`journalctl -u ledmatrix` shows which one), and are **removed in 3.7.0**.
+Nothing in core, the official plugins or the third-party plugins in the
+registry calls them.
+
+| Object | Methods | Instead |
+|---|---|---|
+| `cache_manager` | `update_cache` | `set()` |
+| `cache_manager` | `get_background_cached_data`, `is_background_data_available` | `get()` |
+| `cache_manager` | `has_data_changed`, `setup_persistent_cache`, `get_sport_live_interval`, `get_sport_key_from_cache_key`, `record_cache_hit`, `record_cache_miss`, `record_fetch_time`, `get_cache_metrics`, `log_cache_metrics`, `get_memory_cache_stats` | no replacement |
+| `display_manager` | `draw_weather_icon`, `draw_sun`, `draw_cloud`, `draw_rain`, `draw_snow`, `draw_text_with_icons` | draw your own icons (the weather plugin ships `WeatherIcons`) |
+| `display_manager` | `get_scrolling_stats` | no replacement |
+| `font_manager` | `get_font_catalog`, `get_available_fonts` | read `font_catalog` |
+| `font_manager` | `set_override`, `remove_override`, `get_overrides`, `add_font`, `remove_font`, `validate_font`, `get_size_tokens`, `get_performance_stats`, `get_manager_fonts`, `get_detected_fonts`, `get_plugin_fonts`, `unregister_plugin_fonts` | no replacement |
+| `plugin_manager` | `get_enabled_plugins` | check `enabled` on the entries in `plugin_manager.plugins` |
+

docs/PLUGIN_ARCHITECTURE_SPEC.md

@@ -8,12 +8,13 @@
 > - 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 (`web_interface/blueprints/api_v3/`) is mounted at `/api/v3`
+>   in `web_interface/app.py`.
 > - 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`).
+> - Example imports use `src/plugin_system/base_classes/*_plugin.py`,
+>   which do not exist. The old `src/base_classes/` package has been
+>   removed; shared sports code lives in `src/common/`.
 > - The "Migration Strategy" and "Implementation Roadmap" sections
 >   describe work that has now shipped.
 >
@@ -189,7 +190,9 @@ class BasePlugin(ABC):
     def update(self) -> None:
         """
         Fetch/update data for this plugin.
-        Called based on update_interval in manifest.
+        Called every get_update_interval() seconds when that returns a
+        number, otherwise at the static interval: the manifest's
+        update_interval, else the plugin config's update_interval, else 60s.
         """
         pass
     
@@ -204,6 +207,21 @@ class BasePlugin(ABC):
         """
         pass
     
+    def get_update_interval(self) -> Optional[float]:
+        """
+        Seconds until update() should run again, decided at runtime.
+        Return None (the default) to use the static interval.
+
+        PluginManager._get_plugin_update_interval calls this on every
+        scheduling tick. A number overrides the manifest and is clamped up
+        to PluginManager.MIN_DYNAMIC_UPDATE_INTERVAL (5s); None, a raise,
+        or a non-finite/non-numeric value falls back to the manifest's
+        update_interval, then the plugin config's update_interval, then
+        60s. The static value is cached until the plugin reloads; the hook
+        is not cached, so it must be cheap and must not raise.
+        """
+        return None
+    
     def get_display_duration(self) -> float:
         """
         Get the display duration for this plugin instance.

docs/PLUGIN_CONFIGURATION_GUIDE.md

@@ -9,7 +9,7 @@ The LEDMatrix system uses a plugin-based architecture where each plugin manages
 1. **Install a plugin** from the Plugin Store in the web interface
 2. **Navigate to the plugin's configuration tab** (automatically created when installed)
 3. **Configure settings** using the auto-generated form
-4. **Save configuration** and restart the display service
+4. **Save configuration**; the running display applies it without a restart
 
 For detailed information, see the sections below.
 
@@ -67,9 +67,7 @@ The main configuration file (`config/config.json`) now contains only essential s
         "time_format": "%I:%M %p"
     },
     "plugin_system": {
-        "plugins_directory": "plugin-repos",
-        "auto_discover": true,
-        "auto_load_enabled": true
+        "plugins_directory": "plugin-repos"
     }
 }
 ```
@@ -93,9 +91,9 @@ The main configuration file (`config/config.json`) now contains only essential s
 
 #### 4. Plugin System
 - **plugin_system**: Plugin system configuration
-  - **plugins_directory**: Directory where plugins are stored
-  - **auto_discover**: Automatically discover plugins
-  - **auto_load_enabled**: Automatically load enabled plugins
+  - **plugins_directory**: Directory where plugins are stored (the only one the loader scans)
+  - `auto_discover`, `auto_load_enabled`, `development_mode` may still appear in
+    older configs; nothing reads them (see [CONFIG_REFERENCE.md](CONFIG_REFERENCE.md#plugin_system))
 
 ## Plugin Configuration
 
@@ -191,19 +189,20 @@ plugin-repos/
     "author": "Your Name",
     "entry_point": "manager.py",
     "class_name": "MyPlugin",
-    "display_modes": ["my_plugin"],
-    "config_schema": "config_schema.json"
+    "display_modes": ["my_plugin"]
 }
 ```
 
-The required fields the plugin loader will check for are `id`,
-`name`, `version`, `class_name`, and `display_modes`. `entry_point`
-defaults to `manager.py` if omitted. `config_schema` must be a
-**file path** (relative to the plugin directory) — the schema itself
-lives in a separate JSON file, not inline in the manifest. The
-`class_name` value must match the actual class defined in the entry
-point file **exactly** (case-sensitive, no spaces); otherwise the
-loader fails with `AttributeError` at load time.
+The Plugin Store refuses a manifest that lacks any of `id`, `name`,
+`class_name` or `display_modes` (`store_manager.py`); the loader itself
+needs `class_name`. `version` is not required, but the store compares it
+with the registry's `latest_version` to offer updates, so set it.
+`entry_point` defaults to `manager.py` if omitted. The config schema is not
+named in the manifest: it is always the file `config_schema.json` in the
+plugin directory. The `class_name` value must match the actual class
+defined in the entry point file **exactly** (case-sensitive, no spaces);
+otherwise the loader fails with a `PluginError` ("Class ... not found in
+module") at load time.
 
 ### Plugin Manager Class
 
@@ -225,9 +224,11 @@ class MyPlugin(BasePlugin):
         """Render plugin content to the LED matrix."""
         pass
     
-    def get_duration(self):
-        """Get display duration for this plugin"""
-        return self.config.get('duration', 30)
+    # BasePlugin.get_display_duration() already returns
+    # self.config['display_duration'] (default 15s); override it only to
+    # vary the duration with the content.
+    def get_display_duration(self):
+        return self.config.get('display_duration', 30)
 ```
 
 ### Dynamic Duration Configuration
@@ -261,7 +262,7 @@ Each installed plugin automatically gets its own dedicated configuration tab in
 
 ### Accessing Plugin Configuration
 
-1. Navigate to the **Plugins** tab to see all installed plugins
+1. Navigate to the **Plugin Manager** tab to see all installed plugins
 2. Click the **Configure** button on any plugin card, or
 3. Click directly on the plugin's tab button in the navigation bar
 
@@ -280,7 +281,6 @@ Configuration forms are automatically generated from each plugin's `config_schem
 - **Type-safe inputs**: Form inputs match JSON Schema types
 - **Default values**: Fields show current values or schema defaults
 - **Real-time validation**: Input constraints enforced (min, max, maxLength, etc.)
-- **Reset to defaults**: One-click reset to restore original settings
 - **Help text**: Each field shows description from schema
 
 For more details, see [Plugin Configuration Tabs](PLUGIN_CONFIGURATION_TABS.md).
@@ -339,20 +339,16 @@ The configuration system uses JSON Schema Draft-07 for validation:
 2. **Configuration errors**: Validate plugin configuration against schema
 3. **Display issues**: Check display durations and plugin display methods
 4. **Performance**: Monitor plugin update intervals and resource usage
-5. **Tab not showing**: Verify `config_schema.json` exists and is referenced in manifest
+5. **Form missing or wrong**: Verify `config_schema.json` exists in the plugin directory and is valid JSON Schema
 6. **Settings not saving**: Check validation errors and ensure all required fields are filled
 
 ### Debug Mode
 
-Enable debug logging to troubleshoot plugin issues:
+There is no config key for debug logging. Run the display with debug
+logging instead:
 
-```json
-{
-    "plugin_system": {
-        "debug": true,
-        "log_level": "debug"
-    }
-}
+```bash
+python3 run.py -d            # or: LEDMATRIX_DEBUG=true python3 run.py
 ```
 
 ## See Also

docs/PLUGIN_CONFIGURATION_TABS.md

@@ -1,18 +1,8 @@
 # Plugin Configuration Tabs
 
-> **Status note:** this doc was written during the rollout of the
-> per-plugin configuration tab feature. The feature itself is shipped
-> and working in the current v3 web interface, but a few file paths
-> in the "Implementation Details" section below still reference the
-> pre-v3 file layout (`web_interface_v2.py`, `templates/index_v2.html`).
-> The current implementation lives in `web_interface/app.py`,
-> `web_interface/blueprints/api_v3.py`, and `web_interface/templates/v3/`.
-> The user-facing description (Overview, Features, Form Generation
-> Process) is still accurate.
-
 ## Overview
 
-Each installed plugin now gets its own dedicated configuration tab in the web interface. This provides a clean, organized way to configure plugins without cluttering the main Plugins management tab.
+Each installed plugin now gets its own dedicated configuration tab in the web interface. This provides a clean, organized way to configure plugins without cluttering the **Plugin Manager** tab.
 
 ## Features
 
@@ -20,24 +10,27 @@ Each installed plugin now gets its own dedicated configuration tab in the web in
 - **JSON Schema-Based Forms**: Configuration forms are automatically generated based on each plugin's `config_schema.json`
 - **Type-Safe Inputs**: Form inputs are created based on the JSON Schema type (boolean, number, string, array, enum)
 - **Default Values**: All fields show current values or fallback to schema defaults
-- **Reset Functionality**: Users can reset all settings to defaults with one click
 - **Real-Time Validation**: Input constraints from JSON Schema are enforced (min, max, maxLength, etc.)
 
 ## User Experience
 
 ### Accessing Plugin Configuration
 
-1. Navigate to the **Plugins** tab to see all installed plugins
+1. Navigate to the **Plugin Manager** tab to see all installed plugins
 2. Click the **Configure** button on any plugin card
 3. You'll be automatically taken to that plugin's configuration tab
-4. Alternatively, click directly on the plugin's tab button (marked with a puzzle piece icon)
+4. Alternatively, click directly on the plugin's tab button in the second nav row
 
 ### Configuring a Plugin
 
 1. Open the plugin's configuration tab
 2. Modify settings using the generated form
-3. Click **Save Configuration**
-4. Restart the display service to apply changes
+3. Click **Save Configuration**. The settings apply to the running display
+   without a restart: the display service reloads `config.json` when it
+   changes and calls the plugin's `on_config_change()`
+
+The tab also has **Refresh** (reload the form), **Update** (update the
+plugin) and **Uninstall** buttons.
 
 ### Plugin Manager vs Per-Plugin Configuration
 
@@ -52,22 +45,13 @@ Each installed plugin now gets its own dedicated configuration tab in the web in
 
 ### Requirements
 
-To enable automatic configuration tab generation, your plugin must:
+Every installed plugin gets a tab. To get a generated form in it, include a
+`config_schema.json` file in the plugin's directory. The name is fixed: the
+web interface finds the schema by that file name (`SchemaManager` in
+`src/plugin_system/schema_manager.py`), and no manifest field points to it.
 
-1. Include a `config_schema.json` file
-2. Reference it in your `manifest.json`:
-
-```json
-{
-  "id": "your-plugin",
-  "name": "Your Plugin",
-  "icon": "fas fa-star",  // Optional: Custom tab icon
-  ...
-  "config_schema": "config_schema.json"
-}
-```
-
-**Note:** You can optionally specify a custom `icon` for your plugin tab. See [Plugin Custom Icons Guide](PLUGIN_CUSTOM_ICONS.md) for details.
+**Note:** You can optionally specify a Font Awesome `icon` class for your
+plugin tab in `manifest.json`. See [Plugin Custom Icons Guide](PLUGIN_CUSTOM_ICONS.md) for details.
 
 ### Supported JSON Schema Types
 
@@ -208,69 +192,32 @@ Renders as: Dropdown select
 
 ### Form Generation Process
 
-1. Web UI loads installed plugins via `/api/v3/plugins/installed`
-2. For each plugin, the backend loads its `config_schema.json`
-3. Frontend generates a tab button with plugin name
-4. Frontend generates a form based on the JSON Schema
-5. Current config values from `config.json` are populated
-6. When saved, each field is sent to `/api/v3/plugins/config` endpoint
+Forms are rendered on the server, not generated in the browser:
 
-## Implementation Details
-
-### Backend Changes
-
-**File**: `web_interface_v2.py`
-
-- Modified `/api/v3/plugins/installed` endpoint to include `config_schema_data`
-- Loads each plugin's `config_schema.json` if it exists
-- Returns schema data along with plugin info
-
-### Frontend Changes
-
-**File**: `templates/index_v2.html`
-
-New Functions:
-- `generatePluginTabs(plugins)` - Creates tab buttons and content for each plugin
-- `generatePluginConfigForm(plugin)` - Generates HTML form from JSON Schema
-- `savePluginConfiguration(pluginId)` - Saves form data to backend
-- `resetPluginConfig(pluginId)` - Resets all settings to defaults
-- `configurePlugin(pluginId)` - Navigates to plugin's tab
-
-### Data Flow
-
-```
-Page Load
-  → refreshPlugins()
-    → /api/v3/plugins/installed
-      → Returns plugins with config_schema_data
-    → generatePluginTabs()
-      → Creates tab buttons
-      → Creates tab content
-        → generatePluginConfigForm()
-          → Reads JSON Schema
-          → Creates form inputs
-          → Populates current values
-
-User Saves
-  → savePluginConfiguration()
-    → Reads form data
-    → Converts types per schema
-    → Sends to /api/v3/plugins/config
-      → Updates config.json
-    → Shows success notification
-```
+1. The web UI loads installed plugins via `/api/v3/plugins/installed` and adds
+   a tab button for each one
+2. Opening a tab loads `/v3/partials/plugin-config/<plugin_id>`
+   (`web_interface/blueprints/pages_v3.py`), which loads the plugin's schema
+   through `SchemaManager` and its current values from `config.json`
+3. `web_interface/templates/v3/partials/plugin_config.html` renders the form
+   from the schema (widgets named by `x-widget` are rendered by the scripts in
+   `web_interface/static/v3/js/widgets/`)
+4. **Save Configuration** posts the form to `/api/v3/plugins/config`
+   (`web_interface/blueprints/api_v3/plugins.py`), which validates it against
+   the schema, writes `config.json` (secret fields go to
+   `config_secrets.json`) and shows a notification
 
 ## Troubleshooting
 
 ### Plugin Tab Not Appearing
 
-- Ensure `config_schema.json` exists in plugin directory
-- Verify `config_schema` field in `manifest.json`
+- Check that the plugin is installed and appears in the **Plugin Manager** tab
 - Check browser console for errors
-- Try refreshing plugins (Plugins tab → Refresh button)
+- Reload the page
 
 ### Form Not Generating Correctly
 
+- Ensure `config_schema.json` exists in the plugin directory
 - Validate your `config_schema.json` against JSON Schema Draft 07
 - Check that all properties have a `type` field
 - Ensure `default` values match the specified type
@@ -282,7 +229,6 @@ User Saves
 - Check that config keys match schema properties
 - Verify backend API is accessible
 - Check browser network tab for API errors
-- Ensure display service is restarted after config changes
 
 ## Migration Guide
 
@@ -300,26 +246,21 @@ If your plugin doesn't have a config schema:
 2. Add descriptions for each property
 3. Set appropriate defaults
 4. Add validation constraints (min, max, etc.)
-5. Reference the schema in your `manifest.json`
 
 ### Backward Compatibility
 
 - Plugins without `config_schema.json` still work normally
-- They simply won't have a configuration tab
+- Their tab shows plain text, number and checkbox inputs for the keys already
+  in their `config.json` section, or "No configuration options available for
+  this plugin." when there are none
 - Users can still edit config via the Raw JSON editor
-- The Configure button will navigate to a tab with a friendly message
 
-## Future Enhancements
+## Beyond the Basic Types
 
-Potential improvements for future versions:
-
-- **Advanced Schema Features**: Support for nested objects, conditional fields
-- **Visual Validation**: Real-time validation feedback as user types
-- **Color Pickers**: Special input for RGB/color array types
-- **File Uploads**: Support for image/asset uploads
-- **Import/Export**: Save and share plugin configurations
-- **Presets**: Quick-switch between saved configurations
-- **Documentation Links**: Link schema fields to plugin documentation
+Nested objects (rendered as collapsible sections), `x-widget` widgets such as
+`color-picker` and `file-upload`, and more are supported; see
+[PLUGIN_CONFIGURATION_GUIDE.md](PLUGIN_CONFIGURATION_GUIDE.md) and
+`web_interface/static/v3/js/widgets/README.md`.
 
 ## Example Plugins
 

docs/PLUGIN_CONFIG_ARCHITECTURE.md

@@ -11,427 +11,179 @@
 ### Component Overview
 
 ```
-┌─────────────────────────────────────────────────────────────────┐
-│                         Web Browser                              │
-│  ┌─────────────────────────────────────────────────────────┐   │
-│  │                    Tab Navigation Bar                     │   │
-│  │  [Overview] [General] ... [Plugins] [Plugin X] [Plugin Y]│   │
-│  └─────────────────────────────────────────────────────────┘   │
-│                                                                   │
-│  ┌─────────────────┐  ┌──────────────────────────────────┐     │
-│  │  Plugins Tab    │  │   Plugin X Configuration Tab     │     │
-│  │                 │  │                                    │     │
-│  │ • Install       │  │  Form Generated from Schema:      │     │
-│  │ • Update        │  │  • Boolean → Toggle               │     │
-│  │ • Uninstall     │  │  • Number → Number Input          │     │
-│  │ • Enable        │  │  • String → Text Input            │     │
-│  │ • [Configure]──────→  • Array → Comma Input           │     │
-│  │                 │  │  • Enum → Dropdown                │     │
-│  └─────────────────┘  │                                    │     │
-│                        │  [Save] [Back] [Reset]            │     │
-│                        └──────────────────────────────────┘     │
-└─────────────────────────────────────────────────────────────────┘
+┌──────────────────────────────────────────────────────────────────┐
+│ Web browser (templates/v3/base.html, Alpine.js + HTMX)            │
+│                                                                    │
+│  Second nav row: one tab per installed plugin                      │
+│  Clicking a tab: GET /v3/partials/plugin-config/<plugin_id>        │
+│  → server-rendered form swapped into the tab                       │
+│                                                                    │
+│  Save: hx-post="/api/v3/plugins/config?plugin_id=<id>" (form data) │
+└──────────────────────────────────────────────────────────────────┘
                                 │
-                                │ HTTP API
                                 ▼
-┌─────────────────────────────────────────────────────────────────┐
-│                      Flask Backend                               │
-│  ┌───────────────────────────────────────────────────────┐     │
-│  │         /api/v3/plugins/installed                         │     │
-│  │  • Discover plugins in plugins/ directory              │     │
-│  │  • Load manifest.json for each plugin                  │     │
-│  │  • Load config_schema.json if exists                   │     │
-│  │  • Load current config from config.json                │     │
-│  │  • Return combined data to frontend                    │     │
-│  └───────────────────────────────────────────────────────┘     │
-│                                                                   │
-│  ┌───────────────────────────────────────────────────────┐     │
-│  │         /api/v3/plugins/config                            │     │
-│  │  • Receive key-value pair                              │     │
-│  │  • Update config.json                                  │     │
-│  │  • Return success/error                                │     │
-│  └───────────────────────────────────────────────────────┘     │
-└─────────────────────────────────────────────────────────────────┘
+┌──────────────────────────────────────────────────────────────────┐
+│ Flask (web_interface/app.py)                                       │
+│                                                                    │
+│  pages_v3 blueprint (blueprints/pages_v3.py)                       │
+│   _load_plugin_config_partial(plugin_id)                           │
+│    • SchemaManager.load_schema() → config_schema.json              │
+│    • config.json section for the plugin                            │
+│    • masks x-secret fields                                         │
+│    • renders partials/plugin_config.html (render_field macros)     │
+│                                                                    │
+│  api_v3 blueprint (blueprints/api_v3/plugins.py)                   │
+│   save_plugin_config()   POST /api/v3/plugins/config               │
+│   get_plugin_config()    GET  /api/v3/plugins/config               │
+│   get_plugin_schema()    GET  /api/v3/plugins/schema               │
+│   reset_plugin_config()  POST /api/v3/plugins/config/reset         │
+└──────────────────────────────────────────────────────────────────┘
                                 │
-                                │ File System
                                 ▼
-┌─────────────────────────────────────────────────────────────────┐
-│                      File System                                 │
-│                                                                   │
-│  plugins/                                                         │
-│  ├── hello-world/                                                │
-│  │   ├── manifest.json ───┐                                     │
-│  │   ├── config_schema.json ─┼─→ Defines UI structure           │
-│  │   ├── manager.py          │                                   │
-│  │   └── requirements.txt    │                                   │
-│  └── clock-simple/            │                                   │
-│      ├── manifest.json        │                                   │
-│      └── config_schema.json ──┘                                  │
-│                                                                   │
-│  config/                                                          │
-│  └── config.json ────────────→ Stores configuration values       │
-│      {                                                            │
-│        "hello-world": {                                           │
-│          "enabled": true,                                         │
-│          "message": "Hello!",                                     │
-│          ...                                                      │
-│        }                                                          │
-│      }                                                            │
-└─────────────────────────────────────────────────────────────────┘
+┌──────────────────────────────────────────────────────────────────┐
+│ Files                                                              │
+│  plugin-repos/<id>/config_schema.json   JSON Schema (Draft-7)      │
+│  config/config.json                     { "<id>": { ... } }        │
+│  config/config_secrets.json             { "<id>": { secrets } }    │
+└──────────────────────────────────────────────────────────────────┘
 ```
 
+The plugins directory is `plugin_system.plugins_directory` in
+`config/config.json` (default `plugin-repos/`). Plugin configuration lives in
+`config/config.json`, not in the plugin directory, so it survives reinstalls.
+
 ## Data Flow
 
-### 1. Page Load Sequence
+### 1. Rendering a plugin's tab
 
 ```
-User Opens Web Interface
-         │
-         ▼
-DOMContentLoaded Event
-         │
-         ▼
-refreshPlugins()
-         │
-         ▼
-GET /api/v3/plugins/installed
-         │
-         ├─→ For each plugin directory:
-         │   ├─→ Read manifest.json
-         │   ├─→ Read config_schema.json (if exists)
-         │   └─→ Read config from config.json
-         │
-         ▼
-Return JSON Array:
-[{
-  id: "hello-world",
-  name: "Hello World",
-  config: { enabled: true, message: "Hello!" },
-  config_schema_data: {
-    properties: {
-      enabled: { type: "boolean", ... },
-      message: { type: "string", ... }
-    }
-  }
-}, ...]
-         │
-         ▼
-generatePluginTabs(plugins)
-         │
-         ├─→ For each plugin:
-         │   ├─→ Create tab button
-         │   ├─→ Create tab content div
-         │   └─→ generatePluginConfigForm(plugin)
-         │           │
-         │           ├─→ Read schema properties
-         │           ├─→ Get current config values
-         │           └─→ Generate HTML form inputs
-         │
-         ▼
-Tabs Rendered in UI
+User opens the plugin's tab
+        │
+        ▼
+GET /v3/partials/plugin-config/<plugin_id>        (pages_v3)
+        │
+        ├─→ Load schema (SchemaManager, no cache)
+        ├─→ Load config.json[<plugin_id>]
+        ├─→ Mask "x-secret" values (fails closed if the schema is unusable)
+        └─→ render partials/plugin_config.html
+                │
+                └─→ render_field() per property, recursively:
+                      boolean → toggle, number/integer → input or slider,
+                      string → input / textarea / select (enum),
+                      array → list or table widget,
+                      object → collapsible nested section,
+                      "x-widget" → a registered widget
+                               (static/v3/js/widgets/, or one the plugin ships)
 ```
 
-### 2. Configuration Save Sequence
+Nested objects are supported: a nested field is posted with a dotted name
+(e.g. `transition.type`).
+
+### 2. Saving
 
 ```
-User Modifies Form
-         │
-         ▼
-User Clicks "Save"
-         │
-         ▼
-savePluginConfiguration(pluginId)
-         │
-         ├─→ Get form data
-         ├─→ For each field:
-         │   ├─→ Get schema type
-         │   ├─→ Convert value to correct type
-         │   │   • boolean: checkbox.checked
-         │   │   • integer: parseInt()
-         │   │   • number: parseFloat()
-         │   │   • array: split(',')
-         │   │   • string: as-is
-         │   │
-         │   └─→ POST /api/v3/plugins/config
-         │       {
-         │         plugin_id: "hello-world",
-         │         key: "message",
-         │         value: "Hello, World!"
-         │       }
-         │
-         ▼
-Backend Updates config.json
-         │
-         ▼
-Return Success
-         │
-         ▼
-Show Notification
-         │
-         ▼
-Refresh Plugins
+User clicks Save
+        │
+        ▼
+validatePluginConfigForm() (client-side checks)
+        │
+        ▼
+POST /api/v3/plugins/config?plugin_id=<id>   (form data, all fields of the form)
+        │
+        ▼
+save_plugin_config()                          (api_v3/plugins.py)
+        ├─→ Start from the stored config.json[<id>]
+        ├─→ Apply form fields: dotted names → nested keys, "[]" checkbox
+        │   groups → lists, values coerced to the schema's types
+        ├─→ Merge schema defaults for keys that are still missing
+        ├─→ Validate against the schema (plus core per-plugin properties);
+        │   invalid → 400 with the validation errors, nothing saved
+        ├─→ Split "x-secret" fields out; masked/blank secrets are dropped so
+        │   an untouched secret keeps its stored value
+        ├─→ Deep-merge regular fields into config.json[<id>] (atomic save)
+        ├─→ Merge secrets into config_secrets.json[<id>]
+        └─→ Call the loaded plugin's on_config_change() (and
+            on_enable/on_disable if "enabled" changed)
+        │
+        ▼
+One response for the whole form → notification in the UI
 ```
 
-## Class and Function Hierarchy
+The display service picks up the new config through its config hot reload
+(ConfigService) without a restart.
 
-### Frontend (JavaScript)
+JSON clients can post `{"plugin_id": ..., "config": {...}}` instead; the keys
+sent are merged onto the stored config the same way. See
+[REST_API_REFERENCE.md](REST_API_REFERENCE.md#save-plugin-configuration).
 
-```
-Window Load
-  └── DOMContentLoaded
-      └── refreshPlugins()
-          ├── fetch('/api/v3/plugins/installed')
-          ├── renderInstalledPlugins(plugins)
-          └── generatePluginTabs(plugins)
-              └── For each plugin:
-                  ├── Create tab button
-                  ├── Create tab content
-                  └── generatePluginConfigForm(plugin)
-                      ├── Read config_schema_data
-                      ├── Read current config
-                      └── Generate form HTML
-                          ├── Boolean → Toggle switch
-                          ├── Number → Number input
-                          ├── String → Text input
-                          ├── Array → Comma-separated input
-                          └── Enum → Select dropdown
+### 3. Reset
 
-User Interactions
-  ├── configurePlugin(pluginId)
-  │   └── showTab(`plugin-${pluginId}`)
-  │
-  ├── savePluginConfiguration(pluginId)
-  │   ├── Process form data
-  │   ├── Convert types per schema
-  │   └── For each field:
-  │       └── POST /api/v3/plugins/config
-  │
-  └── resetPluginConfig(pluginId)
-      ├── Get schema defaults
-      └── For each field:
-          └── POST /api/v3/plugins/config
-```
-
-### Backend (Python)
-
-```
-Flask Routes
-  ├── /api/v3/plugins/installed (GET)
-  │   └── api_plugins_installed()
-  │       ├── PluginManager.discover_plugins()
-  │       ├── For each plugin:
-  │       │   ├── PluginManager.get_plugin_info()
-  │       │   ├── Load config_schema.json
-  │       │   └── Load config from config.json
-  │       └── Return JSON response
-  │
-  └── /api/v3/plugins/config (POST)
-      └── api_plugin_config()
-          ├── Parse request JSON
-          ├── Load current config
-          ├── Update config[plugin_id][key] = value
-          └── Save config.json
-```
-
-## File Structure
-
-```
-LEDMatrix/
-│
-├── web_interface_v2.py
-│   └── Flask backend with plugin API endpoints
-│
-├── templates/
-│   └── index_v2.html
-│       └── Frontend with dynamic tab generation
-│
-├── config/
-│   └── config.json
-│       └── Stores all plugin configurations
-│
-├── plugins/
-│   ├── hello-world/
-│   │   ├── manifest.json           ← Plugin metadata
-│   │   ├── config_schema.json      ← UI schema definition
-│   │   ├── manager.py              ← Plugin logic
-│   │   └── requirements.txt
-│   │
-│   └── clock-simple/
-│       ├── manifest.json
-│       ├── config_schema.json
-│       └── manager.py
-│
-└── docs/
-    ├── PLUGIN_CONFIGURATION_TABS.md       ← Full documentation
-    ├── PLUGIN_CONFIG_TABS_SUMMARY.md      ← Implementation summary
-    ├── PLUGIN_CONFIG_QUICK_START.md       ← Quick start guide
-    └── PLUGIN_CONFIG_ARCHITECTURE.md      ← This file
-```
+`POST /api/v3/plugins/config/reset` replaces the plugin's section with the
+schema defaults (keeping secrets unless `preserve_secrets` is false).
 
 ## Key Design Decisions
 
-### 1. Dynamic Tab Generation
+### 1. Server-side rendered forms
 
-**Why**: Plugins are installed/uninstalled dynamically  
-**How**: JavaScript creates/removes tab elements on plugin list refresh  
-**Benefit**: No server-side template rendering needed
+**Why**: One renderer for every plugin, no per-plugin frontend code
+**How**: Jinja macros in `partials/plugin_config.html` walk the schema
+**Benefit**: The settings search index is built from the same rendered HTML
+(`/v3/settings/search-index`)
 
-### 2. JSON Schema as Source of Truth
+### 2. JSON Schema as source of truth
 
-**Why**: Standard, well-documented, validation-ready  
-**How**: Frontend interprets schema to generate forms  
-**Benefit**: Plugin developers use familiar format
+**Why**: Standard, well-documented, validation-ready
+**How**: The same schema drives the form, the defaults and server-side validation
+**Benefit**: Plugin developers use a familiar format
 
-### 3. Individual Config Updates
+### 3. Whole-form saves that merge
 
-**Why**: Simplifies backend API  
-**How**: Each field saved separately via `/api/v3/plugins/config`  
-**Benefit**: Atomic updates, easier error handling
+**Why**: A partial form (or a field the form doesn't show) must not wipe
+stored values
+**How**: The handler starts from the stored section and merges what was posted
+**Benefit**: One request per save, atomic write
 
-### 4. Type Conversion in Frontend
+### 4. Secrets kept out of config.json
 
-**Why**: HTML forms only return strings  
-**How**: JavaScript converts based on schema type before sending  
-**Benefit**: Backend receives correctly-typed values
-
-### 5. No Nested Objects
-
-**Why**: Keeps UI simple  
-**How**: Only flat property structures supported  
-**Benefit**: Easy form generation, clear to users
+**Why**: `config.json` is shown in the raw editor and returned by the API
+**How**: `"x-secret": true` fields go to `config_secrets.json`, which is
+deep-merged back into the plugin's config at load time
+**Benefit**: Plugins read secrets with plain `config.get(...)`
 
 ## Extension Points
 
-### Adding New Input Types
+### Custom input widgets
 
-Location: `generatePluginConfigForm()` in `index_v2.html`
+Set `"x-widget": "<name>"` on a property. Core widgets are in
+`web_interface/static/v3/js/widgets/` (see its README); a plugin can ship its
+own widget script, served from `/static/plugin-widgets/<plugin_id>/<name>.js`.
+See [widget-guide.md](widget-guide.md).
 
-```javascript
-if (type === 'your-new-type') {
-    formHTML += `
-        <!-- Your custom input HTML -->
-    `;
-}
-```
+### Custom actions
 
-### Custom Validation
+Buttons that run plugin scripts are declared in the manifest's
+`web_ui_actions`. See [PLUGIN_WEB_UI_ACTIONS.md](PLUGIN_WEB_UI_ACTIONS.md).
 
-Location: `savePluginConfiguration()` in `index_v2.html`
+### Reacting to changes
 
-```javascript
-// Add validation before sending
-if (!validateCustomConstraint(value, propSchema)) {
-    throw new Error('Validation failed');
-}
-```
+Implement `on_config_change(new_config)` in the plugin (see
+[PLUGIN_API_REFERENCE.md](PLUGIN_API_REFERENCE.md)).
 
-### Backend Hook
+## Where to Look
 
-Location: `api_plugin_config()` in `web_interface_v2.py`
-
-```python
-# Add custom logic before saving
-if plugin_id == 'special-plugin':
-    value = transform_value(value)
-```
-
-## Performance Considerations
-
-### Frontend
-
-- **Tab Generation**: O(n) where n = number of plugins (typically < 20)
-- **Form Generation**: O(m) where m = number of config properties (typically < 10)
-- **Memory**: Each plugin tab ~5KB HTML
-- **Total Impact**: Negligible for typical use cases
-
-### Backend
-
-- **Schema Loading**: Cached after first load
-- **Config Updates**: Single file write (atomic)
-- **API Calls**: One per config field on save (sequential)
-- **Optimization**: Could batch updates in single API call
-
-## Security Considerations
-
-1. **Input Validation**: Schema constraints enforced client-side (UX) and should be enforced server-side
-2. **Path Traversal**: Plugin paths validated against known plugin directory
-3. **XSS**: All user inputs escaped before rendering in HTML
-4. **CSRF**: Flask CSRF tokens should be used in production
-5. **File Permissions**: config.json requires write access
+| Concern | File |
+|---------|------|
+| Tab partial loader | `web_interface/blueprints/pages_v3.py` (`_load_plugin_config_partial`) |
+| Form template and field macros | `web_interface/templates/v3/partials/plugin_config.html` |
+| Save / get / schema / reset handlers | `web_interface/blueprints/api_v3/plugins.py` |
+| Schema loading, defaults, validation | `src/plugin_system/schema_manager.py` |
+| Secret masking and splitting | `src/web_interface/secret_helpers.py` |
+| Widgets | `web_interface/static/v3/js/widgets/` |
 
 ## Error Handling
 
-### Frontend
-
-- Network errors: Show notification, don't crash
-- Schema errors: Graceful fallback to no config tab
-- Type errors: Log to console, continue processing other fields
-
-### Backend
-
-- Invalid plugin_id: 400 Bad Request
-- Schema not found: Return null, frontend handles gracefully
-- Config save error: 500 Internal Server Error with message
-
-## Testing Strategy
-
-### Unit Tests
-
-- `generatePluginConfigForm()` for each schema type
-- Type conversion logic in `savePluginConfiguration()`
-- Backend schema loading logic
-
-### Integration Tests
-
-- Full save flow: form → API → config.json
-- Tab generation from API response
-- Reset to defaults
-
-### E2E Tests
-
-- Install plugin → verify tab appears
-- Configure plugin → verify config saved
-- Uninstall plugin → verify tab removed
-
-## Monitoring
-
-### Frontend Metrics
-
-- Time to generate tabs
-- Form submission success rate
-- User interactions (configure, save, reset)
-
-### Backend Metrics
-
-- API response times
-- Config update success rate
-- Schema loading errors
-
-### User Feedback
-
-- Are users finding the configuration interface?
-- Are validation errors clear?
-- Are default values sensible?
-
-## Future Roadmap
-
-### Phase 2: Enhanced Validation
-- Real-time validation feedback
-- Custom error messages
-- Dependent field validation
-
-### Phase 3: Advanced Inputs
-- Color pickers for RGB arrays
-- File upload for assets
-- Rich text editor for descriptions
-
-### Phase 4: Configuration Management
-- Export/import configurations
-- Configuration presets
-- Version history/rollback
-
-### Phase 5: Developer Tools
-- Schema editor in web UI
-- Live preview while editing schema
-- Validation tester
-
+- Unknown plugin or unreadable schema: the partial renders an error message
+- Validation failure: `400` with `details` and `context.validation_errors`;
+  the form shows them and nothing is saved
+- Save failure: `500` with an error message; config.json is written
+  atomically, so a failed save leaves the previous file intact

docs/PLUGIN_CONFIG_CORE_PROPERTIES.md

@@ -6,7 +6,8 @@ The LEDMatrix plugin system automatically manages certain core properties that a
 
 ## Core Properties
 
-The following properties are automatically managed by the system:
+The following properties are automatically managed by the system (the list
+is `CORE_PLUGIN_PROPERTIES` in `src/plugin_system/schema_manager.py`):
 
 1. **`enabled`** (boolean)
    - Default: `true`
@@ -24,6 +25,18 @@ The following properties are automatically managed by the system:
    - Description: Enable live priority takeover when plugin has live content
    - Used by DisplayController for priority scheduling
 
+4. **`vegas_width_pct`**, **`vegas_overflow`**, **`vegas_max_width_screens`**
+   (untyped; no default)
+   - Description: Vegas mode tuning for this plugin — card width as a
+     percentage of the panel, `"rotate"` or `"truncate"` on overflow, and the
+     widest the card may be in screens
+   - Read by `src/vegas_mode/plugin_adapter.py` and `BasePlugin`, which
+     validate the values themselves and ignore a bad one with a log line
+
+`skin` and `skin_options` were core properties until the skin system was
+removed. A plugin config saved with them still loads and saves; the keys are
+dropped on the next save (see `RETIRED_PLUGIN_KEYS` in `schema_manager.py`).
+
 ## How Core Properties Work
 
 ### Schema Validation

docs/PLUGIN_CONFIG_QUICK_START.md

@@ -10,8 +10,8 @@
    and click **Install**
 4. Notice a new tab appears in the second nav row with the plugin's name
 5. Click that tab to configure the plugin
-6. Modify settings and click **Save**
-7. From **Overview**, click **Restart Display Service** to see changes
+6. Modify settings and click **Save Configuration**. The running display
+   picks the change up by itself; no restart is needed
 
 That's it! Each installed plugin automatically gets its own configuration tab.
 
@@ -29,7 +29,6 @@ That's it! Each installed plugin automatically gets its own configuration tab.
 - ✅ Proper input types (toggles, numbers, dropdowns)
 - ✅ Help text explaining each setting
 - ✅ Input validation (min/max, length, etc.)
-- ✅ One-click reset to defaults
 
 ## 📋 Example Walkthrough
 
@@ -40,7 +39,7 @@ Let's configure the "Hello World" plugin:
 After installing the plugin, you'll see a new tab:
 
 ```
-[Overview] [General] [...] [Plugins] [Hello World] ← New tab!
+[Plugin Manager] [Hello World] ← New tab! (second nav row)
 ```
 
 ### Step 2: Configure Settings
@@ -70,15 +69,16 @@ Display Duration
 How long to display in seconds
   [10                   ]
 
-[Save Configuration] [Back] [Reset to Defaults]
+[Refresh] [Update] [Uninstall] [Save Configuration]
 ```
 
 ### Step 3: Save and Apply
 
 1. Modify any settings
 2. Click **Save Configuration**
-3. See confirmation: "Configuration saved for hello-world. Restart display to apply changes."
-4. Restart the display service
+3. See the confirmation notification. Plugin settings apply live: the
+   display service reloads `config.json` when it changes and passes the new
+   settings to the plugin's `on_config_change()`
 
 ## 🛠️ For Plugin Developers
 
@@ -105,19 +105,14 @@ Create `config_schema.json` in your plugin directory:
 }
 ```
 
-Reference it in `manifest.json`:
+**Done!** The file name is fixed: the web interface looks for
+`config_schema.json` in the plugin's directory; there is no manifest field
+for it. Every installed plugin gets a tab; the schema is what turns it into a
+form.
 
-```json
-{
-  "id": "my-plugin",
-  "icon": "fas fa-star",              // Optional: add a custom icon!
-  "config_schema": "config_schema.json"
-}
-```
-
-**Done!** Your plugin now has a configuration tab.
-
-**Bonus:** Add an `icon` field for a custom tab icon! Use Font Awesome icons (`fas fa-star`), emoji (⭐), or custom images. See [PLUGIN_CUSTOM_ICONS.md](PLUGIN_CUSTOM_ICONS.md) for the full guide.
+**Bonus:** an `icon` field in `manifest.json` names a Font Awesome class for
+the tab (`"icon": "fas fa-star"`). See
+[PLUGIN_CUSTOM_ICONS.md](PLUGIN_CUSTOM_ICONS.md).
 
 ## 🎨 Supported Input Types
 
@@ -171,12 +166,10 @@ User enters: `255, 0, 0`
 
 ### For Users
 
-1. **Reset Anytime**: Use "Reset to Defaults" to restore original settings
-2. **Navigate Back**: Switch to the **Plugin Manager** tab to see the
+1. **Navigate Back**: Switch to the **Plugin Manager** tab to see the
    full list of installed plugins
-3. **Check Help Text**: Each field has a description explaining what it does
-4. **Restart Required**: Remember to restart the display service from
-   **Overview** after saving
+2. **Check Help Text**: Each field has a description explaining what it does
+3. **No Restart Needed**: Saved plugin settings apply to the running display
 
 ### For Developers
 
@@ -189,18 +182,17 @@ User enters: `255, 0, 0`
 ## 🔧 Troubleshooting
 
 ### Tab Not Showing
-- Check that `config_schema.json` exists
-- Verify `config_schema` is in `manifest.json`
+- Check that the plugin is installed and listed under **Plugin Manager**
 - Refresh the page
 - Check browser console for errors
 
 ### Settings Not Saving
 - Ensure plugin is properly installed
-- Restart the display service after saving
 - Check that all required fields are filled
 - Look for validation errors in browser console
 
 ### Form Looks Wrong
+- Check that `config_schema.json` is in the plugin's directory
 - Validate your JSON Schema
 - Check that types match your defaults
 - Ensure descriptions are strings

docs/PLUGIN_CUSTOM_ICONS.md

@@ -2,17 +2,28 @@
 
 ## Overview
 
-Plugins can specify custom icons that appear next to their name in the web interface tabs. This makes your plugin instantly recognizable and adds visual polish to the UI.
+A plugin can name an icon for its tab in the web interface's second nav row
+(next to **Plugin Manager**) with the `icon` field in `manifest.json`.
 
-## Icon Types Supported
+> **Status:** the tab code honors `icon`, but `GET /api/v3/plugins/installed`
+> (`web_interface/blueprints/api_v3/plugins.py`) does not currently include
+> the manifest's `icon` in its response, so every tab shows the default
+> puzzle piece. Setting `icon` is harmless and will take effect once the API
+> passes it through again.
 
-The system supports three types of icons:
+## Font Awesome classes only
 
-### 1. Font Awesome Icons (Recommended)
+`icon` is used verbatim as the CSS class of an `<i>` element
+(`iconEl.className = plugin.icon || 'fas fa-puzzle-piece'` in
+`web_interface/static/v3/js/app-shell.js` and the same fallback in
+`app-early.js`). So it must be a Font Awesome class string. Emoji, image
+paths and URLs are not supported: they would end up as a meaningless class
+name and render nothing.
 
-The web interface uses Font Awesome 6, giving you access to thousands of icons.
+The web interface bundles Font Awesome Free 6
+(`web_interface/static/v3/vendor/fontawesome/`), so any free `fas`, `far` or
+`fab` icon works.
 
-**Example:**
 ```json
 {
   "id": "my-plugin",
@@ -21,292 +32,33 @@ The web interface uses Font Awesome 6, giving you access to thousands of icons.
 }
 ```
 
-**Common Font Awesome Icons:**
-- Clock: `fas fa-clock`
+Some common choices:
+
+- Clock / calendar: `fas fa-clock`, `fas fa-calendar-alt`
 - Weather: `fas fa-cloud-sun`, `fas fa-cloud-rain`
-- Calendar: `fas fa-calendar`, `fas fa-calendar-alt`
-- Sports: `fas fa-football-ball`, `fas fa-basketball-ball`
+- Sports: `fas fa-football-ball`, `fas fa-basketball-ball`, `fas fa-trophy`
 - Music: `fas fa-music`, `fas fa-headphones`
 - Finance: `fas fa-chart-line`, `fas fa-dollar-sign`
 - News: `fas fa-newspaper`, `fas fa-rss`
-- Settings: `fas fa-cog`, `fas fa-sliders-h`
-- Timer: `fas fa-stopwatch`, `fas fa-hourglass`
-- Alert: `fas fa-bell`, `fas fa-exclamation-triangle`
-- Heart: `fas fa-heart`, `far fa-heart` (outline)
-- Star: `fas fa-star`, `far fa-star` (outline)
-- Image: `fas fa-image`, `fas fa-camera`
-- Video: `fas fa-video`, `fas fa-film`
-- Game: `fas fa-gamepad`, `fas fa-dice`
+- Games: `fas fa-gamepad`, `fas fa-dice`
 
-**Browse all icons:** [Font Awesome Icon Gallery](https://fontawesome.com/icons)
+Browse the rest in the [Font Awesome gallery](https://fontawesome.com/icons)
+(filter to Free, version 6).
 
-### 2. Emoji Icons (Fun & Simple)
+## Default
 
-Use any emoji character for a colorful, fun icon.
-
-**Example:**
-```json
-{
-  "id": "hello-world",
-  "name": "Hello World",
-  "icon": "👋"
-}
-```
-
-**Popular Emojis:**
-- Time: ⏰ 🕐 ⏱️ ⏲️
-- Weather: ☀️ ⛅ 🌤️ 🌧️ ⛈️ 🌩️ ❄️
-- Sports: ⚽ 🏀 🏈 ⚾ 🎾 🏐
-- Music: 🎵 🎶 🎸 🎹 🎤
-- Money: 💰 💵 💴 💶 💷
-- Calendar: 📅 📆
-- News: 📰 📻 📡
-- Fun: 🎮 🎲 🎯 🎨 🎭
-- Nature: 🌍 🌎 🌏 🌳 🌺 🌸
-- Food: 🍕 🍔 🍟 🍦 ☕ 🍰
-
-### 3. Custom Image URLs (Advanced)
-
-Use a custom image file for ultimate branding.
-
-**Example:**
-```json
-{
-  "id": "my-plugin",
-  "name": "My Plugin",
-  "icon": "/plugins/my-plugin/icon.png"
-}
-```
-
-**Requirements:**
-- Image should be 16x16 to 32x32 pixels
-- Supported formats: PNG, SVG, JPG, GIF
-- Can be a relative path, absolute path, or external URL
-- SVG recommended for best quality at any size
-
-## How to Add an Icon
-
-### Step 1: Choose Your Icon
-
-Decide which type suits your plugin:
-- **Font Awesome**: Professional, consistent with UI
-- **Emoji**: Fun, colorful, no setup needed
-- **Custom Image**: Unique branding, requires image file
-
-### Step 2: Add to manifest.json
-
-Add the `icon` field to your plugin's `manifest.json`:
-
-```json
-{
-  "id": "my-weather-plugin",
-  "name": "Weather Display",
-  "version": "1.0.0",
-  "author": "Your Name",
-  "description": "Shows weather information",
-  "icon": "fas fa-cloud-sun",  // ← Add this line
-  "entry_point": "manager.py",
-  ...
-}
-```
-
-### Step 3: Test Your Plugin
-
-1. Install or update your plugin
-2. Open the web interface
-3. Look for your plugin's tab
-4. The icon should appear next to the plugin name
-
-## Examples
-
-### Weather Plugin
-```json
-{
-  "id": "weather-advanced",
-  "name": "Weather Advanced",
-  "icon": "fas fa-cloud-sun",
-  "description": "Advanced weather display with forecasts"
-}
-```
-**Result:** Tab shows: `☁️ Weather Advanced`
-
-### Clock Plugin
-```json
-{
-  "id": "digital-clock",
-  "name": "Digital Clock",
-  "icon": "⏰",
-  "description": "A beautiful digital clock"
-}
-```
-**Result:** Tab shows: `⏰ Digital Clock`
-
-### Sports Scores Plugin
-```json
-{
-  "id": "sports-scores",
-  "name": "Sports Scores",
-  "icon": "fas fa-trophy",
-  "description": "Live sports scores"
-}
-```
-**Result:** Tab shows: `🏆 Sports Scores`
-
-### Custom Branding
-```json
-{
-  "id": "company-dashboard",
-  "name": "Company Dashboard",
-  "icon": "/plugins/company-dashboard/logo.svg",
-  "description": "Company metrics display"
-}
-```
-**Result:** Tab shows: `[logo] Company Dashboard`
-
-## Best Practices
-
-### 1. Choose Meaningful Icons
-- Icon should relate to plugin functionality
-- Users should understand what the plugin does at a glance
-- Avoid generic icons for specific functionality
-
-### 2. Keep It Simple
-- Simpler icons work better at small sizes
-- Avoid icons with too much detail
-- Test how your icon looks at 16x16 pixels
-
-### 3. Match the UI Style
-- Font Awesome icons match the interface best
-- If using emoji, consider contrast with background
-- Custom images should use similar color schemes
-
-### 4. Consider Accessibility
-- Icons should be recognizable without color
-- Don't rely solely on color to convey meaning
-- The plugin name should be descriptive
-
-### 5. Test on Different Displays
-- Check icon clarity on various screen sizes
-- Ensure emoji render correctly on target devices
-- Custom images should have good contrast
-
-## Icon Categories
-
-Here are recommended icons by plugin category:
-
-### Time & Calendar
-- `fas fa-clock`, `fas fa-calendar`, `fas fa-hourglass`
-- Emoji: ⏰ 📅 ⏱️
-
-### Weather
-- `fas fa-cloud-sun`, `fas fa-temperature-high`, `fas fa-wind`
-- Emoji: ☀️ 🌧️ ⛈️
-
-### Finance & Stocks
-- `fas fa-chart-line`, `fas fa-dollar-sign`, `fas fa-coins`
-- Emoji: 💰 📈 💵
-
-### Sports & Games
-- `fas fa-football-ball`, `fas fa-trophy`, `fas fa-gamepad`
-- Emoji: ⚽ 🏀 🎮
-
-### Entertainment
-- `fas fa-music`, `fas fa-film`, `fas fa-tv`
-- Emoji: 🎵 🎬 📺
-
-### News & Information
-- `fas fa-newspaper`, `fas fa-rss`, `fas fa-info-circle`
-- Emoji: 📰 📡 ℹ️
-
-### Utilities
-- `fas fa-tools`, `fas fa-cog`, `fas fa-wrench`
-- Emoji: 🔧 ⚙️ 🛠️
-
-### Social Media
-- `fab fa-twitter`, `fab fa-facebook`, `fab fa-instagram`
-- Emoji: 📱 💬 📧
+With no `icon` (or an empty one) the tab shows `fas fa-puzzle-piece`.
 
 ## Troubleshooting
 
-### Icon Not Showing
-1. Check that the `icon` field is correctly spelled in `manifest.json`
-2. For Font Awesome icons, verify the class name is correct
-3. For custom images, check that the file path is accessible
-4. Refresh the plugins in the web interface
-5. Check browser console for errors
-
-### Emoji Looks Wrong
-- Some emojis render differently on different platforms
-- Try a different emoji if one doesn't work well
-- Consider using Font Awesome instead for consistency
-
-### Custom Image Not Loading
-- Verify the image file exists in the specified path
-- Check file permissions (should be readable)
-- Try using an absolute path or URL
-- Ensure image format is supported (PNG, SVG, JPG, GIF)
-- Check image dimensions (16x16 to 32x32 recommended)
-
-### Icon Too Large/Small
-- Font Awesome and emoji icons automatically size correctly
-- For custom images, adjust the image file dimensions
-- SVG images scale best
-
-## Default Behavior
-
-If you don't specify an `icon` field in your manifest:
-- The plugin tab will show a default puzzle piece icon: 🧩
-- This is the fallback for all plugins without custom icons
-
-## Technical Details
-
-The icon system works as follows:
-
-1. **Frontend reads manifest**: When plugins load, the web interface reads each plugin's `manifest.json`
-2. **Icon detection**: The `getPluginIcon()` function determines icon type:
-   - Contains `fa-` → Font Awesome icon
-   - 1-4 characters → Emoji
-   - Starts with `http://`, `https://`, or `/` → Custom image
-   - Otherwise → Default puzzle piece
-3. **Rendering**: Icon HTML is generated and inserted into:
-   - Tab button in navigation bar
-   - Configuration page header
-
-## Advanced: Dynamic Icons
-
-Want to change icons programmatically? While not officially supported, you could:
-
-1. Store multiple icon options in your manifest
-2. Use JavaScript to swap icons based on plugin state
-3. Update the manifest dynamically and refresh plugins
-
-**Example (advanced):**
-```json
-{
-  "id": "status-display",
-  "icon": "fas fa-circle",
-  "icon_states": {
-    "active": "fas fa-check-circle",
-    "error": "fas fa-exclamation-circle",
-    "warning": "fas fa-exclamation-triangle"
-  }
-}
-```
+1. Check the class name against the Font Awesome 6 Free gallery; a Pro-only
+   or misspelled class renders as a blank space.
+2. Include the style prefix (`fas`, `far` or `fab`) as well as the icon
+   class.
+3. See the status note above: the icon is currently not passed through by
+   the API.
 
 ## Related Documentation
 
-- [Plugin Configuration Tabs](PLUGIN_CONFIGURATION_TABS.md) - Main plugin tabs documentation
-- [Plugin Development Guide](PLUGIN_DEVELOPMENT_GUIDE.md) - 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
-
-## Summary
-
-Adding a custom icon to your plugin:
-
-1. **Choose** your icon (Font Awesome, emoji, or custom image)
-2. **Add** the `icon` field to `manifest.json`
-3. **Test** in the web interface
-
-That's it! Your plugin now has a professional, recognizable icon in the UI. 🎨
-
+- [Plugin Configuration Tabs](PLUGIN_CONFIGURATION_TABS.md)
+- [Plugin Development Guide](PLUGIN_DEVELOPMENT_GUIDE.md)

docs/PLUGIN_DEPENDENCY_GUIDE.md

@@ -2,234 +2,161 @@
 
 ## Overview
 
-The LEDMatrix system has smart dependency installation that adapts based on who is running it. This guide explains how it works and potential pitfalls.
+A plugin lists its Python packages in its `requirements.txt`. LEDMatrix
+installs them for you when a plugin is installed, updated or loaded. This
+guide explains where they end up and what to do when a plugin can't import a
+package.
 
-## How It Works
+The rule to remember: **packages must be importable by `ledmatrix.service`,
+which runs as root.** Anything installed only into another user's
+`~/.local/` is invisible to it.
 
-### Execution Context Detection
+## Who Runs What
 
-The plugin manager checks if it's running as root:
-```python
-running_as_root = os.geteuid() == 0
+| Service | Runs as | Set by |
+|---------|---------|--------|
+| `ledmatrix.service` (display) | `root` | `systemd/ledmatrix.service` |
+| `ledmatrix-web.service` (web UI) | the user who ran the installer (e.g. `ledpi`) | `User=__USER__` in `systemd/ledmatrix-web.service`, filled in by `scripts/install/install_service.sh` |
+
+## How Dependencies Get Installed
+
+### 1. Installing or updating a plugin from the web UI
+
+The web interface is not root, so it installs through a narrow sudo helper:
+
+1. `PluginStoreManager._install_dependencies()`
+   (`src/plugin_system/store_manager.py`) calls
+   `install_requirements_file()` (`src/common/permission_utils.py`).
+2. That runs `sudo -n bash scripts/fix_perms/safe_pip_install.sh <plugin>/requirements.txt`.
+   The helper checks the path is the project's own `requirements.txt` or a
+   `requirements.txt` under `plugin-repos/` or `plugins/`, then runs
+   `python3 -m pip install --break-system-packages --ignore-installed -r ...`
+   **as root**, so the display service can import the packages.
+3. The sudoers rule that allows this is written by the installer
+   (`first_time_install.sh`) or by `scripts/install/configure_web_sudo.sh`.
+
+If sudo refuses (the rule isn't installed), `install_requirements_file()`
+falls back to installing with the web process's own interpreter, as the web
+user, and prefixes the pip output with a note like:
+
+```
+[Root install unavailable (...); installed for the current process's user only.
+Packages may not be visible to ledmatrix.service if it runs as a different
+user — run scripts/install/configure_web_sudo.sh to fix this.]
 ```
 
-Based on this, it chooses the appropriate installation method:
+Fix it by running `./scripts/install/configure_web_sudo.sh` as the web
+user (not with `sudo`; it asks for your password itself), then
+reinstall the plugin (or use the manual install below).
 
-| Running As | Installation Method | Location | Accessible To |
-|------------|-------------------|----------|---------------|
-| **root** (systemd service) | System-wide (`--break-system-packages`) | `/usr/local/lib/python3.X/dist-packages/` | All users |
-| **ledpi** or other user | User-specific (`--user`) | `~/.local/lib/python3.X/site-packages/` | Only that user |
+The **Reinstall Plugin Deps** button on the web UI's Tools tab goes
+through the same helper for every installed plugin.
+
+### 2. Loading a plugin
+
+When a plugin loads, `PluginLoader.install_dependencies()`
+(`src/plugin_system/plugin_loader.py`) checks its `requirements.txt`. If the
+requirements are already satisfied it does nothing; otherwise it runs
+`python3 -m pip install --break-system-packages -r requirements.txt` with the
+interpreter of the process doing the loading (retrying with
+`--ignore-installed` when a system package without a pip RECORD file is in
+the way).
+
+In `ledmatrix.service` that process is root, so restarting the display
+service installs anything missing system-wide:
+
+```bash
+sudo systemctl restart ledmatrix
+```
+
+If you run `python3 run.py` by hand as a normal user instead, pip cannot
+write to the system site-packages and installs into your `~/.local/`. That
+works for your manual run but not for the service.
 
 ## Common Scenarios
 
-### ✅ Scenario 1: Normal Production Use (Recommended)
+### Installing plugins from the web UI (recommended)
 
-**What:** Services running via systemd
+Use the **Plugin Manager** tab. Dependencies are installed as root through
+the sudo helper and the display service can use them.
+
+### Running the display manually for debugging
 
 ```bash
-sudo systemctl start ledmatrix
-sudo systemctl start ledmatrix-web
+cd ~/LEDMatrix
+sudo python3 run.py        # same user as the service
 ```
 
-- **Runs as:** root (configured in .service files)
-- **Installs to:** System-wide
-- **Result:** ✅ Works perfectly, all dependencies accessible
+Running as your own user works for plugins whose packages are already
+installed system-wide, but any *missing* package lands in `~/.local/`.
 
-### ✅ Scenario 2: Web Interface Plugin Installation
+### A plugin works when run manually but fails in the service
 
-**What:** Installing/enabling plugins via web interface at `http://pi-ip:5000`
+Its packages were installed for your user only. Install them as root (see
+below) and restart the service.
 
-- **Web service runs as:** root (ledmatrix-web.service)
-- **Installs to:** System-wide
-- **Result:** ✅ Works perfectly, systemd service can access them
+## Manual Installation
 
-### ✅ Scenario 3: Manual Testing as ledpi (Read-only)
-
-**What:** Running display manually as ledpi to test/debug
+### All plugins
 
 ```bash
-# As ledpi user
-cd /home/ledpi/LEDMatrix
-python3 run.py
-```
-
-- **Runs as:** ledpi
-- **Can import:** ✅ System-wide packages (installed by root)
-- **Result:** ✅ Works! Can use existing plugins with root-installed dependencies
-
-### ⚠️ Scenario 4: Manual Plugin Installation as ledpi (Problematic)
-
-**What:** Enabling a NEW plugin and running manually as ledpi
-
-```bash
-# As ledpi user
-cd /home/ledpi/LEDMatrix
-# Edit config to enable new plugin
-nano config/config.json
-# Run display - will try to install new plugin dependencies
-python3 run.py
-```
-
-**What Happens:**
-1. Plugin manager runs as `ledpi`
-2. Installs dependencies with `--user` flag
-3. Dependencies go to `~/.local/lib/python3.X/site-packages/`
-4. ⚠️ **Warning logged:** "Installing plugin dependencies for current user (not root)"
-
-**Problem:**
-- When systemd service restarts (as root), it **can't see** `~/.local/` packages
-- Plugin will fail to load for the systemd service
-
-**Solution:**
-After testing, restart the service to install dependencies system-wide:
-```bash
+sudo ~/LEDMatrix/scripts/install_plugin_dependencies.sh
 sudo systemctl restart ledmatrix
 ```
 
-## Best Practices
+The script installs every `requirements.txt` found in the plugins directory
+configured by `plugin_system.plugins_directory` in `config/config.json`
+(default `plugin-repos/`). Run it with `sudo` so the packages are installed
+system-wide.
 
-### For Production/Normal Use
+### One plugin
 
-1. **Always use the web interface** to install/enable plugins
-2. **Or restart the systemd service** after config changes:
-   ```bash
-   sudo systemctl restart ledmatrix
-   ```
-
-### For Development/Testing
-
-1. **Read existing plugins:** Safe to run as `ledpi` - can import system packages
-2. **Test new plugins:** Use sudo or restart service to install dependencies:
-   ```bash
-   # Option 1: Run as root
-   sudo python3 run.py
-   
-   # Option 2: Install deps manually
-   sudo pip3 install --break-system-packages -r plugins/my-plugin/requirements.txt
-   python3 run.py
-   
-   # Option 3: Let service install them
-   sudo systemctl restart ledmatrix
-   ```
-
-## Warning Messages
-
-### If you see this warning:
-```
-Installing plugin dependencies for current user (not root).
-These will NOT be accessible to the systemd service.
-For production use, install plugins via the web interface or restart the ledmatrix service.
-```
-
-**What it means:**
-- You're running as a non-root user
-- Dependencies were installed to your user directory only
-- The systemd service won't be able to use this plugin
-
-**What to do:**
 ```bash
-# Restart the service to install dependencies system-wide
+cd ~/LEDMatrix/plugin-repos/PLUGIN-NAME     # or your configured plugins directory
+sudo python3 -m pip install --break-system-packages --no-cache-dir -r requirements.txt
 sudo systemctl restart ledmatrix
 ```
 
+`--no-cache-dir` avoids errors about `/root/.cache/pip` not being writable.
+
 ## Troubleshooting
 
-### Plugin works when I run manually but fails in systemd service
-
-**Cause:** Dependencies installed to user directory (`~/.local/`) instead of system-wide
-
-**Fix:**
-```bash
-# Check where package is installed
-pip3 list -v | grep <package-name>
-
-# If it shows ~/.local/, reinstall system-wide:
-sudo pip3 install --break-system-packages <package-name>
-
-# Or just restart the service:
-sudo systemctl restart ledmatrix
-```
-
 ### Permission denied when installing dependencies
 
-**If you see errors like:**
 ```
 ERROR: Could not install packages due to an OSError: [Errno 13] Permission denied: '/root/.local'
 WARNING: The directory '/root/.cache/pip' or its parent directory is not owned or is not writable
 ```
 
-**Quick Fix - Use the Helper Script:**
-```bash
-sudo /home/ledpi/LEDMatrix/scripts/install_plugin_dependencies.sh
-sudo systemctl restart ledmatrix
-```
+Use one of the manual installs above (they pass `--no-cache-dir`).
 
-**Manual Fix:**
-```bash
-# Install dependencies with --no-cache-dir to avoid cache permission issues
-cd /home/ledpi/LEDMatrix/plugins/PLUGIN-NAME
-sudo pip3 install --break-system-packages --no-cache-dir -r requirements.txt
-sudo systemctl restart ledmatrix
-```
-
-**For more detailed troubleshooting, see:** [Plugin Dependency Troubleshooting Guide](PLUGIN_DEPENDENCY_TROUBLESHOOTING.md)
-
-## Architecture Summary
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                    LEDMatrix Services                        │
-├─────────────────────────────────────────────────────────────┤
-│                                                              │
-│  ledmatrix.service (User=root)                              │
-│  ledmatrix-web.service (User=root)                          │
-│  ├── Install dependencies system-wide                        │
-│  └── Accessible to all users                                 │
-│                                                              │
-├─────────────────────────────────────────────────────────────┤
-│                                                              │
-│  Manual execution as ledpi                                   │
-│  ├── Can READ system-wide packages ✅                        │
-│  ├── WRITES go to ~/.local/ ⚠️                               │
-│  └── Not accessible to root service                          │
-│                                                              │
-└─────────────────────────────────────────────────────────────┘
-```
-
-## Recommendations
-
-1. **For end users:** Always use the web interface for plugin management
-2. **For developers:** Be aware of the user context when testing
-3. **For plugin authors:** Test with `sudo systemctl restart ledmatrix` to ensure dependencies install correctly
-4. **For CI/CD:** Always run installation as root or use the service
-
-## Helper Scripts
-
-### Install Plugin Dependencies Script
-
-Located at: `scripts/install_plugin_dependencies.sh`
-
-This script automatically finds and installs dependencies for all plugins:
+### Checking where a package is installed
 
 ```bash
-# Run as root (recommended for production)
-sudo /home/ledpi/LEDMatrix/scripts/install_plugin_dependencies.sh
+# How the service sees it
+sudo python3 -c "import package_name; print(package_name.__file__)"
 
-# Make executable if needed
-chmod +x /home/ledpi/LEDMatrix/scripts/install_plugin_dependencies.sh
+# A path under /home/<user>/.local/ means it was installed for that user only
+python3 -m pip show -f package_name
 ```
 
-Features:
-- Auto-detects all plugins with requirements.txt
-- Uses correct installation method (system-wide vs user)
-- Bypasses pip cache to avoid permission issues
-- Provides detailed logging and error messages
+For more, see the [Plugin Dependency Troubleshooting Guide](PLUGIN_DEPENDENCY_TROUBLESHOOTING.md).
+
+## For Plugin Authors
+
+1. Keep `requirements.txt` minimal and pin only what you need.
+2. Test that it installs the way the Pi will install it:
+   ```bash
+   sudo python3 -m pip install --break-system-packages --no-cache-dir -r requirements.txt
+   ```
+3. Note any `apt` packages your plugin needs in its README.
 
 ## Files to Reference
 
-- Service configs: `ledmatrix.service`, `ledmatrix-web.service`
-- Plugin manager: `src/plugin_system/plugin_manager.py`
-- Installation script: `first_time_install.sh`
-- Dependency installer: `scripts/install_plugin_dependencies.sh`
-- Troubleshooting guide: `PLUGIN_DEPENDENCY_TROUBLESHOOTING.md`
-
+- Service units: `systemd/ledmatrix.service`, `systemd/ledmatrix-web.service`
+- Store installs: `src/plugin_system/store_manager.py` (`_install_dependencies`)
+- Root install helper: `src/common/permission_utils.py` (`install_requirements_file`), `scripts/fix_perms/safe_pip_install.sh`
+- Load-time installs: `src/plugin_system/plugin_loader.py` (`install_dependencies`)
+- Sudo rules: `scripts/install/lib_sudoers.sh` (written by `first_time_install.sh`
+  and `scripts/install/configure_web_sudo.sh`)
+- Manual installer: `scripts/install_plugin_dependencies.sh`

docs/PLUGIN_DEPENDENCY_TROUBLESHOOTING.md

@@ -1,6 +1,7 @@
 # Plugin Dependency Installation Troubleshooting
 
-This guide helps resolve issues with automatic plugin dependency installation in the LEDMatrix system.
+This guide helps resolve problems installing a plugin's Python packages. For
+how installation works, see the [Plugin Dependency Guide](PLUGIN_DEPENDENCY_GUIDE.md).
 
 ## Common Error Symptoms
 
@@ -10,109 +11,118 @@ ERROR: Could not install packages due to an OSError: [Errno 13] Permission denie
 WARNING: The directory '/root/.cache/pip' or its parent directory is not owned or is not writable
 ```
 
-### Context Mismatch
+### Installed for the wrong user
+The pip output shown after a web-UI install starts with:
 ```
-WARNING: Installing plugin dependencies for current user (not root). 
-These will NOT be accessible to the systemd service.
+[Root install unavailable (...); installed for the current process's user only.
+Packages may not be visible to ledmatrix.service if it runs as a different
+user — run scripts/install/configure_web_sudo.sh to fix this.]
 ```
 
+### Plugin fails to load with `ModuleNotFoundError`
+The display service can't see a package the plugin needs.
+
 ## Root Cause
 
-Plugin dependencies must be installed in a context accessible to the LEDMatrix systemd service, which runs as root. Permission errors typically occur when:
+Plugin packages must be importable by `ledmatrix.service`, which runs as
+root. The web interface (`ledmatrix-web.service`) runs as the user who
+installed LEDMatrix, so it installs through a sudo helper
+(`scripts/fix_perms/safe_pip_install.sh`). Problems usually come from:
 
-1. The pip cache directory has incorrect permissions
-2. The process tries to install to user directories without proper permissions
-3. Environment variables (like HOME) are not set correctly for the service context
+1. The sudoers rule for that helper missing, so the web UI installed the
+   packages for its own user only
+2. Running `python3 run.py` by hand as a normal user, which installs missing
+   packages into `~/.local/`
+3. pip's cache directory not being writable for root
 
 ## Solutions
 
-### Solution 1: Use the Manual Installation Script (Recommended)
-
-We provide a helper script that handles dependency installation correctly:
+### Solution 1: Restore the sudo rule, then reinstall
 
 ```bash
-# Run as root to install system-wide (for production)
-sudo /home/ledpi/LEDMatrix/scripts/install_plugin_dependencies.sh
+cd ~/LEDMatrix
+./scripts/install/configure_web_sudo.sh   # as the web user, not with sudo
+```
 
-# After installation, restart the service
+Then reinstall the plugin from the **Plugin Manager** tab, or click
+**Reinstall Plugin Deps** on the **Tools** tab.
+
+### Solution 2: Install every plugin's dependencies from the terminal
+
+```bash
+sudo ~/LEDMatrix/scripts/install_plugin_dependencies.sh
 sudo systemctl restart ledmatrix
 ```
 
-This script:
-- Detects all plugins with requirements.txt files
-- Installs dependencies with correct permissions
-- Uses `--no-cache-dir` to avoid cache permission issues
-- Provides detailed logging for troubleshooting
+The script finds each `requirements.txt` in the plugins directory set by
+`plugin_system.plugins_directory` in `config/config.json` (default
+`plugin-repos/`), installs with `--no-cache-dir`, and reports what it found.
 
-### Solution 2: Manual Installation per Plugin
-
-If you need to install dependencies for a specific plugin:
+### Solution 3: Install one plugin's dependencies
 
 ```bash
-# Navigate to the plugin directory
-cd /home/ledpi/LEDMatrix/plugins/PLUGIN-NAME
+# Your configured plugins directory; plugin-repos/ by default
+cd ~/LEDMatrix/plugin-repos/PLUGIN-NAME
 
-# Install as root (system-wide)
-sudo pip3 install --break-system-packages --no-cache-dir -r requirements.txt
+sudo python3 -m pip install --break-system-packages --no-cache-dir -r requirements.txt
 
-# Restart the service
 sudo systemctl restart ledmatrix
 ```
 
-### Solution 3: Fix Cache Directory Permissions
+### Solution 4: Let the display service install them
 
-If you specifically have cache permission issues:
+When a plugin loads, the display service installs any missing requirements
+itself, as root:
+
+```bash
+sudo systemctl restart ledmatrix
+sudo journalctl -u ledmatrix -f     # watch for "Installing dependencies for plugin ..."
+```
+
+### Solution 5: Fix pip cache permissions
 
 ```bash
 # Option A: Skip the cache (recommended)
-sudo pip3 install --no-cache-dir --break-system-packages -r requirements.txt
+sudo python3 -m pip install --no-cache-dir --break-system-packages -r requirements.txt
 
-# Option B: Fix cache permissions (if needed)
+# Option B: Fix cache permissions
 sudo mkdir -p /root/.cache/pip
 sudo chown -R root:root /root/.cache
 sudo chmod -R 755 /root/.cache
 ```
 
-### Solution 4: Install via Web Interface
-
-The web interface handles dependency installation correctly in the service context:
-
-1. Access the web interface (`http://ledpi:5000` or `http://your-pi-ip:5000`)
-2. Open the **Plugin Manager** tab (use the **Plugin Store** section to
-   find the plugin, or **Install from GitHub**)
-3. Install the plugin through the web UI
-4. The system automatically handles dependency installation in the
-   service context (which has the right permissions)
-
 ## Prevention
 
 ### For Plugin Developers
 
-When creating plugins with dependencies:
-
 1. **Keep requirements minimal**: Only include essential packages
-2. **Test installation**: Verify your requirements.txt works with:
+2. **Test installation** the way the Pi does it:
    ```bash
-   sudo pip3 install --break-system-packages --no-cache-dir -r requirements.txt
+   sudo python3 -m pip install --break-system-packages --no-cache-dir -r requirements.txt
    ```
 3. **Document dependencies**: Note any system packages needed (via apt)
 
 ### For Users
 
-1. **Use web interface**: Install plugins via the web UI when possible
-2. **Install as root**: When using SSH/terminal, use sudo for plugin installations
-3. **Restart service**: After manual installations, restart the ledmatrix service
+1. **Use the web interface** to install plugins
+2. **Use sudo** for installs from SSH/terminal
+3. **Restart the service** after manual installations
 
 ## Technical Details
 
-### How Dependency Installation Works
+### Where installs happen
 
-The `PluginManager._install_plugin_dependencies()` method:
-
-1. Detects if running as root using `os.geteuid() == 0`
-2. If root: Uses system-wide installation with `--break-system-packages --no-cache-dir`
-3. If not root: Uses user installation with `--user --break-system-packages --no-cache-dir`
-4. The `--no-cache-dir` flag prevents cache-related permission issues
+- **Web UI install/update:** `PluginStoreManager._install_dependencies()`
+  → `install_requirements_file()` in `src/common/permission_utils.py`, which
+  runs `sudo -n bash scripts/fix_perms/safe_pip_install.sh <requirements.txt>`.
+  The helper only accepts the project's `requirements.txt` or one under
+  `plugin-repos/` or `plugins/`, and runs
+  `pip install --break-system-packages --ignore-installed` as root. If sudo
+  refuses, it falls back to a pip install as the web user and says so.
+- **Plugin load:** `PluginLoader.install_dependencies()` in
+  `src/plugin_system/plugin_loader.py` skips satisfied requirements and
+  otherwise runs `pip install --break-system-packages` with the loading
+  process's interpreter — root in `ledmatrix.service`.
 
 ### Why `--break-system-packages`?
 
@@ -120,26 +130,20 @@ Debian 12+ (Bookworm) and Raspberry Pi OS based on it implement PEP 668, which p
 
 ### Service Context
 
-The ledmatrix.service runs as:
-- **User**: root
-- **WorkingDirectory**: /home/ledpi/LEDMatrix
-- **Python**: /usr/bin/python3
+- `ledmatrix.service` runs as **root** with `/usr/bin/python3`
+- `ledmatrix-web.service` runs as **the installing user**
 
-Dependencies must be installed in root's Python environment or system-wide to be accessible.
+Dependencies must be installed system-wide (as root) to be visible to the
+display service.
 
 ## Checking Installation
 
-Verify dependencies are installed correctly:
-
 ```bash
 # Check as root (how the service sees it)
-sudo python3 -c "import package_name"
+sudo python3 -c "import package_name; print(package_name.__file__)"
 
-# List installed packages
-pip3 list
-
-# Check specific package
-pip3 show package_name
+# A path under /home/<user>/.local/ means a user-only install
+python3 -m pip show -f package_name
 ```
 
 ## Getting Help
@@ -151,19 +155,11 @@ If you continue to experience issues:
    sudo journalctl -u ledmatrix -f
    ```
 
-2. Check pip logs (created by manual script):
+2. Verify the plugin manifest and requirements (default plugins directory
+   shown):
    ```bash
-   cat /tmp/pip_install_*.log
-   ```
-
-3. Verify plugin manifest is correct:
-   ```bash
-   cat /home/ledpi/LEDMatrix/plugins/PLUGIN-NAME/manifest.json
-   ```
-
-4. Check plugin requirements:
-   ```bash
-   cat /home/ledpi/LEDMatrix/plugins/PLUGIN-NAME/requirements.txt
+   cat ~/LEDMatrix/plugin-repos/PLUGIN-NAME/manifest.json
+   cat ~/LEDMatrix/plugin-repos/PLUGIN-NAME/requirements.txt
    ```
 
 ## Related Documentation
@@ -171,4 +167,3 @@ If you continue to experience issues:
 - [Plugin Dependency Guide](PLUGIN_DEPENDENCY_GUIDE.md)
 - [Plugin Development Guide](PLUGIN_DEVELOPMENT_GUIDE.md)
 - [Troubleshooting](TROUBLESHOOTING.md)
-

docs/PLUGIN_DEVELOPMENT_GUIDE.md

@@ -3,19 +3,15 @@
 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
+> (`self.display_manager.width/height`) rather than hardcoding one
+> panel. Don't read `display_manager.matrix.width/height`: `matrix` is
+> `None` when hardware init fails, while the `width`/`height` properties
+> fall back to the canvas size. 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:
@@ -43,28 +39,45 @@ The solution uses **symbolic links** to connect plugin repositories to the `plug
 
 ## Quick Start
 
-### 1. Link a Plugin from GitHub
+Official plugins all live in one repository,
+[ledmatrix-plugins](https://github.com/ChuckBuilds/ledmatrix-plugins), with
+one directory per plugin under `plugins/` (there are no per-plugin
+`ledmatrix-<name>` repositories). The helper script links a plugin directory
+from a checkout of that monorepo into LEDMatrix's `plugins/` directory.
 
-The easiest way to link a plugin that's already on GitHub:
+### 1. Link an Official Plugin
 
 ```bash
-./scripts/dev/dev_plugin_setup.sh link-github music
+./scripts/dev/dev_plugin_setup.sh link-github football-scoreboard
 ```
 
 This will:
-- Clone `https://github.com/ChuckBuilds/ledmatrix-music.git` to `~/.ledmatrix-dev-plugins/ledmatrix-music`
-- Create a symbolic link from `plugins/music` to the cloned repository
-- Validate that the plugin has a proper `manifest.json`
+- Clone `https://github.com/ChuckBuilds/ledmatrix-plugins.git` to
+  `~/.ledmatrix-dev-plugins/ledmatrix-plugins` (or `git pull` it if it is
+  already there)
+- Find `plugins/football-scoreboard` in it (also accepted:
+  `plugins/ledmatrix-<name>`, or a plugin whose manifest `id` is the name)
+- Validate that it has a `manifest.json`
+- Create a symbolic link named after the plugin's manifest id, e.g.
+  `plugins/football-scoreboard` → `~/.ledmatrix-dev-plugins/ledmatrix-plugins/plugins/football-scoreboard`
 
-### 2. Link a Local Plugin Repository
+`link-github music` finds the monorepo's `plugins/ledmatrix-music` directory
+and links it into LEDMatrix as `plugins/ledmatrix-music`, because
+`ledmatrix-music` is that plugin's manifest id.
 
-If you already have a plugin repository cloned locally:
+To work from your fork of the monorepo, set `github_user` in
+`dev_plugins.json` (see [Configuration](#configuration)).
+
+### 2. Link a Local Plugin Directory
+
+If you already have the monorepo (or a third-party plugin repository) cloned
+locally:
 
 ```bash
-./scripts/dev/dev_plugin_setup.sh link music ../ledmatrix-music
+./scripts/dev/dev_plugin_setup.sh link hello-world ../ledmatrix-plugins/plugins/hello-world
 ```
 
-This creates a symlink from `plugins/music` to your local repository path.
+This creates a symlink from `plugins/hello-world` to that directory.
 
 ### 3. Check Status
 
@@ -77,13 +90,17 @@ See which plugins are linked and their git status:
 ### 4. Work on Your Plugin
 
 ```bash
-cd plugins/music  # Actually editing the linked repository
-# Make your changes
+cd plugins/football-scoreboard  # Actually editing the monorepo checkout
+# Make your changes, then bump "version" in manifest.json
 git add .
-git commit -m "feat: add new feature"
-git push origin main
+git commit -m "feat(football-scoreboard): add new feature"
+git push   # to your fork, then open a PR against ledmatrix-plugins
 ```
 
+In the monorepo, every plugin change must bump `version` in the plugin's
+`manifest.json` and run `python update_registry.py`, or users won't receive
+the update.
+
 ### 5. Update Plugins
 
 Pull latest changes from remote:
@@ -116,7 +133,7 @@ Links a local plugin repository to the plugins directory.
 
 **Example:**
 ```bash
-./scripts/dev/dev_plugin_setup.sh link football-scoreboard ../ledmatrix-football-scoreboard
+./scripts/dev/dev_plugin_setup.sh link football-scoreboard ../ledmatrix-plugins/plugins/football-scoreboard
 ```
 
 **Notes:**
@@ -129,23 +146,25 @@ Links a local plugin repository to the plugins directory.
 Clones a plugin from GitHub and links it.
 
 **Arguments:**
-- `plugin-name`: The name of the plugin (will be the directory name in `plugins/`)
-- `repo-url`: (Optional) Full GitHub repository URL. If omitted, constructs from pattern: `https://github.com/ChuckBuilds/ledmatrix-<plugin-name>.git`
+- `plugin-name`: Without `repo-url`, the plugin to link from the monorepo: a
+  directory under `plugins/` (`<name>` or `ledmatrix-<name>`) or a manifest
+  id. The link is named after the plugin's manifest id. With `repo-url`, the
+  name of the link in `plugins/`.
+- `repo-url`: (Optional) A plugin that has its own repository (e.g. a
+  third-party plugin). The repository root is linked.
 
 **Examples:**
 ```bash
-# Auto-construct URL from plugin name
-./scripts/dev/dev_plugin_setup.sh link-github music
+# Official plugin, from the ledmatrix-plugins monorepo
+./scripts/dev/dev_plugin_setup.sh link-github stocks
 
-# Use explicit URL
-./scripts/dev/dev_plugin_setup.sh link-github stocks https://github.com/ChuckBuilds/ledmatrix-stocks.git
-
-# Link from a different GitHub user
+# Third-party plugin with its own repository
 ./scripts/dev/dev_plugin_setup.sh link-github custom-plugin https://github.com/OtherUser/custom-plugin.git
 ```
 
 **Notes:**
 - Repositories are cloned to `~/.ledmatrix-dev-plugins/` by default (configurable)
+- The monorepo is cloned once and shared by every plugin you link from it
 - If the repository already exists, it will be updated with `git pull` instead of re-cloning
 - The cloned repository is preserved when you unlink the plugin
 
@@ -217,30 +236,28 @@ Updates plugin(s) by running `git pull` in their repositories.
 
 ### Custom Development Directory
 
-By default, GitHub repositories are cloned to `~/.ledmatrix-dev-plugins/`. You can customize this by creating a `dev_plugins.json` file:
+By default, GitHub repositories are cloned to `~/.ledmatrix-dev-plugins/`
+and official plugins come from `ChuckBuilds/ledmatrix-plugins`. To change
+either, copy `dev_plugins.json.example` (in the LEDMatrix root) to
+`dev_plugins.json` and edit it. `dev_plugins.json` is git-ignored.
 
 ```json
 {
-  "dev_plugins_dir": "/path/to/your/dev/plugins",
-  "github_user": "ChuckBuilds",
-  "github_pattern": "ledmatrix-",
-  "plugins": {
-    "music": {
-      "source": "github",
-      "url": "https://github.com/ChuckBuilds/ledmatrix-music.git",
-      "branch": "main"
-    }
-  }
+  "dev_plugins_dir": "~/.ledmatrix-dev-plugins",
+  "github_user": "your-github-user",
+  "plugins_repo": "ledmatrix-plugins",
+  "plugins_branch": "main"
 }
 ```
 
-**Configuration options:**
+**Configuration options** (all optional):
 - `dev_plugins_dir`: Where to clone GitHub repositories (default: `~/.ledmatrix-dev-plugins`)
-- `github_user`: Default GitHub username for auto-constructing URLs
-- `github_pattern`: Pattern for repository names (default: `ledmatrix-`)
-- `plugins`: Plugin definitions (optional, for future auto-discovery features)
+- `github_user`: Owner of the plugin monorepo that `link-github <name>` clones — set it to use your fork (default: `ChuckBuilds`)
+- `plugins_repo`: Name of that monorepo (default: `ledmatrix-plugins`)
+- `plugins_branch`: Branch to clone it at (default: the repository's default branch). Only applies when the clone is first made.
 
-**Note:** Copy `dev_plugins.json.example` to `dev_plugins.json` and customize it. The `dev_plugins.json` file is git-ignored.
+`github_pattern` from older versions of this guide is no longer used (the
+script warns if it is set).
 
 ## Development Workflow
 
@@ -248,43 +265,46 @@ By default, GitHub repositories are cloned to `~/.ledmatrix-dev-plugins/`. You c
 
 1. **Link your plugin for development:**
    ```bash
-   ./scripts/dev/dev_plugin_setup.sh link-github music
+   ./scripts/dev/dev_plugin_setup.sh link-github clock-simple
    ```
 
 2. **Test in LEDMatrix:**
    ```bash
-   # Run LEDMatrix with your plugin
-   python run.py
+   # Run LEDMatrix with your plugin (emulator shown)
+   python3 run.py -e
    ```
 
 3. **Make changes:**
    ```bash
-   cd plugins/music
+   cd plugins/clock-simple
    # Edit files...
    # Test changes...
    ```
 
-4. **Commit to plugin repository:**
+4. **Commit to the plugin repository:**
    ```bash
-   cd plugins/music  # This is actually your repo
+   cd plugins/clock-simple  # This is inside your monorepo checkout
+   # bump "version" in manifest.json, then from the monorepo root:
+   # python update_registry.py
    git add .
-   git commit -m "feat: add new feature"
-   git push origin main
+   git commit -m "feat(clock-simple): add new feature"
+   git push
    ```
 
 5. **Update from remote (if needed):**
    ```bash
-   ./scripts/dev/dev_plugin_setup.sh update music
+   ./scripts/dev/dev_plugin_setup.sh update clock-simple
    ```
 
 6. **When done developing:**
    ```bash
-   ./scripts/dev/dev_plugin_setup.sh unlink music
+   ./scripts/dev/dev_plugin_setup.sh unlink clock-simple
    ```
 
 ### Working with Multiple Plugins
 
-You can have multiple plugins linked simultaneously:
+You can have multiple plugins linked simultaneously. Plugins linked from the
+monorepo share one checkout:
 
 ```bash
 ./scripts/dev/dev_plugin_setup.sh link-github music
@@ -294,7 +314,7 @@ You can have multiple plugins linked simultaneously:
 # Check status of all
 ./scripts/dev/dev_plugin_setup.sh status
 
-# Update all at once
+# Update all at once (the shared monorepo checkout is pulled once)
 ./scripts/dev/dev_plugin_setup.sh update
 ```
 
@@ -409,7 +429,7 @@ If you have conflicts when updating:
 
 1. **Manually resolve in the plugin repository:**
    ```bash
-   cd ~/.ledmatrix-dev-plugins/ledmatrix-music
+   cd ~/.ledmatrix-dev-plugins/ledmatrix-plugins
    git pull
    # Resolve conflicts...
    git add .
@@ -470,18 +490,19 @@ You can mix local and GitHub plugins:
 
 The development workflow is separate from the plugin store installation:
 
-- **Plugin Store:** Installs plugins to `plugins/` as regular directories
-- **Development Setup:** Links plugin repositories as symlinks
+- **Plugin Store:** Installs plugins as regular directories in the configured
+  plugins directory (`plugin-repos/` by default)
+- **Development Setup:** Links plugin directories as symlinks in `plugins/`
 
-If you install a plugin via the store, you can still link it for development:
+The plugin loader scans only one directory, so while developing set
+`plugin_system.plugins_directory` to `plugins` (see the note at the top of
+this guide). If `plugins/` already holds a regular directory of the same
+name, `link`/`link-github` offers to rename it to
+`<name>.backup.<timestamp>` before linking.
 
-```bash
-# Store installs to plugins/music (regular directory)
-# Link for development (will prompt to replace)
-./scripts/dev/dev_plugin_setup.sh link-github music
-```
-
-When you unlink, the directory is removed. If you want to switch back to the store version, re-install it via the plugin store.
+`unlink` removes only the symlink. To switch back to the store version, set
+`plugins_directory` back to `plugin-repos` (or reinstall the plugin from the
+store).
 
 ## API Reference
 
@@ -525,7 +546,7 @@ Want to create and share your own plugin? Here's everything you need to know.
    - [Advanced Plugin Development](ADVANCED_PLUGIN_DEVELOPMENT.md) - Patterns and examples
 
 2. **Start with a template**:
-   - Use the [Hello World plugin](https://github.com/ChuckBuilds/ledmatrix-hello-world) as a starting point
+   - Use the [Hello World plugin](https://github.com/ChuckBuilds/ledmatrix-plugins/tree/main/plugins/hello-world) as a starting point
    - Or fork an existing plugin and modify it
 
 3. **Follow the plugin structure**:
@@ -589,24 +610,16 @@ 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):
-
-  ```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).
+- **Bump `version` in `manifest.json` by hand** for every change you ship.
+  There is no automatic version-bump hook or bump script.
+- **Official (monorepo) plugins**: after bumping the manifest, run
+  `python update_registry.py` in the `ledmatrix-plugins` checkout. It copies
+  each manifest's version into `plugins.json` as `latest_version`, which is
+  what the store compares installed versions against. Without it, users
+  won't be offered the update.
+- **Plugins in their own repository**: still bump the manifest `version`,
+  so users can see which version they run; tagging releases (`v1.2.3`) to
+  match is a good habit.
 
 ### Submitting to Official Registry
 
@@ -618,12 +631,14 @@ To have your plugin added to the official plugin store:
    - Follows best practices
    - Tested on Raspberry Pi hardware
 
-2. **Create GitHub repository**:
-   - Repository name: `ledmatrix-<plugin-name>`
-   - Public repository
-   - Proper README.md with installation instructions
+2. **Choose where it lives** (see `SUBMISSION.md` in
+   [ledmatrix-plugins](https://github.com/ChuckBuilds/ledmatrix-plugins)):
+   - **In the monorepo (preferred):** fork ledmatrix-plugins, add
+     `plugins/<your-plugin-id>/`, and open a pull request
+   - **In your own public repository** (conventionally
+     `ledmatrix-<plugin-name>`), with a README that covers installation
 
-3. **Contact maintainers**:
+3. **Contact maintainers** (own-repository plugins):
    - Open a GitHub issue in the [ledmatrix-plugins](https://github.com/ChuckBuilds/ledmatrix-plugins) repository
    - Or reach out on Discord: https://discord.gg/uW36dVAtcT
    - Include: Repository URL, plugin description, why it's useful
@@ -639,7 +654,8 @@ To have your plugin added to the official plugin store:
 For your plugin to work well in the plugin store:
 
 - **GitHub repository**: Must be publicly accessible on GitHub
-- **Releases or tags**: Recommended for version tracking
+- **`version` in manifest.json**: The store offers updates by comparing it
+  with the registry's `latest_version`; releases and tags are not read
 - **README.md**: Clear installation and configuration instructions
 - **config_schema.json**: Recommended for web UI configuration
 - **manifest.json**: Required with all required fields
@@ -649,7 +665,8 @@ For your plugin to work well in the plugin store:
 
 1. **Official Registry** (Recommended):
    - Listed in default plugin store
-   - Automatic updates
+   - Update offers in the Plugin Manager (and weekly automatic updates, if
+     the user turns them on)
    - Verified badge
    - Requires approval
 

docs/PLUGIN_ELEMENT_STYLING.md

@@ -0,0 +1,135 @@
+# Per-element styling for plugin authors
+
+Users want to change the font, size and colour of individual things on screen,
+nudge them a few pixels, hide the ones they do not care about, and scale a logo
+down. This is the one system that does that, and a plugin joins it by
+**declaring elements in its `config_schema.json`** — not by writing a style
+resolver, a font cache or a web form.
+
+The short version:
+
+```jsonc
+"customization": {
+  "type": "object",
+  "title": "Display Customization",
+  "x-style-elements": {
+    "score_text": {
+      "title": "Score",
+      "font":  { "default": "PressStart2P-Regular.ttf" },
+      "size":  { "default": 10, "min": 4, "max": 16 },
+      "color": { "default": [255, 255, 255] },
+      "offsets": true,
+      "visible": true,
+      "align": true
+    },
+    "home_logo": { "title": "Home logo", "offsets": true, "scale": true }
+  },
+  "x-style-modes": ["live", "upcoming", "recent"]
+}
+```
+
+That is the whole declaration. The core expands it into a full JSON Schema, the
+web UI renders a compact style editor with a row per element, and the values
+land in `config.json` under the keys you named.
+
+## What each key does
+
+| Key | Effect |
+|---|---|
+| `font` | Font picker listing every shipped **and user-uploaded** font. |
+| `size` | Number field. `min`/`max` also cap which fixed-size fonts are offered. |
+| `color` | Colour swatch; stored as `[r, g, b]`. |
+| `offsets` | X/Y nudge, stored under `customization.layout.<element>`. |
+| `visible` | Show/hide toggle. |
+| `align` | `left` / `center` / `right`. |
+| `scale` | Size multiplier, for logos and images. Also under `layout`. |
+
+`x-style-modes` is optional. Declare it and every element gains a per-mode
+override tab — a scoreboard can then style its live, upcoming and recent cards
+separately. **A mode field left blank means "inherit", not zero.**
+
+## Reading the values
+
+Every plugin inherits `BasePlugin.styles`, which finds your `config_schema.json`
+on its own:
+
+```python
+style = self.styles.style(
+    "score_text",
+    classic_font="PressStart2P-Regular.ttf",   # what you shipped
+    classic_size=10,
+    classic_color=(255, 255, 255),
+)
+if style.visible:
+    draw.text((x + style.offset[0], y + style.offset[1]),
+              text, font=style.font, fill=style.color)
+```
+
+For a specific mode, use `self.styles_for("recent")`, or set
+`STYLE_MODE = "recent"` on the class and keep calling `self.styles`.
+
+### The one rule that matters
+
+**Pass your shipped values as the `classic_*` arguments.** The resolver returns
+them verbatim unless the user actually changed something, which is what keeps an
+untouched install rendering byte-identically. It can tell the difference because
+a value only counts as user-forced when it *differs from the schema default* —
+the save path writes the full default object into `config.json` on every save,
+so "present in config" proves nothing.
+
+Never compare against the default yourself; that rule lives in exactly one place.
+
+### Stateless readers
+
+For helpers handed a config dict rather than a plugin instance:
+
+```python
+from src.element_style import (element_color, element_visible,
+                               element_align, element_scale, layout_offset)
+
+colour = element_color(config, "score_text", (255, 255, 255), mode)
+shown  = element_visible(config, "records", True, mode)
+dy     = layout_offset(config, "score", "y_offset", 0, mode)
+```
+
+## Sports scoreboards
+
+`SportsCoreSharedMixin` wires most of this up already. Two things to know:
+
+* **Name your draws.** `_draw_text_with_outline(..., element="score_text")`
+  resolves the colour by name *and* honours the visibility toggle. Without it
+  the colour has to be guessed from the identity of the font object, which
+  cannot tell two elements apart when they share a face — the case every
+  bitmap font is in.
+* **Modes are free.** Live/upcoming/recent are separate instances, so setting
+  `SKIN_MODE` on each is enough; no call site passes a mode.
+
+## Adopting an existing hand-written block
+
+If your schema already spells out `font` / `font_size` / `text_color` per
+element longhand, **you do not need to change anything**. The core recognises
+that shape and upgrades it in place: the style editor, the real font picker
+(including uploaded fonts) and per-mode overrides all appear on a core update.
+Add `x-style-modes` if you want the mode tabs.
+
+## Fonts, and why size is sometimes locked
+
+32 of the 35 shipped fonts are fixed-strike BDF bitmaps: they render at exactly
+one pixel size and ignore `font_size`. The picker knows which, and the editor
+locks the size field to the native size and labels it `fixed`. A font too tall
+for the `max` you declared is not offered at all.
+
+Uploaded fonts (Fonts tab) land in `assets/fonts/` and appear in the picker
+automatically.
+
+## Checklist
+
+1. Declare `x-style-elements` (and `x-style-modes` if you have modes).
+2. Read through `self.styles`, passing your shipped values as `classic_*`.
+3. Honour `style.visible`, `style.offset` and `style.scale` where they apply.
+4. Confirm an untouched config renders identically:
+   `python scripts/check_plugin.py --plugin <id>`.
+5. Monorepo plugins: bump `manifest.json` and run `python update_registry.py`.
+
+See also: [docs/PLUGIN_CONFIGURATION_GUIDE.md](PLUGIN_CONFIGURATION_GUIDE.md),
+[docs/FONT_MANAGER.md](FONT_MANAGER.md).

docs/PLUGIN_ERROR_HANDLING.md

@@ -146,7 +146,10 @@ def display(self, force_clear: bool = False) -> bool:
 
 ## Error Aggregation
 
-LEDMatrix automatically tracks plugin errors. Access error data via the API:
+LEDMatrix automatically tracks plugin errors: every exception or timeout from
+a plugin's `update()` or `display()` is recorded by the display service,
+which runs the plugins. See them in the web interface under **Logs → Plugin
+errors**, or through the API:
 
 ```bash
 # Get error summary
@@ -155,10 +158,21 @@ curl http://localhost:5000/api/v3/errors/summary
 # Get plugin-specific health
 curl http://localhost:5000/api/v3/errors/plugin/my-plugin
 
-# Clear old errors
+# Clear errors older than 24 hours (the default), or all of them
 curl -X POST http://localhost:5000/api/v3/errors/clear
+curl -X POST -H 'Content-Type: application/json' -d '{"all": true}' \
+  http://localhost:5000/api/v3/errors/clear
 ```
 
+The web interface is a separate process, so it reads a snapshot the display
+service writes to the shared cache directory (`plugin_error_snapshot`): at most
+every 10 seconds, and only when something changed. Expect the numbers to lag
+by up to about 15 seconds, and to start from zero when the display service
+restarts. `snapshot_available` is `false` until the display service has
+reported. A clear is a request the display service applies within about 5
+seconds; the API hides the cleared errors immediately. Details and response
+shapes: [REST API reference](REST_API_REFERENCE.md#error-tracking).
+
 ### Error Patterns
 
 When the same error occurs repeatedly (5+ times in 60 minutes), it's detected as a pattern and logged as a warning. This helps identify systemic issues.

docs/PLUGIN_IMPLEMENTATION_SUMMARY.md

@@ -1,358 +0,0 @@
-# LEDMatrix Plugin System - Implementation Summary
-
-> **Status note:** this is a high-level summary written during the
-> initial plugin system rollout. Most of it is accurate, but a few
-> sections describe features that are aspirational or only partially
-> implemented (per-plugin virtual envs, resource limits, registry
-> manager). Drift from current reality is called out inline.
-
-This document provides a comprehensive overview of the plugin architecture implementation, consolidating details from multiple plugin-related implementation summaries.
-
-## Executive Summary
-
-The LEDMatrix plugin system transforms the project into a modular, extensible platform where users can create, share, and install custom displays through a GitHub-based store (similar to Home Assistant Community Store).
-
-## Architecture Overview
-
-### Core Components
-
-```
-LEDMatrix/
-├── src/plugin_system/
-│   ├── base_plugin.py          # Plugin interface contract
-│   ├── plugin_loader.py        # Discovery + dynamic import
-│   ├── plugin_manager.py       # Lifecycle management
-│   ├── store_manager.py        # GitHub install / store integration
-│   ├── schema_manager.py       # Config schema validation
-│   ├── health_monitor.py       # Plugin health metrics
-│   ├── operation_queue.py      # Async install/update operations
-│   └── state_manager.py        # Persistent plugin state
-├── plugin-repos/               # Default plugin install location
-│   ├── football-scoreboard/
-│   ├── ledmatrix-music/
-│   └── ledmatrix-stocks/
-└── config/config.json          # Plugin configurations
-```
-
-> Earlier drafts of this doc referenced `registry_manager.py`. It was
-> never created — discovery happens in `plugin_loader.py`. The earlier
-> default plugin location of `plugins/` has been replaced with
-> `plugin-repos/` (see `config/config.template.json:130`).
-
-### Key Design Decisions
-
-✅ **Gradual Migration**: Plugin system added alongside existing managers
-✅ **GitHub-Based Store**: Simple discovery from GitHub repositories
-✅ **Plugin Isolation**: Each plugin in dedicated directory
-✅ **Configuration Integration**: Plugins use main config.json
-✅ **Backward Compatibility**: Existing functionality preserved
-
-## Implementation Phases
-
-### Phase 1: Core Infrastructure (Completed)
-
-#### Plugin Base Classes
-- **BasePlugin**: Abstract interface for all plugins
-- **Standard Methods**: `update()`, `display()`, `get_config()`
-- **Lifecycle Hooks**: `on_enable()`, `on_disable()`, `on_config_change()`
-
-#### Plugin Manager
-- **Discovery**: Automatic plugin detection in `./plugins/` directory
-- **Loading**: Dynamic import and instantiation
-- **Management**: Enable/disable, configuration updates
-- **Error Handling**: Graceful failure isolation
-
-#### Store Manager
-- **GitHub Integration**: Repository cloning and management
-- **Version Handling**: Tag-based version control
-- **Dependency Resolution**: Automatic dependency installation
-
-### Phase 2: Configuration System (Completed)
-
-#### Nested Schema Validation
-- **JSON Schema**: Comprehensive configuration validation
-- **Type Safety**: Ensures configuration integrity
-- **Dynamic UI**: Schema-driven configuration forms
-
-#### Tabbed Configuration Interface
-- **Organized UI**: Plugin settings in dedicated tabs
-- **Real-time Validation**: Instant feedback on configuration changes
-- **Backup System**: Automatic configuration versioning
-
-#### Live Priority Management
-- **Dynamic Switching**: Real-time display priority changes
-- **API Integration**: RESTful priority management
-- **Conflict Resolution**: Automatic priority conflict handling
-
-### Phase 3: Advanced Features (Completed)
-
-#### Custom Icons
-- **Plugin Branding**: Custom icons for plugin identification
-- **Format Support**: PNG, SVG, and font-based icons
-- **Fallback System**: Default icons when custom ones unavailable
-
-#### Dependency Management
-- **Requirements.txt**: Per-plugin dependencies, installed system-wide
-  via pip on first plugin load
-- **Version Pinning**: Standard pip version constraints in
-  `requirements.txt`
-
-> Earlier plans called for per-plugin virtual environments. That isn't
-> implemented — plugin Python deps install into the system Python
-> environment (or whatever environment the LEDMatrix service is using).
-> Conflicting versions across plugins are not auto-resolved.
-
-#### Health monitoring
-- **Resource Monitor** (`src/plugin_system/resource_monitor.py`): tracks
-  CPU and memory metrics per plugin and warns about slow plugins
-- **Health Monitor** (`src/plugin_system/health_monitor.py`): tracks
-  plugin failures and last-success timestamps
-
-> Earlier plans called for hard CPU/memory limits and a sandboxed
-> permission system. Neither is implemented. Plugins run in the same
-> process as the display loop with full file-system and network access
-> — review third-party plugin code before installing.
-
-## Plugin Development
-
-### Plugin Structure
-```
-my-plugin/
-├── manifest.json           # Metadata and configuration
-├── manager.py              # Main plugin class
-├── requirements.txt        # Python dependencies
-├── config_schema.json      # Configuration validation
-├── icon.png               # Custom icon (optional)
-└── README.md              # Documentation
-```
-
-### Manifest Format
-```json
-{
-  "id": "my-plugin",
-  "name": "My Custom Display",
-  "version": "1.0.0",
-  "author": "Developer Name",
-  "description": "Brief plugin description",
-  "entry_point": "manager.py",
-  "class_name": "MyPlugin",
-  "category": "custom",
-  "requires": ["requests>=2.25.0"],
-  "config_schema": "config_schema.json"
-}
-```
-
-### Plugin Class Template
-```python
-from src.plugin_system.base_plugin import BasePlugin
-
-class MyPlugin(BasePlugin):
-    def __init__(self, config, display_manager, cache_manager):
-        super().__init__(config, display_manager, cache_manager)
-        self.my_setting = config.get('my_setting', 'default')
-
-    def update(self):
-        # Fetch data from API, database, etc.
-        self.data = self.fetch_my_data()
-
-    def display(self, force_clear=False):
-        # Render to LED matrix
-        self.display_manager.draw_text(
-            self.data,
-            x=5, y=15
-        )
-        self.display_manager.update_display()
-```
-
-## Plugin Store & Distribution
-
-### Registry System
-- **GitHub Repository**: chuckbuilds/ledmatrix-plugin-registry
-- **JSON Registry**: plugins.json with metadata
-- **Version Management**: Semantic versioning support
-- **Verification**: Trusted plugin marking
-
-### Installation Process
-1. **Discovery**: Browse available plugins in web UI
-2. **Selection**: Choose plugin and version
-3. **Download**: Clone from GitHub repository
-4. **Installation**: Install dependencies and register plugin
-5. **Configuration**: Set up plugin settings
-6. **Activation**: Enable and start plugin
-
-### Publishing Process
-```bash
-# Create plugin repository
-git init
-git add .
-git commit -m "Initial plugin release"
-git tag v1.0.0
-git push origin main --tags
-
-# Submit to registry (PR to chuckbuilds/ledmatrix-plugin-registry)
-```
-
-## Web Interface Integration
-
-### Plugin Store UI
-- **Browse**: Filter and search available plugins
-- **Details**: Version info, dependencies, screenshots
-- **Installation**: One-click install process
-- **Management**: Enable/disable installed plugins
-
-### Configuration Interface
-- **Tabbed Layout**: Separate tabs for each plugin
-- **Schema-Driven Forms**: Automatic form generation
-- **Validation**: Real-time configuration validation
-- **Live Updates**: Immediate configuration application
-
-### Status Monitoring
-- **Plugin Health**: Individual plugin status indicators
-- **Resource Usage**: Memory and CPU monitoring
-- **Error Reporting**: Plugin-specific error logs
-- **Update Notifications**: Available update alerts
-
-## Testing & Quality Assurance
-
-### Test Coverage
-- **Unit Tests**: Individual component testing
-- **Integration Tests**: Plugin lifecycle testing
-- **Hardware Tests**: Real Pi validation
-- **Performance Tests**: Resource usage monitoring
-
-### Example Plugins Created
-1. **Football Scoreboard**: Live NFL score display
-2. **Music Visualizer**: Audio spectrum display
-3. **Stock Ticker**: Financial data visualization
-
-### Compatibility Testing
-- **Python Versions**: 3.10, 3.11, 3.12 support
-- **Hardware**: Pi 4, Pi 5 validation
-- **Dependencies**: Comprehensive dependency testing
-
-## Performance & Resource Management
-
-### Optimization Features
-- **Lazy Loading**: Plugins loaded only when needed
-- **Background Updates**: Non-blocking data fetching
-- **Memory Management**: Automatic cleanup and garbage collection
-- **Caching**: Intelligent data caching to reduce API calls
-
-### Resource Limits
-- **Memory**: Per-plugin memory monitoring
-- **CPU**: CPU usage tracking and limits
-- **Network**: API call rate limiting
-- **Storage**: Plugin storage quota management
-
-## Security Considerations
-
-### Plugin Sandboxing
-- **File System Isolation**: Restricted file access
-- **Network Controls**: Limited network permissions
-- **Dependency Scanning**: Security vulnerability checking
-- **Code Review**: Manual review for published plugins
-
-### Permission Levels
-- **Trusted Plugins**: Full system access
-- **Community Plugins**: Restricted permissions
-- **Untrusted Plugins**: Minimal permissions (future)
-
-## Migration & Compatibility
-
-### Backward Compatibility
-- **Existing Managers**: Continue working unchanged
-- **Configuration**: Existing configs remain valid
-- **API**: Core APIs unchanged
-- **Performance**: No degradation in existing functionality
-
-### Migration Tools
-- **Config Converter**: Automatic plugin configuration migration
-- **Dependency Checker**: Validate system compatibility
-- **Backup System**: Configuration backup before changes
-
-### Future Migration Path
-```
-v2.0.0: Plugin infrastructure (current)
-v2.1.0: Migration tools and examples
-v2.2.0: Enhanced plugin features
-v3.0.0: Plugin-only architecture (legacy removal)
-```
-
-## Success Metrics
-
-### ✅ Completed Achievements
-- **Architecture**: Modular plugin system implemented
-- **Store**: GitHub-based plugin distribution working
-- **UI**: Web interface plugin management complete
-- **Examples**: 3 functional example plugins created
-- **Testing**: Comprehensive test coverage achieved
-- **Documentation**: Complete developer and user guides
-
-### 📊 Usage Statistics
-- **Plugin Count**: 3+ plugins available
-- **Installation Success**: 100% successful installations
-- **Performance Impact**: <5% overhead on existing functionality
-- **User Adoption**: Plugin system actively used
-
-### 🔮 Future Enhancements
-- **Sandboxing**: Complete plugin isolation
-- **Auto-Updates**: Automatic plugin updates
-- **Marketplace**: Plugin ratings and reviews
-- **Advanced Dependencies**: Complex plugin relationships
-
-## Technical Highlights
-
-### Plugin Discovery
-```python
-def discover_plugins(self):
-    """Automatically discover plugins in ./plugins/ directory"""
-    for plugin_dir in os.listdir(self.plugins_dir):
-        manifest_path = os.path.join(plugin_dir, 'manifest.json')
-        if os.path.exists(manifest_path):
-            # Load and validate manifest
-            # Register plugin with system
-```
-
-### Dynamic Loading
-```python
-def load_plugin(self, plugin_id):
-    """Dynamically load and instantiate plugin"""
-    plugin_dir = os.path.join(self.plugins_dir, plugin_id)
-    sys.path.insert(0, plugin_dir)
-
-    try:
-        manifest = self.load_manifest(plugin_id)
-        module = importlib.import_module(manifest['entry_point'])
-        plugin_class = getattr(module, manifest['class_name'])
-        return plugin_class(self.config, self.display_manager, self.cache_manager)
-    finally:
-        sys.path.pop(0)
-```
-
-### Configuration Validation
-```python
-def validate_config(self, plugin_id, config):
-    """Validate plugin configuration against schema"""
-    schema_path = os.path.join(self.plugins_dir, plugin_id, 'config_schema.json')
-    with open(schema_path) as f:
-        schema = json.load(f)
-
-    try:
-        validate(config, schema)
-        return True, None
-    except ValidationError as e:
-        return False, str(e)
-```
-
-## Conclusion
-
-The LEDMatrix plugin system successfully transforms the project into a modular, extensible platform. The implementation provides:
-
-- **For Users**: Easy plugin discovery, installation, and management
-- **For Developers**: Clear plugin API and development tools
-- **For Maintainers**: Smaller core codebase with community contributions
-
-The system maintains full backward compatibility while enabling future growth through community-developed plugins. All major components are implemented, tested, and ready for production use.
-
----
-*This document consolidates plugin implementation details from multiple phase summaries into a comprehensive technical overview.*

docs/PLUGIN_QUICK_REFERENCE.md

@@ -99,20 +99,13 @@ class MyPlugin(BasePlugin):
 
 ### 3. Publishing
 
-```bash
-# Create repo
-git init
-git add .
-git commit -m "Initial commit"
-git remote add origin https://github.com/YourName/ledmatrix-my-plugin
-git push -u origin main
-
-# Tag release
-git tag v1.0.0
-git push origin v1.0.0
-
-# Submit to registry (PR to ChuckBuilds/ledmatrix-plugins)
-```
+Official plugins live in the
+[ledmatrix-plugins](https://github.com/ChuckBuilds/ledmatrix-plugins)
+monorepo: add `plugins/<your-plugin-id>/`, bump `version` in its
+`manifest.json` on every change, run `python update_registry.py` there and
+open a pull request. A third-party plugin can stay in its own repository and
+be installed by URL. Git tags and releases are not read by the store; see
+[PLUGIN_REGISTRY_SETUP_GUIDE.md](PLUGIN_REGISTRY_SETUP_GUIDE.md).
 
 ## Using Plugins
 
@@ -127,7 +120,8 @@ git push origin v1.0.0
 
 ### REST API
 
-The API is mounted at `/api/v3` (`web_interface/app.py:199`).
+The API is mounted at `/api/v3` (the `api_v3` blueprint in
+`web_interface/blueprints/api_v3/`, registered in `web_interface/app.py`).
 
 ```bash
 # Install plugin from the registry
@@ -165,20 +159,20 @@ follows this shape:
       "name": "Simple Clock",
       "author": "ChuckBuilds",
       "category": "time",
-      "repo": "https://github.com/ChuckBuilds/ledmatrix-clock-simple",
-      "versions": [
-        {
-          "version": "1.0.0",
-          "ledmatrix_min_version": "2.0.0",
-          "download_url": "https://github.com/.../v1.0.0.zip"
-        }
-      ],
+      "repo": "https://github.com/ChuckBuilds/ledmatrix-plugins",
+      "branch": "main",
+      "plugin_path": "plugins/clock-simple",
+      "latest_version": "1.0.0",
       "verified": true
     }
   ]
 }
 ```
 
+`plugin_path` is empty for a third-party plugin in its own repository. The
+store offers an update when the installed manifest's `version` is older
+than `latest_version`.
+
 ## Benefits
 
 ### For Users
@@ -211,8 +205,11 @@ intentionally simple:
    slow plugins, but no hard CPU/memory caps.
 3. **Plugin ratings**: not yet — the Plugin Store shows version,
    author, and category but no community rating system.
-4. **Auto-updates**: manual via the Plugin Manager tab; no automatic
-   background updates.
+4. **Auto-updates**: off by default. Update from the Plugin Manager tab
+   (per plugin, or **Check & Update All**), or turn on weekly automatic
+   updates in the General tab (`auto_update.enabled`,
+   `web_interface/auto_update.py`), which update LEDMatrix and then the
+   installed plugins.
 5. **Dependency conflicts**: each plugin's `requirements.txt` is
    installed via pip; conflicting versions across plugins are not
    resolved automatically.

docs/PLUGIN_REGISTRY_SETUP_GUIDE.md

@@ -1,412 +1,109 @@
 # Plugin Registry Setup Guide
 
-This guide explains how to set up and maintain your official plugin registry at [https://github.com/ChuckBuilds/ledmatrix-plugins](https://github.com/ChuckBuilds/ledmatrix-plugins).
+This page explains how the official plugin registry works and how a plugin
+gets into it. The registry and the official plugins both live in one
+repository, [ledmatrix-plugins](https://github.com/ChuckBuilds/ledmatrix-plugins);
+its `SUBMISSION.md`, `VERIFICATION.md` and `docs/` are the authoritative
+contributor guides.
 
-## Overview
+## How it fits together
 
-Your plugin registry serves as a **central directory** that lists all official, verified plugins. The registry is just a JSON file; the actual plugins live in their own repositories.
-
-## Repository Structure
-
-```
+```text
 ledmatrix-plugins/
-├── README.md              # Main documentation
-├── LICENSE               # GPL-3.0
-├── plugins.json          # The registry file (main file!)
-├── SUBMISSION.md         # Guidelines for submitting plugins
-├── VERIFICATION.md       # Verification checklist
-└── assets/               # Optional: screenshots, badges
-    └── screenshots/
+├── plugins/
+│   ├── clock-simple/        # one directory per official plugin
+│   │   ├── manifest.json    # source of truth for the plugin's version
+│   │   ├── manager.py
+│   │   ├── config_schema.json
+│   │   └── requirements.txt
+│   └── ...
+├── plugins.json             # the registry the Plugin Store reads
+└── update_registry.py       # regenerates plugins.json from the manifests
 ```
 
-## Step 1: Create plugins.json
+- **Registry.** The Plugin Store fetches
+  `https://raw.githubusercontent.com/ChuckBuilds/ledmatrix-plugins/main/plugins.json`
+  (`PluginStoreManager.REGISTRY_URL` in `src/plugin_system/store_manager.py`)
+  and caches it for 15 minutes.
+- **Monorepo plugins** have `repo` set to the ledmatrix-plugins URL and
+  `plugin_path` set to their directory (`plugins/<id>`). The store downloads
+  just that directory (GitHub API, falling back to the repository ZIP), so
+  installed copies have no `.git` directory.
+- **Third-party plugins** keep their own repository: `repo` points at it and
+  `plugin_path` is empty. The store installs them with `git clone`, falling
+  back to an archive download.
+- **Updates.** For registry plugins the store compares the installed
+  manifest's `version` with the entry's `latest_version`. Git tags and GitHub
+  releases are not read.
 
-This is the **core file** that the Plugin Store reads from.
-
-**Important**: The registry stores **metadata only** (name, description, repo URL, etc.). 
-The plugin store always pulls the latest commit information directly from GitHub, so you never manage semantic versions here.
-
-**File**: `plugins.json`
+## A registry entry
 
 ```json
 {
-  "last_updated": "2025-01-09T12:00:00Z",
-  "plugins": [
-    {
-      "id": "clock-simple",
-      "name": "Simple Clock",
-      "description": "A clean, simple clock display with date and time",
-      "author": "ChuckBuilds",
-      "category": "time",
-      "tags": ["clock", "time", "date"],
-      "repo": "https://github.com/ChuckBuilds/ledmatrix-clock-simple",
-      "branch": "main",
-      "stars": 12,
-      "downloads": 156,
-      "last_updated": "2025-01-09",
-      "last_commit": "abc1234",
-      "verified": true,
-      "screenshot": "https://raw.githubusercontent.com/ChuckBuilds/ledmatrix-plugins/main/assets/screenshots/clock-simple.png"
-    }
-  ]
+  "id": "clock-simple",
+  "name": "Simple Clock",
+  "description": "A clean, simple clock display with date and time",
+  "author": "ChuckBuilds",
+  "category": "time",
+  "tags": ["clock", "time", "date"],
+  "repo": "https://github.com/ChuckBuilds/ledmatrix-plugins",
+  "branch": "main",
+  "plugin_path": "plugins/clock-simple",
+  "stars": 0,
+  "downloads": 0,
+  "last_updated": "2026-09-03",
+  "verified": true,
+  "screenshot": "",
+  "latest_version": "1.0.0"
 }
 ```
 
-**Note**: There's no need for version arrays or release tracking. The store queries GitHub for the latest commit details (date, branch, and short SHA) whenever metadata is requested.
+[plugin_registry_template.json](plugin_registry_template.json) shows a
+monorepo entry and a third-party entry.
 
-## Step 2: Create Plugin Repositories
+Don't edit `latest_version` or `last_updated` by hand for monorepo plugins:
+`update_registry.py` in ledmatrix-plugins writes them from each plugin's
+`manifest.json`.
 
-Each plugin should have its own repository:
+## Adding or changing an official plugin
 
-### Example: Creating clock-simple Plugin
+1. Add or edit `plugins/<your-plugin-id>/` in the monorepo. The store refuses
+   a manifest without `id`, `name`, `class_name` and `display_modes`; also
+   set `version`.
+2. Bump `version` in the plugin's `manifest.json` for every change, or users
+   won't be offered the update.
+3. Run `python update_registry.py` in ledmatrix-plugins and commit the
+   updated `plugins.json` with the plugin change.
+4. Open a pull request. The monorepo's CI and review steps are described in
+   its `SUBMISSION.md`.
 
-1. **Create new repo**: `ledmatrix-clock-simple`
-2. **Add plugin files**:
-   ```
-   ledmatrix-clock-simple/
-   ├── manifest.json
-   ├── manager.py
-   ├── requirements.txt
-   ├── config_schema.json
-   ├── README.md
-   └── assets/
-   ```
-3. **Add to registry**: Update `plugins.json` in ledmatrix-plugins repo
+## Adding a third-party plugin
 
-## Step 3: Update README.md
+Test it with **Plugin Manager → Install from GitHub → Install Single Plugin**
+(or `POST /api/v3/plugins/install-from-url`), then follow the "own
+repository" option in the monorepo's `SUBMISSION.md` to request a registry
+entry.
 
-Create a comprehensive README for your plugin registry:
-
-```markdown
-# LEDMatrix Official Plugins
-
-Official plugin registry for [LEDMatrix](https://github.com/ChuckBuilds/LEDMatrix).
-
-## Available Plugins
-
-<!-- This table is auto-generated from plugins.json -->
-
-| Plugin | Description | Category | Last Updated |
-|--------|-------------|----------|--------------|
-| [Simple Clock](https://github.com/ChuckBuilds/ledmatrix-clock-simple) | Clean clock display | Time | 2025-01-09 |
-| [NHL Scores](https://github.com/ChuckBuilds/ledmatrix-nhl-scores) | Live NHL scores | Sports | 2025-01-07 |
-
-## Installation
-
-All plugins can be installed through the LEDMatrix web interface:
-
-1. Open web interface (http://your-pi-ip:5000)
-2. Open the **Plugin Manager** tab
-3. Browse or search the **Plugin Store** section
-4. Click **Install**
-
-Or via API:
-```bash
-curl -X POST http://your-pi-ip:5000/api/v3/plugins/install \
-  -d '{"plugin_id": "clock-simple"}'
-```
-
-## Submitting Plugins
-
-See [SUBMISSION.md](SUBMISSION.md) for guidelines on submitting your plugin.
-
-## Creating Plugins
-
-See the main [LEDMatrix Plugin Developer Guide](https://github.com/ChuckBuilds/LEDMatrix/wiki/Plugin-Development).
-
-## Plugin Categories
-
-- **Time**: Clocks, timers, countdowns
-- **Sports**: Scoreboards, schedules, stats
-- **Weather**: Forecasts, current conditions
-- **Finance**: Stocks, crypto, market data
-- **Entertainment**: Games, animations, media
-- **Custom**: Unique displays
-```
-
-## Step 4: Create SUBMISSION.md
-
-Guidelines for community plugin submissions:
-
-```markdown
-# Plugin Submission Guidelines
-
-Want to add your plugin to the official registry? Follow these steps!
-
-## Requirements
-
-Before submitting, ensure your plugin:
-
-- ✅ Has a complete `manifest.json` with all required fields
-- ✅ Follows the plugin architecture specification
-- ✅ Has comprehensive README documentation
-- ✅ Includes example configuration
-- ✅ Has been tested on Raspberry Pi hardware
-- ✅ Follows coding standards (PEP 8)
-- ✅ Has proper error handling
-- ✅ Uses logging appropriately
-- ✅ Has no hardcoded API keys or secrets
-
-## Submission Process
-
-1. **Test Your Plugin**
-   ```bash
-   # Install via URL on your Pi
-   curl -X POST http://your-pi:5000/api/v3/plugins/install-from-url \
-     -d '{"repo_url": "https://github.com/you/ledmatrix-your-plugin"}'
-   ```
-
-2. **Fork This Repo**
-   Fork [ledmatrix-plugins](https://github.com/ChuckBuilds/ledmatrix-plugins)
-
-4. **Update plugins.json**
-   Add your plugin entry (metadata only - no versions needed):
-   ```json
-   {
-     "id": "your-plugin",
-     "name": "Your Plugin Name",
-     "description": "What it does",
-     "author": "YourName",
-     "category": "custom",
-     "tags": ["tag1", "tag2"],
-     "repo": "https://github.com/you/ledmatrix-your-plugin",
-     "branch": "main",
-     "verified": false
-   }
-   ```
-
-5. **Submit Pull Request**
-   Create PR with title: "Add plugin: your-plugin-name"
-
-## Review Process
-
-1. **Automated Checks**: Manifest validation, structure check
-2. **Code Review**: Manual review of plugin code
-3. **Testing**: Test installation and basic functionality
-4. **Approval**: If accepted, merged and marked as verified
-
-## After Approval
-
-- Plugin appears in official store
-- `verified: true` badge shown
-- Included in plugin count
-- Featured in README
-
-## Updating Your Plugin
-
-Whenever you push new commits to your plugin repository's default branch, the store will automatically surface the latest commit timestamp and short SHA. No release tagging or manifest version bumps are required.
-
-You only need to update the registry if:
-- Plugin metadata changes (name, description, category, etc.)
-- Repository URL changes
-- You want to update the verified status
-
-To update metadata:
-1. Fork the registry repo
-2. Update plugins.json with new metadata
-3. Submit PR with changes
-4. We'll review and merge
-
-## Questions?
-
-Open an issue in this repo or the main LEDMatrix repo.
-```
-
-## Step 5: Create VERIFICATION.md
-
-Checklist for verifying plugins:
-
-```markdown
-# Plugin Verification Checklist
-
-Use this checklist when reviewing plugin submissions.
-
-## Code Review
-
-- [ ] Follows BasePlugin interface
-- [ ] Has proper error handling
-- [ ] Uses logging appropriately
-- [ ] No hardcoded secrets/API keys
-- [ ] Follows Python coding standards
-- [ ] Has type hints where appropriate
-- [ ] Has docstrings for classes/methods
-
-## Manifest Validation
-
-- [ ] All required fields present
-- [ ] Valid JSON syntax
-- [ ] Last updated metadata present when available
-- [ ] Category is valid
-- [ ] Tags are descriptive
-
-## Functionality
-
-- [ ] Installs successfully via URL
-- [ ] Dependencies install correctly
-- [ ] Plugin loads without errors
-- [ ] Display output works correctly
-- [ ] Configuration schema validates
-- [ ] Example config provided
-
-## Documentation
-
-- [ ] README.md exists and is comprehensive
-- [ ] Installation instructions clear
-- [ ] Configuration options documented
-- [ ] Examples provided
-- [ ] License specified
-
-## Security
-
-- [ ] No malicious code
-- [ ] Safe dependency versions
-- [ ] Appropriate permissions
-- [ ] No network access without disclosure
-- [ ] No file system access outside plugin dir
-
-## Testing
-
-- [ ] Tested on Raspberry Pi
-- [ ] Works with 64x32 matrix (minimum)
-- [ ] No excessive CPU/memory usage
-- [ ] No crashes or freezes
-
-## Approval
-
-Once all checks pass:
-- [ ] Set `verified: true` in plugins.json
-- [ ] Merge PR
-- [ ] Welcome plugin author
-- [ ] Update stats (downloads, stars)
-```
-
-## Step 6: Workflow for Adding Plugins
-
-### For Your Own Plugins
+## Testing locally
 
 ```bash
-# 1. Create plugin in separate repo
-mkdir ledmatrix-clock-simple
-cd ledmatrix-clock-simple
-# ... create plugin files ...
+# Validate a plugin headlessly (from LEDMatrix)
+python3 scripts/check_plugin.py --plugin <id>
 
-# 2. Push to GitHub
-git init
-git add .
-git commit -m "Initial commit"
-git remote add origin https://github.com/ChuckBuilds/ledmatrix-clock-simple
-git push -u origin main
-
-# 3. Update registry
-cd ../ledmatrix-plugins
-# Edit plugins.json to add new entry
-git add plugins.json
-git commit -m "Add clock-simple plugin"
-git push
-```
-
-### For Community Submissions
-
-```bash
-# 1. Receive PR on ledmatrix-plugins repo
-# 2. Review using VERIFICATION.md checklist
-# 3. Test installation:
-curl -X POST http://pi:5000/api/v3/plugins/install-from-url \
-  -d '{"repo_url": "https://github.com/contributor/plugin"}'
-
-# 4. If approved, merge PR
-# 5. Set verified: true in plugins.json
-```
-
-## Step 7: Maintaining the Registry
-
-### Regular Updates
-
-```bash
-# Refresh local clones of all plugin repos
-python3 scripts/update_plugin_repos.py
-
-# (Re-)create local plugin repo checkouts from the registry
-python3 scripts/setup_plugin_repos.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>
-```
-
-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:
-
-### 1. Move to Separate Repos
-
-```bash
-# For each plugin in plugins/
-cd plugins/clock-simple
-
-# Create new repo
-git init
-git add .
-git commit -m "Extract clock-simple plugin"
-git remote add origin https://github.com/ChuckBuilds/ledmatrix-clock-simple
-git push -u origin main
-git tag v1.0.0
-git push origin v1.0.0
-```
-
-### 2. Add to Registry
-
-Update `plugins.json` in ledmatrix-plugins repo.
-
-### 3. Keep or Remove from Main Repo
-
-Decision:
-- **Keep**: Leave in main repo for backward compatibility
-- **Remove**: Delete from main repo, users install via store
-
-## Testing the Registry
-
-After setting up:
-
-```bash
-# Test registry fetch
-curl https://raw.githubusercontent.com/ChuckBuilds/ledmatrix-plugins/main/plugins.json
-
-# Test plugin installation
+# Fetch the registry the way the store does
 python3 -c "
 from src.plugin_system.store_manager import PluginStoreManager
-store = PluginStoreManager()
-registry = store.fetch_registry()
-print(f'Found {len(registry[\"plugins\"])} plugins')
+store = PluginStoreManager(plugins_dir='plugin-repos')
+print(len(store.fetch_registry(force_refresh=True).get('plugins', [])), 'plugins')
 "
 ```
 
-## Benefits of This Setup
-
-✅ **Centralized Discovery**: One place to find all official plugins  
-✅ **Decentralized Storage**: Each plugin in its own repo  
-✅ **Easy Maintenance**: Update registry without touching plugin code  
-✅ **Community Friendly**: Anyone can submit via PR  
-✅ **Version Control**: Track plugin versions and updates  
-✅ **Verified Badge**: Show trust with verified plugins  
-
-## Next Steps
-
-1. Create `plugins.json` in your repo
-2. Update the registry URL in LEDMatrix code (already done)
-3. Create SUBMISSION.md and README.md
-4. Move existing plugins to separate repos
-5. Add them to the registry
-6. Announce the plugin store!
+To work on monorepo plugins against a LEDMatrix checkout, see
+[MULTI_ROOT_WORKSPACE_SETUP.md](MULTI_ROOT_WORKSPACE_SETUP.md) and the
+[Plugin Development Guide](PLUGIN_DEVELOPMENT_GUIDE.md).
 
 ## References
 
-- Plugin Store Implementation: See `PLUGIN_IMPLEMENTATION_SUMMARY.md`
-- User Guide: See `PLUGIN_STORE_GUIDE.md`
-- Architecture: See `PLUGIN_ARCHITECTURE_SPEC.md`
-
+- Plugin Store user guide: [PLUGIN_STORE_GUIDE.md](PLUGIN_STORE_GUIDE.md)
+- Plugin architecture (historical): [PLUGIN_ARCHITECTURE_SPEC.md](PLUGIN_ARCHITECTURE_SPEC.md)
+- [ledmatrix-plugins](https://github.com/ChuckBuilds/ledmatrix-plugins)

docs/PLUGIN_STORE_GUIDE.md

@@ -4,13 +4,22 @@
 
 The LEDMatrix Plugin Store allows you to discover, install, and manage display plugins for your LED matrix. Install curated plugins from the official registry or add custom plugins directly from any GitHub repository.
 
+In the web interface, the **Plugin Store** is a section of the **Plugin
+Manager** tab (below the installed plugins), followed by an **Install from
+GitHub** section.
+
+The Python examples below pass `plugins_dir="plugin-repos"`:
+`PluginStoreManager()` defaults to `plugins`, but the web interface and the
+plugin loader use `plugin_system.plugins_directory` from `config.json`
+(`plugin-repos` by default).
+
 ---
 
 ## Quick Reference
 
 ### Install from Store
 ```bash
-# Web UI: Plugin Store → Search → Click Install
+# Web UI: Plugin Manager → Plugin Store section → Search → Click Install
 # API:
 curl -X POST http://your-pi-ip:5000/api/v3/plugins/install \
   -H "Content-Type: application/json" \
@@ -19,7 +28,7 @@ curl -X POST http://your-pi-ip:5000/api/v3/plugins/install \
 
 ### Install from GitHub URL
 ```bash
-# Web UI: Plugin Store → "Install from URL" → Paste URL
+# Web UI: Plugin Manager → Install from GitHub → "Install Single Plugin" → Paste URL
 # API:
 curl -X POST http://your-pi-ip:5000/api/v3/plugins/install-from-url \
   -H "Content-Type: application/json" \
@@ -57,7 +66,7 @@ The official plugin store contains curated, verified plugins that have been revi
 
 **Via Web Interface:**
 1. Open the web interface at http://your-pi-ip:5000
-2. Navigate to the "Plugin Store" tab
+2. Navigate to the "Plugin Manager" tab and scroll to the "Plugin Store" section
 3. Browse or search for plugins
 4. Click "Install" on the desired plugin
 5. Wait for installation to complete
@@ -74,7 +83,7 @@ curl -X POST http://your-pi-ip:5000/api/v3/plugins/install \
 ```python
 from src.plugin_system.store_manager import PluginStoreManager
 
-store = PluginStoreManager()
+store = PluginStoreManager(plugins_dir="plugin-repos")
 success = store.install_plugin('clock-simple')
 if success:
     print("Plugin installed!")
@@ -90,10 +99,11 @@ Install any plugin directly from a GitHub repository, even if it's not in the of
 
 **Via Web Interface:**
 1. Open the web interface
-2. Navigate to the "Plugin Store" tab
-3. Find the "Install from URL" section
+2. Navigate to the "Plugin Manager" tab
+3. Find "Install Single Plugin" in the "Install from GitHub" section
 4. Paste the GitHub repository URL (e.g., `https://github.com/user/ledmatrix-my-plugin`)
-5. Click "Install from URL"
+   and optionally a branch
+5. Click "Install"
 6. Review the warning about unverified plugins
 7. Confirm installation
 8. Wait for installation to complete
@@ -110,7 +120,7 @@ curl -X POST http://your-pi-ip:5000/api/v3/plugins/install-from-url \
 ```python
 from src.plugin_system.store_manager import PluginStoreManager
 
-store = PluginStoreManager()
+store = PluginStoreManager(plugins_dir="plugin-repos")
 result = store.install_from_url('https://github.com/user/ledmatrix-my-plugin')
 
 if result['success']:
@@ -131,20 +141,20 @@ else:
 **Via REST API:**
 ```bash
 # Search by query
-curl "http://your-pi-ip:5000/api/v3/plugins/store/search?q=hockey"
+curl "http://your-pi-ip:5000/api/v3/plugins/store/list?query=hockey"
 
 # Filter by category
-curl "http://your-pi-ip:5000/api/v3/plugins/store/search?category=sports"
+curl "http://your-pi-ip:5000/api/v3/plugins/store/list?category=sports"
 
 # Filter by tags
-curl "http://your-pi-ip:5000/api/v3/plugins/store/search?tags=nhl&tags=hockey"
+curl "http://your-pi-ip:5000/api/v3/plugins/store/list?tags=nhl&tags=hockey"
 ```
 
 **Via Python:**
 ```python
 from src.plugin_system.store_manager import PluginStoreManager
 
-store = PluginStoreManager()
+store = PluginStoreManager(plugins_dir="plugin-repos")
 
 # Search by query
 results = store.search_plugins(query="hockey")
@@ -175,12 +185,9 @@ curl "http://your-pi-ip:5000/api/v3/plugins/installed"
 ```python
 from src.plugin_system.store_manager import PluginStoreManager
 
-store = PluginStoreManager()
-installed = store.list_installed_plugins()
-
-for plugin_id in installed:
-    info = store.get_installed_plugin_info(plugin_id)
-    print(f"{info['name']} (Last updated: {info.get('last_updated', 'unknown')})")
+store = PluginStoreManager(plugins_dir="plugin-repos")
+for plugin_id in store.list_installed_plugins():
+    print(plugin_id)
 ```
 
 ### Enable/Disable Plugins
@@ -216,7 +223,7 @@ curl -X POST http://your-pi-ip:5000/api/v3/plugins/update \
 ```python
 from src.plugin_system.store_manager import PluginStoreManager
 
-store = PluginStoreManager()
+store = PluginStoreManager(plugins_dir="plugin-repos")
 success = store.update_plugin('clock-simple')
 ```
 
@@ -239,7 +246,7 @@ curl -X POST http://your-pi-ip:5000/api/v3/plugins/uninstall \
 ```python
 from src.plugin_system.store_manager import PluginStoreManager
 
-store = PluginStoreManager()
+store = PluginStoreManager(plugins_dir="plugin-repos")
 success = store.uninstall_plugin('clock-simple')
 ```
 
@@ -296,13 +303,17 @@ When installing from a custom GitHub URL, you'll see a warning about installing
 
 ### Plugin Won't Install
 
-**Problem:** Installation fails with "Failed to clone or download repository"
+**Problem:** Installation fails
 
 **Solutions:**
-- Check that git is installed: `which git`
+- Plugins from the official registry live in the `ledmatrix-plugins`
+  monorepo and are downloaded, not cloned: the store fetches the plugin's
+  directory through the GitHub API and falls back to extracting it from the
+  repository ZIP, so git is not involved (the installed copy has no `.git`)
+- A plugin installed by URL from its own repository is cloned with git,
+  falling back to an archive download; check `which git` if that fails
 - Verify the GitHub URL is correct
 - Check your internet connection
-- The system will automatically try ZIP download as fallback
 
 ### Plugin Won't Load
 
@@ -351,8 +362,7 @@ All API endpoints return JSON with this structure:
 
 | Method | Endpoint | Description |
 |--------|----------|-------------|
-| GET | `/api/v3/plugins/store/list` | List all plugins in store |
-| GET | `/api/v3/plugins/store/search` | Search for plugins |
+| GET | `/api/v3/plugins/store/list` | List plugins in store; `?query=`, `?category=`, `?tags=` search and filter |
 | GET | `/api/v3/plugins/installed` | List installed plugins |
 | POST | `/api/v3/plugins/install` | Install from registry |
 | POST | `/api/v3/plugins/install-from-url` | Install from GitHub URL |
@@ -411,10 +421,10 @@ As a plugin developer, you can share your plugin with others even before it's in
 2. Share the URL with users
 3. Users install via:
    - Open the LEDMatrix web interface
-   - Click "Plugin Store" tab
-   - Scroll to "Install from URL"
+   - Open the "Plugin Manager" tab
+   - Scroll to "Install from GitHub" → "Install Single Plugin"
    - Paste the URL
-   - Click "Install from URL"
+   - Click "Install"
 
 ---
 
@@ -426,14 +436,14 @@ For advanced users, manage plugins via command line:
 # Install from registry
 python3 -c "
 from src.plugin_system.store_manager import PluginStoreManager
-store = PluginStoreManager()
+store = PluginStoreManager(plugins_dir='plugin-repos')
 store.install_plugin('clock-simple')
 "
 
 # Install from URL
 python3 -c "
 from src.plugin_system.store_manager import PluginStoreManager
-store = PluginStoreManager()
+store = PluginStoreManager(plugins_dir='plugin-repos')
 result = store.install_from_url('https://github.com/user/plugin')
 print(result)
 "
@@ -441,16 +451,15 @@ print(result)
 # List installed
 python3 -c "
 from src.plugin_system.store_manager import PluginStoreManager
-store = PluginStoreManager()
+store = PluginStoreManager(plugins_dir='plugin-repos')
 for plugin_id in store.list_installed_plugins():
-    info = store.get_installed_plugin_info(plugin_id)
-    print(f'{plugin_id}: {info[\"name\"]} (Last updated: {info.get(\"last_updated\", \"unknown\")})')
+    print(plugin_id)
 "
 
 # Uninstall
 python3 -c "
 from src.plugin_system.store_manager import PluginStoreManager
-store = PluginStoreManager()
+store = PluginStoreManager(plugins_dir='plugin-repos')
 store.uninstall_plugin('clock-simple')
 "
 ```
@@ -469,10 +478,17 @@ A: Yes, you can install anytime, but you must restart the display to load them.
 A: The existing copy will be replaced with the latest code from the repository.
 
 **Q: Can I install multiple versions of the same plugin?**
-A: No, each plugin ID maps to a single checkout of the repository's default branch.
+A: No, each plugin ID maps to a single installed copy.
 
 **Q: How do I update all plugins at once?**
-A: Currently, you need to update each plugin individually. Bulk update is planned for a future release.
+A: Click **Check & Update All** at the top of the Plugin Manager tab. You can
+also turn on weekly automatic updates (off by default) in the General tab;
+they update LEDMatrix itself and then the installed plugins
+(`web_interface/auto_update.py`).
+
+**Q: How does the store know an update is available?**
+A: For registry plugins it compares the installed manifest's `version` with
+the registry's `latest_version`; git tags and releases are not consulted.
 
 **Q: Can plugins access my API keys from config_secrets.json?**
 A: Yes, if a plugin needs API keys, it can access them like core managers do.

docs/PLUGIN_WEB_UI_ACTIONS.md

@@ -25,9 +25,6 @@ Add a `web_ui_actions` array to your plugin's `manifest.json`:
       "script": "path/to/script.py",
       "oauth_flow": false,
       "section_description": "Optional section description",
-      "success_message": "Action completed successfully",
-      "error_message": "Action failed",
-      "step1_message": "Authorization URL generated",
       "step2_prompt": "Please paste the full redirect URL:",
       "step2_button_text": "Complete Authentication"
     }
@@ -52,12 +49,13 @@ Add a `web_ui_actions` array to your plugin's `manifest.json`:
 - **`color`**: Color theme - `"blue"`, `"green"`, `"red"`, `"yellow"`, `"purple"`, etc. (defaults to `"blue"`)
 - **`oauth_flow`**: Set to `true` for OAuth-style two-step authentication flows
 - **`section_description`**: Description shown at the top of the actions section
-- **`success_message`**: Message shown on successful completion
-- **`error_message`**: Message shown on failure
-- **`step1_message`**: Message shown after step 1 (for OAuth flows)
 - **`step2_prompt`**: Prompt text for step 2 redirect URL input
 - **`step2_button_text`**: Button text for step 2 (defaults to "Complete Authentication")
 
+The status messages shown after an action runs come from the action's
+response (`message`), with built-in fallbacks such as "Action completed
+successfully"; there are no manifest fields for them.
+
 ## Action Types
 
 ### Script Actions (`type: "script"`)
@@ -98,7 +96,6 @@ For two-step OAuth flows (e.g., Spotify):
   "color": "green",
   "script": "authenticate_spotify.py",
   "oauth_flow": true,
-  "step1_message": "Authorization URL generated",
   "step2_prompt": "Please paste the full redirect URL from Spotify after authorization:",
   "step2_button_text": "Complete Authentication"
 }
@@ -131,9 +128,6 @@ Here's a complete example for the `ledmatrix-music` plugin:
       "script": "authenticate_spotify.py",
       "oauth_flow": true,
       "section_description": "Authenticate with Spotify or YouTube Music to enable music playback display.",
-      "success_message": "Spotify authentication completed successfully",
-      "error_message": "Spotify authentication failed",
-      "step1_message": "Authorization URL generated",
       "step2_prompt": "Please paste the full redirect URL from Spotify after authorization:",
       "step2_button_text": "Complete Authentication"
     },
@@ -145,9 +139,7 @@ Here's a complete example for the `ledmatrix-music` plugin:
       "button_text": "Authenticate YTM",
       "icon": "fab fa-youtube",
       "color": "red",
-      "script": "authenticate_ytm.py",
-      "success_message": "YouTube Music authentication completed successfully",
-      "error_message": "YouTube Music authentication failed"
+      "script": "authenticate_ytm.py"
     }
   ]
 }

docs/PLUGIN_WEB_UI_ACTIONS_EXAMPLE.json

@@ -37,9 +37,6 @@
       "script": "authenticate_spotify.py",
       "oauth_flow": true,
       "section_description": "Authenticate with Spotify or YouTube Music to enable music playback display.",
-      "success_message": "Spotify authentication completed successfully",
-      "error_message": "Spotify authentication failed",
-      "step1_message": "Authorization URL generated",
       "step2_prompt": "Please paste the full redirect URL from Spotify after authorization:",
       "step2_button_text": "Complete Authentication"
     },
@@ -51,9 +48,7 @@
       "button_text": "Authenticate YTM",
       "icon": "fab fa-youtube",
       "color": "red",
-      "script": "authenticate_ytm.py",
-      "success_message": "YouTube Music authentication completed successfully",
-      "error_message": "YouTube Music authentication failed"
+      "script": "authenticate_ytm.py"
     }
   ],
   "versions": [

docs/README.md

@@ -45,6 +45,8 @@ Going deeper:
 
 - [PLUGIN_CONFIG_QUICK_START.md](PLUGIN_CONFIG_QUICK_START.md) — minimal config you need
 - [PLUGIN_CONFIGURATION_GUIDE.md](PLUGIN_CONFIGURATION_GUIDE.md) — schema design
+- [PLUGIN_ELEMENT_STYLING.md](PLUGIN_ELEMENT_STYLING.md) — let users restyle,
+  move, hide and scale individual elements (per display mode, if you have them)
 - [PLUGIN_CONFIGURATION_TABS.md](PLUGIN_CONFIGURATION_TABS.md) — multi-tab UI configs
 - [PLUGIN_CONFIG_ARCHITECTURE.md](PLUGIN_CONFIG_ARCHITECTURE.md) — how the config system works
 - [PLUGIN_CONFIG_CORE_PROPERTIES.md](PLUGIN_CONFIG_CORE_PROPERTIES.md) — properties every plugin honors
@@ -54,8 +56,6 @@ 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
 
@@ -63,7 +63,6 @@ Going deeper:
 - [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
-- [PLUGIN_IMPLEMENTATION_SUMMARY.md](PLUGIN_IMPLEMENTATION_SUMMARY.md) — what the plugin system actually does
 
 ## Contributing to LEDMatrix itself
 
@@ -73,18 +72,17 @@ Going deeper:
 - [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
+## Audits
 
-`docs/archive/` holds older guides that have been superseded or describe
-features that have been removed. They are kept for historical context and
-git history but should not be relied on.
+- [audits/WEB_UI_AUDIT_2026-09.md](audits/WEB_UI_AUDIT_2026-09.md) — web UI audit (September 2026)
 
 ## Contributing to the docs
 
 - Markdown only, professional tone, minimal emoji.
 - Prefer adding to an existing page over creating a new one. If you add a
   new page, link it from this index in the section it belongs to.
-- If a page becomes obsolete, move it to `docs/archive/` rather than
-  deleting it, so links don't rot.
+- If a page becomes obsolete, delete it (it stays in the repository
+  history) and fix the links to it; `test/test_doc_links.py` fails on
+  broken relative links.
 - Keep examples runnable — paths, commands, and config keys here should
   match what's actually in the repo.

docs/SCROLL_PERFORMANCE.md

@@ -0,0 +1,405 @@
+# Scroll Performance
+
+How scrolling is paced on this hardware, what was wrong with it, and how to
+configure a plugin so its marquee is smooth.
+
+Measured on a Raspberry Pi 4 driving a 2×128×64 chain (256×64 logical) at
+`limit_refresh_rate_hz: 100`. Numbers below come from that panel.
+
+| | before | after |
+|---|---|---|
+| scroll frame rate | 44–46 fps | **100 fps, locked** |
+| frames ≥ 45 ms | 14–17% | none observed |
+| dominant frame time | 20 ms | **10 ms** |
+| disk cache write (~1 MB) | 14.8 ms | **5.4 ms** |
+
+---
+
+## The one rule that matters
+
+**Motion is smooth when the strip advances a whole number of pixels per panel
+refresh.**
+
+Advancing one pixel per refresh on a 100 Hz panel gives 100 px/s. Slower crisp
+speeds come from holding each frame for several refreshes -- 50 px/s is one
+pixel every second refresh -- which is covered under *Choosing a speed* below.
+A speed that lands on no such combination has to do one of two bad things:
+
+- **blend** two adjacent columns to render a half-step — on pixel-font text
+  this alternates crisp and smeared frames and reads as shimmer, or as the
+  text jumping a pixel ahead of itself;
+- **repeat** a frame — the strip stands still, then jumps, which reads as
+  judder.
+
+Neither is tunable away. Pick a speed that divides evenly.
+
+`src.common.scroll_config` solves this for you: `configure()` snaps a requested
+speed to the nearest one the panel can actually show in whole pixels, and
+`scripts/scroll_speeds.py` prints the full ladder for your hardware.
+
+## Choosing a speed
+
+The crisp speeds are not a fixed list -- they depend on how fast *your* panel
+refreshes, which depends on its size, `pwm_bits`, `gpio_slowdown` and the Pi
+model. A Pi Zero driving a long chain has a completely different set of good
+speeds from a Pi 4 driving a short one.
+
+```bash
+# what can this panel do? (reads your configured refresh rate)
+python3 scripts/scroll_speeds.py
+
+# what does it ACTUALLY manage, rather than what is configured?
+sudo systemctl stop ledmatrix
+sudo python3 scripts/scroll_speeds.py --measure
+sudo systemctl start ledmatrix
+
+# highlight the closest option to the speed you want
+python3 scripts/scroll_speeds.py --want 45
+
+# try one on the panel
+sudo systemctl stop ledmatrix
+sudo python3 scripts/scroll_speeds.py --demo 50
+sudo systemctl start ledmatrix
+```
+
+Sample ladder for a 100 Hz panel:
+
+```
+  20.0 px/s  (1px every 5 refreshes =  20.0 fps, slightly stepped)
+  25.0 px/s  (1px every 4 refreshes =  25.0 fps, slightly stepped)
+  33.3 px/s  (1px every 3 refreshes =  33.3 fps, smooth)
+  50.0 px/s  (1px every 2 refreshes =  50.0 fps, smooth)
+  66.7 px/s  (2px every 3 refreshes =  33.3 fps, smooth)
+ 100.0 px/s  (1px every 1 refresh  = 100.0 fps, smooth)
+```
+
+### How a slow speed stays crisp
+
+`SwapOnVSync(canvas, framerate_fraction)` holds each frame for N panel
+refreshes. **The panel keeps refreshing at its full rate either way**, so
+holding a frame costs nothing in flicker -- it only changes how often a *new*
+image is presented. That is what allows 50 px/s to be one whole pixel every
+second refresh, instead of half a pixel every refresh (which has no good
+rendering, only a choice between blur and judder).
+
+`scroll_config.configure()` snaps the requested speed to the nearest entry on
+the ladder, sets the helper to advance that entry's whole-pixel step on every
+presented frame (`ScrollHelper.set_pixels_per_frame`), and reports the hold
+that speed needs. It does **not** apply the hold: the hold belongs to a scroll, not to a plugin's lifetime, and plugins
+share one display manager -- one set at construction is reset the moment any
+other plugin finishes scrolling. Apply it yourself when the scroll starts:
+
+```python
+settings = scroll_config.configure(
+    self.scroll_helper,
+    plugin_config=self.config,
+    global_config=self.global_config,
+    display_manager=self.display_manager,   # supplies the panel refresh rate
+)
+
+# ...then, each time this plugin begins scrolling:
+self.display_manager.set_scrolling_state(True, frame_hold=settings.frame_hold)
+```
+
+Passing `display_manager` only lets `configure` read the true refresh rate from
+`display.hardware`, which a plugin config cannot see. Skipping the
+`set_scrolling_state(True, frame_hold=...)` call is the mistake that matters.
+The helper consults no clock in this mode -- it moves the fixed step once per
+`update_scroll_position()` call, and `SwapOnVSync` is what paces those calls --
+so without the hold the panel presents a new frame every refresh and the scroll
+runs `frame_hold` times too fast: 50 px/s (hold 2) plays at 100 px/s.
+
+Pass `snap_to_crisp=False` to keep an exact requested speed and accept the
+artefacts. The helper then paces off elapsed time instead of stepping, and the
+hold is 1.
+
+The General tab's `target_fps` ("Scroll Frame Rate") plays no part in any of
+this: frames are presented at the panel refresh divided by the hold.
+
+Speeds slower than about 20 px/s are stepped no matter what, because a 1-pixel
+advance at 20 fps is simply a coarse increment. That is the pixel pitch, not a
+software limit; the only way to move in smaller increments is sub-pixel
+blending, which this display does not tolerate (see above).
+
+## Configuring a plugin
+
+Use the shared resolver rather than reading config keys yourself:
+
+```python
+from src.common import scroll_config
+
+settings = scroll_config.configure(
+    self.scroll_helper,
+    plugin_config=self.config,
+    global_config=self.global_config,
+    display_manager=self.display_manager,
+    plugin_logger=self.logger,
+)
+
+# each frame of a scroll (or at least when it starts):
+self.display_manager.set_scrolling_state(True, frame_hold=settings.frame_hold)
+```
+
+It resolves every config shape in one place, applies the speed, and returns
+what it did. Precedence, highest first:
+
+1. `display_options.scroll_speed` + `scroll_delay` — **the recommended form**
+2. `display.scroll_speed` + `scroll_delay` — deprecated shape
+3. `scroll_speed` + `scroll_delay` at the root — legacy flat
+4. `scroll_pixels_per_second` — deprecated
+5. the global `display` block
+6. the built-in default (100 px/s)
+
+`scroll_speed` is pixels per frame and `scroll_delay` is the frame period in
+seconds, so the pair means `scroll_speed / scroll_delay` px/s. The recommended
+config for a 100 Hz panel:
+
+```json
+"display_options": { "scroll_speed": 1.0, "scroll_delay": 0.01 }
+```
+
+### Why the deprecated key ranks below the explicit pair
+
+Because some plugins give `scroll_pixels_per_second` a **schema default**, and
+schema defaults are merged into plugin config. Ranking it above the pair means
+it is always present and always wins, so the documented settings become
+unreachable. That is a real, shipped bug — see
+[ledmatrix-plugins#408](https://github.com/ChuckBuilds/ledmatrix-plugins/issues/408).
+
+The flip side: a `scroll_pixels_per_second` you add by hand is ignored whenever
+the plugin's config also carries the pair, which it does whenever the pair has
+a schema default. Set the speed through the pair instead.
+
+The sports scoreboards (`src.common.sports_scroll`) are the exception to all of
+the above: they read `scroll_settings.scroll_speed` per league as px/s directly,
+and their `scroll_delay` is kept for compatibility but ignored for pacing.
+
+If you are writing a plugin: do not give a deprecated key a schema default.
+
+## What was actually wrong
+
+Four independent faults, each found by measurement.
+
+### 1. The frame loop slept on top of a wait it had already done
+
+`display_controller.py` ran the high-FPS loop as `render → SwapOnVSync (blocks
+to the panel's refresh) → time.sleep(0.008) → plugin ticks`. The sleep was
+unconditional and added to a wait that had already happened. Render work
+measured ~4 ms, so each iteration cost ~12 ms against a 10 ms refresh grid —
+every swap missed a refresh and landed on the next one. The loop settled at
+exactly 50 fps while asking for 125, with no headroom, so ~14% of frames
+slipped a further refresh.
+
+Now the loop sleeps only the remainder of the frame budget, with a 1 ms floor
+so plugin threads still get the GIL.
+
+### 2. `SwapOnVSync` held the GIL while blocking
+
+The rgbmatrix binding declares it without `nogil` (unlike `SetPixel`, `Clear`
+and `Fill` immediately above it in `cppinc.pxd`), so the render thread held the
+GIL for the entire vsync wait — most of every frame. Background threads were
+starved into long uninterruptible bursts; a 1.5 MB API response costs ~17 ms to
+parse and ~18 ms to re-encode for the cache, and `json.raw_decode` cannot be
+preempted mid-document. Those bursts are what the render loop then waited on.
+
+Fixed by rebuilding the binding: `scripts/build_rgbmatrix_nogil.sh`.
+
+### 3. Sub-pixel blending was wrong for this display
+
+Enabling it made things worse, not better — see the rule at the top. It is off
+by default and only Vegas mode opts in via `set_sub_pixel_scrolling(True)`.
+
+### 4. Frame-based stepping raced the vsync clock
+
+Frame-based mode gated motion on a wall clock at `1/scroll_delay` steps per
+second. Plugins set `scroll_delay` to the frame period, which puts that
+comparison exactly on its own threshold: a frame arriving a hair early moved
+zero pixels and rendered an identical frame, which dirty-tracking skipped, so
+it returned in ~2 ms and the beat repeated. No `scroll_delay` value tunes this
+out — a shorter delay just trades stalled frames for periodic double-steps.
+
+A crisp speed configured through `scroll_config` no longer consults a clock at
+all. Once `SwapOnVSync` blocks until the panel has taken the frame, the frame
+count is a truer clock than `time.time()`, so the helper advances a fixed whole
+number of pixels per presented frame (`set_pixels_per_frame`) and the display
+manager holds each frame for `frame_hold` refreshes. Every frame moves the eye
+by the same amount.
+
+The time-based path remains only for callers that set a speed directly or pass
+`snap_to_crisp=False`. There, frame-based mode no longer steps either: it
+advances by elapsed time at `scroll_speed / scroll_delay` px/s.
+
+## Diagnosing a juddery scroller
+
+**An average will lie to you.** A 2 ms duplicate frame and a 21 ms double-wait
+mean exactly 10 ms, so a ticker stalling on half its frames still averages to a
+healthy 100 fps. The stats line reports the tail for that reason — read the
+percentiles, not the fps.
+
+Every scroller emits one line every 5 seconds covering *every* frame in that
+window, tagged with the plugin it came from:
+
+```bash
+journalctl -u ledmatrix --since "-10min" --no-pager | grep "Scroll frame stats"
+```
+
+```
+[Plugin: news] Scroll frame stats - 100.0 fps over 501 frames | median 10.00ms
+p95 10.11ms max 12.03ms min 7.98ms | stalls 0 (0.0%) skips 0 (0.0%)
+```
+
+Reading it, on a 100 Hz panel:
+
+A healthy median is the refresh period times the scroll's frame hold: 10 ms
+for a hold of 1 (100 px/s), **20 ms for 50 px/s** (hold 2), 30 ms for 33.3 px/s.
+A 20 ms median on a 50 px/s scroll is the hold doing its job, not missed
+refreshes. The `Scroll configured:` log line gives the hold (`1px every 2
+refreshes`).
+
+| you see | it means |
+|---|---|
+| median = refresh period × hold, p95 within ~0.5 ms of it | healthy — locked to the panel |
+| p95 or max a whole refresh period or more above that median | frames missing refreshes — per-frame work is overrunning, or a background thread is holding the GIL |
+| non-zero **skips**, or a median *below* the expected one | **duplicate frames** — the swap was skipped because the image did not change, so the frame never waited on vsync. The scroller is advancing less than one pixel per frame, which a crisp fixed-step scroll never does; look for a plugin pacing off time or not passing the hold. |
+| non-zero **stalls** | frames past 1.5× the median, which is the measure of judder that survives averaging |
+
+`stalls` and `skips` are both counted against that window's own median, so they
+stay meaningful on a panel running at any refresh rate.
+
+To rank every scroller at once rather than reading lines one at a time:
+
+```bash
+journalctl -u ledmatrix --since "-3h" --no-pager | grep "Scroll frame stats" \
+  | sed -E 's/.*- (\S+) - (\[Plugin: [^]]+\] )?Scroll.*median ([0-9.]+)ms p95 ([0-9.]+)ms.*/\1 \3 \4/' \
+  | awk '$2 < 1000 {n[$1]++; m[$1]+=$2; p[$1]+=$3} END {for (k in n)
+        printf "%-28s %5d windows  median %6.2fms  p95 %6.2fms\n", k, n[k], m[k]/n[k], p[k]/n[k]}' \
+  | sort -k7 -rn
+```
+
+The `$2 < 1000` guard drops windows whose median is a whole second or more.
+Those are not frames. Until the idle-gap fix in `log_frame_rate()`, the first
+frame of every scroll was timed against the end of the *previous* scroll, so
+the gap between them was recorded as one enormous sample — it landed in the
+`max` field of otherwise healthy windows and counted as one stall per scroll,
+roughly 0.2% at 500 frames to a window, which is the same order as the real
+stall rates it sat beside. Current builds emit none, but the guard costs
+nothing and keeps the command honest against older journals.
+
+A scroller whose p95 sits several times its median is the one to fix, and it is
+usually the one doing the most per-frame work rather than the one configured
+worst. Measured over 20 minutes with two scrollers set identically at 100 px/s,
+the leaderboard held 10 ms flat while the odds ticker spent ~20% of its frames
+on duplicates. Same settings, different render cost: odds does more per-frame
+work, and more variably, so it is first to land a frame that advances less than
+a whole pixel. Check the render path before the config.
+
+Then confirm what the plugin actually loaded — config edits do not always reach
+the running code:
+
+```bash
+journalctl -u ledmatrix --since "-5min" --no-pager | grep -iE "px/s|px/frame"
+```
+
+If a plugin logs its scroll config **twice** with different modes, the second
+line is what is running.
+
+---
+
+## A tear across the middle on fast scrolls
+
+**Symptom:** while text scrolls, the top and bottom halves of the panel look
+shifted sideways against each other along a horizontal line at mid-height, and
+the shift grows with scroll speed. It shows most in Vegas mode at high speed.
+
+**It is the panel's scan, not the software.** The measured panel, like most
+64-row panels, is multiplexed 1:32 (some panels of the same size scan
+differently, so check yours): it lights two rows at a time, one from each half
+(row 0 with row 32, row 1 with row 33, …), stepping down both halves together
+once per refresh. So row 31,
+the last row of the top half, lights almost a whole refresh period after row 32
+right below it. Your eye follows moving text, and moving content that lights at
+different times lands in different places, so the two rows meet with an offset
+of roughly
+
+```
+offset ≈ scroll speed × refresh period
+```
+
+Each frame already reaches the panel whole (`SwapOnVSync` swaps complete frames
+between refreshes), so there is nothing to fix in the render path; the shift is
+created inside a single refresh. Other panel heights show it too, at the point
+where their two scan halves meet.
+
+On the 2×128×64 chain above, which refreshes at about 130 Hz flat out
+(7.7 ms per pass):
+
+| scroll speed | offset at the midline |
+|---|---|
+| 50 px/s (Vegas default) | ~0.4 px |
+| 100 px/s | ~0.8 px |
+| 150 px/s | ~1.2 px, plainly visible |
+
+### What changes it
+
+Only a shorter scan period (a faster refresh) or a slower scroll. Measure what
+the panel actually achieves first. The library prints the rate with a carriage
+return and no newline, so read it from the raw journal:
+
+```bash
+# set display.hardware.show_refresh_rate to true (web UI, Display tab), restart, then:
+journalctl -u ledmatrix --since "-1min" --no-pager -o cat --all | grep -a -oE "[0-9.]+Hz" | tail -5
+```
+
+Turn it off again afterwards. Measured on that panel (Pi 4, single chain),
+changing one setting at a time from `pwm_bits: 7`, `gpio_slowdown: 3`:
+
+| change | refresh, uncapped | notes |
+|---|---|---|
+| none | ~130 Hz | the ceiling for this wiring |
+| `pwm_bits: 6` | ~138 Hz | barely faster, and half the colour depth |
+| `gpio_slowdown: 2` | ~130 Hz | no faster, **and visible glitching**; keep 3 |
+| `limit_refresh_rate_hz: 0` | ~130 Hz | Vegas dropped from 100 to 72–95 fps as the refresh thread took more CPU |
+
+None of these helps much, because the time goes into shifting each row's pixels
+out: a 2×128 chain pushes 256 pixels per row down one output. What does help is
+**fewer pixels per output**. On a bonnet with more than one output (the
+`regular` and `classic` mappings have 3; `adafruit-hat` has 1), put each panel
+on its own output and set `parallel` to the number of outputs used and
+`chain_length` to the panels per output, for example `parallel: 2`,
+`chain_length: 1` for two panels. Each refresh then shifts half the data, which
+should roughly double the refresh rate and halve the offset. That is a cable
+change, so measure again afterwards.
+
+Short of rewiring, keep fast scrolls moderate: at the default 50 px/s the
+offset is under half a pixel.
+
+## Rebuilding the binding
+
+```bash
+bash scripts/build_rgbmatrix_nogil.sh              # build into a scratch dir
+sudo bash scripts/build_rgbmatrix_nogil.sh --install
+sudo bash scripts/build_rgbmatrix_nogil.sh --rollback
+```
+
+The build never touches the installed module. `--install` backs up the original
+to `~/rgbmatrix-core.so.ORIGINAL` first, and rolls back automatically if the
+service does not come back healthy. Requires `build-essential`; Cython is
+installed into a cached venv under `~/.cache/ledmatrix-cython`.
+
+Re-run it after upgrading `rpi-rgb-led-matrix`, since a library upgrade
+replaces the patched binding.
+
+## Faster JSON
+
+`src/cache/disk_cache.py` uses `orjson` when it is importable and falls back to
+the stdlib otherwise, so it is optional:
+
+```bash
+sudo pip3 install --break-system-packages orjson
+```
+
+Encoding is where it pays — about 7× on this hardware. Decoding gains far less
+(~1.3× on large payloads) because the cost there is building Python objects,
+not scanning text. That is also why moving parsing to a subprocess does not
+help: `pickle.loads` of the same payload costs 8.1 ms against `json.loads` at
+10.9 ms, so the work just moves rather than disappearing.

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

@@ -7,9 +7,9 @@ becoming nine clients of a god class.
 
 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.
+repo's former `src/base_classes/sports.py` (since removed). 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
@@ -26,7 +26,7 @@ These are independent concerns. Conflating them is what produces god classes.
 |---|---|
 | 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. |
+| Core changes never break a plugin's rendering | The **view-model contract**: the game dict each plugin's `_extract_game_details_common` builds is read by the shared `src/common` renderers, so its 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*. The store enforces that floor on every registry-managed install and on both supported update paths (sideloading via `install_from_url` is not gated), but a floor cannot reach a user who never updates, 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
@@ -67,23 +67,36 @@ This is the property the naive merge destroys, and it is enforced structurally:
 
 ## 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/base_classes/` has been removed: no scoreboard plugin built on it. B1 and
+B2 below promoted code into it (`SportsCore`, the mode classes,
+`CelebrationMixin`, the rotation strategies); the override points and
+capabilities sections record that design, but none of it ships in core any
+more. Shared sports code lives in `src/common`:
 
+```
 src/common/
   sports_scroll.py       SportsScrollDisplay / …Manager — scroll orchestration
                          (content building stays in the plugins)
+  sports_helpers.py      clamp/logo/rotation free functions + SportsHelpersMixin
+                         (3.5.0) — the helpers byte-identical in the
+                         plugins' sports.py, and the _favorite_key seam
 ```
 
-`from src.base_classes.sports import SportsCore` keeps working — the package
-`__init__` re-exports, so the conversion is invisible to every existing importer.
+### Converging on `src/common`
+
+The scoreboards never built on `src/base_classes` (now removed); their own
+`sports.py` copies had moved past it. So shared code now lands in hardware-free `src/common`
+modules taken from the plugin copies, each a **new module** rather than growth
+on an existing one: a plugin that deletes a method copy and relies on an older
+module having gained it fails at runtime with an `AttributeError`, while a
+missing module fails at load, where the version checks can see it.
+`sports_helpers.py` is the first (it holds `_favorite_key`, the override point
+listed below, for later phases); its parity test compares every body against
+the plugin copies when `LEDMATRIX_PLUGINS` points at a checkout, and
+`test/test_common_is_hardware_free.py` keeps `src/common` free of
+`rgbmatrix`, `src.display_manager` and `src.plugin_system`. How a plugin adopts a
+module and drops its copy is documented in the plugins repo's
+`docs/plugin-development/08-shared-sports-code.md`.
 
 ## Override points (the plugin-facing seam)
 
@@ -97,7 +110,6 @@ deprecation cycle.
 | `_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"]` |
@@ -170,9 +182,9 @@ 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
+`test_sports_capabilities.py` (removed with `src/base_classes`) checked 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
@@ -199,6 +211,14 @@ The one behavior the upstreamed version adds is native
 Part A threaded it through each copy by hand, and this makes that threading
 legacy compatibility rather than the mechanism.
 
+> **Superseded.** Once presentation became frame-locked (#545) the helper
+> steps a fixed whole-pixel amount per presented frame and the panel presents
+> at its own refresh, so honouring `target_fps` only turned it into a speed
+> multiplier (60 doubled a scoreboard's speed, 200 halved it). `sports_scroll`
+> no longer reads it: the crisp-speed ladder uses the panel refresh
+> (`display_manager.refresh_hz`), and speed comes from
+> `scroll_settings.scroll_speed` alone. See `docs/SCROLL_PERFORMANCE.md`.
+
 ## Phases
 
 B0–B3 are merged and shipping in core 3.2.0. Everything that remains is
@@ -445,8 +465,9 @@ After adoption plus the frozen legacy copies it was 10,610; removing the dead
 inline duplication (plugins #252) brought it to roughly 8,620. B6 would take it
 to about 3,300 including the shared core module — some 2,400 fewer than before
 this project started. **Until B6 runs, the adoption is net negative on disk**,
-and its one delivered user-visible gain is that adopted plugins honour the
-global `target_fps` instead of hardcoding ~100 FPS.
+and its one delivered user-visible gain was that adopted plugins honoured the
+global `target_fps` instead of hardcoding ~100 FPS (since withdrawn: see the
+note under the B3 design above).
 
 ### Decision: stop adopting further modules until B6 closes
 
@@ -479,9 +500,9 @@ What actually remains, smallest first:
 3. **Reconsider the held modules** (`data_sources.py`, `game_renderer.py`,
    `base_odds_manager.py`) now that the sunset has closed. `game_renderer.py` is
    the largest single duplication left: ~11,500 lines across eight plugins, with
-   ~36,500 more in the eight `sports.py`. Note that core already ships
-   `src/base_classes/sports/` (~143KB, promoted in B1/B2) that **no plugin
-   imports** — check whether it has drifted before treating it as the target.
+   ~36,500 more in the eight `sports.py`. The `src/base_classes/sports/`
+   package promoted in B1/B2 was never imported by a plugin and has been
+   removed, so the plugin copies are the only starting point.
 
 ## How to keep this project healthy
 
@@ -514,6 +535,7 @@ Lessons this migration paid for, worth applying beyond it:
 - **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.
+- **Touch the view-model keys only additively.** The shared `src/common`
+  renderers read them.
 - **Every promotion lands with the characterization suite green**, and every
   pilot adoption lands with that plugin's harness and golden suites green.

docs/SSH_UNAVAILABLE_AFTER_INSTALL.md

@@ -8,7 +8,7 @@ After running `first_time_install.sh`, SSH may become unavailable for the follow
 
 **Primary Cause**: The WiFi monitor service (`ledmatrix-wifi-monitor`) automatically enables Access Point (AP) mode when it detects that the Raspberry Pi is not connected to WiFi. When AP mode is active:
 
-- The Pi creates its own WiFi network: **LEDMatrix-Setup** (password: `ledmatrix123`)
+- The Pi creates its own WiFi network: **LEDMatrix-Setup** (open, no password)
 - The Pi's WiFi interface (`wlan0`) switches from client mode to AP mode
 - **This disconnects the Pi from your original WiFi network**
 - SSH becomes unavailable because the Pi is no longer on your network
@@ -45,7 +45,7 @@ If the script reboots the Pi (which it recommends), network services may restart
 
 1. **Find the AP Network**:
    - Look for a WiFi network named **LEDMatrix-Setup** on your phone/computer
-   - Default password: `ledmatrix123`
+   - It is an open network: no password
 
 2. **Connect to the AP**:
    - Connect your device to the **LEDMatrix-Setup** network
@@ -53,7 +53,7 @@ If the script reboots the Pi (which it recommends), network services may restart
 
 3. **SSH via AP Mode**:
    ```bash
-   ssh devpi@192.168.4.1
+   ssh ledpi@192.168.4.1
    ```
 
 4. **Disable AP Mode and Reconnect to WiFi**:
@@ -96,7 +96,7 @@ sudo nmcli device wifi connect "YourWiFiSSID" password "YourPassword"
 
 If your Pi is connected via Ethernet:
 - SSH should remain available via Ethernet even if WiFi is in AP mode
-- Connect via: `ssh devpi@<pi-ip-address>`
+- Connect via: `ssh ledpi@<pi-ip-address>`
 
 ### Option 4: Physical Access
 
@@ -134,14 +134,22 @@ sudo systemctl disable ledmatrix-wifi-monitor
 
 ### Method 3: Configure WiFi Monitor to Not Auto-Enable AP
 
-Edit the WiFi monitor configuration to prevent automatic AP mode:
+Turn off `auto_enable_ap_mode` so the monitor never starts AP mode on its
+own (you can still enable AP mode by hand). Either switch off
+**Auto-Enable AP Mode** in the web interface's **WiFi** tab, or use the API:
 
 ```bash
-# Edit the WiFi config (if it exists)
-nano /home/devpi/LEDMatrix/config/wifi_config.json
+curl -X POST http://<pi-ip-address>:5000/api/v3/wifi/ap/auto-enable \
+  -H "Content-Type: application/json" \
+  -d '{"auto_enable_ap_mode": false}'
+```
 
-# Or modify the WiFi monitor daemon behavior
-# (requires code changes to wifi_monitor_daemon.py)
+Or set `"auto_enable_ap_mode": false` in `config/wifi_config.json` by hand.
+The monitor daemon reads `wifi_config.json` when it starts, so whichever way
+you change the setting, restart it afterwards:
+
+```bash
+sudo systemctl restart ledmatrix-wifi-monitor
 ```
 
 ## Verification Steps
@@ -149,7 +157,7 @@ nano /home/devpi/LEDMatrix/config/wifi_config.json
 After regaining SSH access, verify your installation:
 
 ```bash
-cd /home/devpi/LEDMatrix
+cd ~/LEDMatrix   # wherever you installed LEDMatrix
 ./scripts/verify_installation.sh
 ```
 
@@ -158,9 +166,11 @@ This script will check:
 - Python dependencies
 - Configuration files
 - File permissions
-- Web interface availability
+- Web interface availability (`ledmatrix-web` listening on port 5000)
 - Network connectivity
 
+Once it passes, the web interface is at `http://<pi-ip>:5000`.
+
 ## Quick Reference Commands
 
 ```bash
@@ -223,7 +233,7 @@ different responses:
 - Prevention and tuning: [LOW_MEMORY_BOARDS.md](LOW_MEMORY_BOARDS.md)
 
 **To regain SSH**:
-1. Connect to **LEDMatrix-Setup** AP network (password: `ledmatrix123`)
+1. Connect to **LEDMatrix-Setup** AP network (open, no password)
 2. SSH to `192.168.4.1`
 3. Disable AP mode and reconnect to your WiFi network
 4. Or disable the WiFi monitor service if not needed

docs/STARLARK_APPS_GUIDE.md

@@ -127,7 +127,7 @@ Verify installation:
 3. Filter by category: Weather, Sports, Finance, Games, Clocks, etc.
 4. Click **Install** on desired apps
 5. Configure each app:
-   - Set location/timezone
+   - Set location/timezone (optional: blank uses this device's location)
    - Enter API keys if required
    - Customize display preferences
 
@@ -137,7 +137,12 @@ Each app may have different configuration options:
 
 #### Common Configuration Types
 
-- **Location** (lat/lng/timezone): For weather, clocks, transit
+- **Location** (lat/lng/timezone): For weather, clocks, transit. Left blank,
+  the app renders at this device's location (City / State / Country under
+  General settings). If no city is set there, or the city can't be looked up
+  (no match, or the geocoder is unreachable -- retried after 30 minutes), the
+  app gets no location and falls back to its author's hard-coded default,
+  usually San Francisco. Fill it in only to point one app somewhere else.
 - **API Keys**: For services like weather, stocks, sports scores
 - **Display Preferences**: Colors, units, layouts
 - **Dropdown Options**: Team selections, language, themes

docs/TROUBLESHOOTING.md

@@ -273,7 +273,7 @@ sudo systemctl cat ledmatrix-web | grep User
 1. **Verify file structure:**
    ```bash
    ls -l web_interface/app.py
-   ls -l web_interface/blueprints/api_v3.py
+   ls -ld web_interface/blueprints/api_v3/
    ls -l web_interface/blueprints/pages_v3.py
    ```
 
@@ -531,7 +531,7 @@ sudo systemctl cat ledmatrix-web | grep User
 
    ```bash
    # Clear the cache with the helper script
-   sudo python3 scripts/utils/clear_cache.py
+   sudo python3 scripts/utils/clear_cache.py --clear-all
 
    # Or remove files manually from the cache dir in use, e.g.:
    sudo rm -rf /var/cache/ledmatrix/*

docs/WEB_INTERFACE_GUIDE.md

@@ -95,7 +95,37 @@ Configure basic system settings:
   plugins
 - **Plugin System Settings** — including the `plugins_directory` (default
   `plugin-repos/`) used by the plugin loader
-- **Autostart** options for the display service
+- **Web Display Autostart** — whether the web interface service starts
+  with the system (`web_display_autostart`)
+- **Automatic updates** — once a week, update LEDMatrix and every installed
+  plugin with a newer version. Off by default. Runs 2–5 AM local time when
+  possible, otherwise within a day of being due. The last result and next
+  check are shown under the toggle, and anything other than success raises a
+  banner on **Overview**.
+  - *Checks first:* the code update is skipped, with the reason shown, if
+    tracked files were edited locally (permission-only changes and edits under
+    `plugins/` or `plugin-repos/` don't count; the pull carries those across
+    and puts them back), the checkout has local commits, a
+    rebase/merge is in progress, the branch has no upstream, less than 300 MB
+    is free, or the newest version already failed once. A failed fetch is
+    retried the next day.
+  - *Health check and rollback:* after pulling, `ledmatrix-update-verify.service`
+    restarts the services and checks that the web interface responds and the
+    display (if it was running) stays up. If not — or if the new dependencies
+    failed to install — it resets to the previous commit, reinstalls the
+    previous dependencies and restarts again. A running display is restarted;
+    a stopped one stays stopped.
+  - *Plugins* update through the Plugin Store, which refuses versions that need
+    a newer LEDMatrix and restores the old copy when an install fails. When the
+    code changed, plugins wait until it passes its health check. Plugins are
+    not health-checked after updating.
+  - *Setup needs no SSH.* Turning the toggle on restarts the display service,
+    which installs the health check (`ledmatrix-update-verify.path` and
+    `.service`); the General tab shows when it is ready, or why setup failed.
+    Until then only plugins update. New installs set it up during
+    installation and can switch updates on with
+    `first_time_install.sh --enable-auto-update` (or `LEDMATRIX_AUTO_UPDATE=1`,
+    which `one-shot-install.sh` passes through), or at the installer's prompt.
 
 Click **Save** to write changes to `config/config.json`. Most changes
 require a display service restart from **Overview**.
@@ -105,18 +135,26 @@ require a display service restart from **Overview**.
 Configure your LED matrix hardware:
 
 **Matrix configuration:**
-- `rows` — LED rows (typically 32 or 64)
-- `cols` — LED columns (typically 64 or 96)
+- `rows` — LED rows per panel (typically 32 or 64; even, at least 8 — the
+  current rgbmatrix library rejects more than 64)
+- `cols` — LED columns per panel (typically 64 or 96; at least 16)
 - `chain_length` — number of horizontally chained panels
-- `parallel` — number of parallel chains
+- `parallel` — number of parallel chains (1–3)
 - `hardware_mapping` — `adafruit-hat-pwm` (with PWM jumper mod),
-  `adafruit-hat` (without), `regular`, or `regular-pi1`
-- `gpio_slowdown` — must match your Pi model (3 for Pi 3, 4 for Pi 4, etc.)
-- `brightness` — 0–100%
+  `adafruit-hat` (without), `regular` (direct wiring, and the Adafruit Triple
+  LED Matrix Bonnet), or `regular-pi1`
+- `gpio_slowdown` — depends on your Pi and panel (roughly 1–3 on a Pi 3,
+  2–4 on a Pi 4); raise it if rows jump or the image is garbage
+- `brightness` — 1–100%
 - `pwm_bits`, `pwm_lsb_nanoseconds`, `pwm_dither_bits` — PWM tuning
 - Dynamic Duration — global cap for plugins that extend their display
   time based on content
 
+The collapsed **Advanced Hardware & Display Options** section holds
+multiplexing, panel type, row address type, scan mode, PWM tuning, the
+refresh-rate cap and hardware pulsing. Every field has a help tip, and the
+README's Display Settings section describes each one with its allowed range.
+
 **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
@@ -171,11 +209,11 @@ 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
-- Preview font changes
+**Font Preview:**
+- Render sample text in any TTF/OTF font at a chosen size
+
+Fonts used by a plugin are chosen in that plugin's own settings tab; the
+Fonts tab has no per-element override editor.
 
 **Delete Fonts:**
 - Remove unused fonts
@@ -209,7 +247,7 @@ View real-time system logs:
 ### Changing Display Brightness
 
 1. Open the **Display** tab
-2. Adjust the **Brightness** slider (0–100)
+2. Adjust the **Brightness** slider (1–100)
 3. Click **Save**
 4. Click **Restart Display Service** on the **Overview** tab
 
@@ -292,9 +330,8 @@ The web interface is built on a REST API that you can access programmatically:
 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
-base.
+The API blueprint (`web_interface/blueprints/api_v3/`) is registered at
+`/api/v3` in `web_interface/app.py`.
 
 **Common Endpoints:**
 - `GET /api/v3/config/main` — Get main configuration
@@ -392,10 +429,10 @@ The web interface uses modern web technologies:
 
 ### File Locations
 
-**Configuration:**
-- Main config: `/config/config.json`
-- Secrets: `/config/config_secrets.json`
-- WiFi config: `/config/wifi_config.json`
+**Configuration** (relative to the LEDMatrix folder, e.g. `~/LEDMatrix`):
+- Main config: `config/config.json`
+- Secrets: `config/config_secrets.json`
+- WiFi config: `config/wifi_config.json`
 
 **Logs:**
 - Display service: `sudo journalctl -u ledmatrix -f`
@@ -408,7 +445,7 @@ The web interface uses modern web technologies:
   the Plugin Store install flow and the schema loader additionally
   probe `plugins/` so dev symlinks created by
   `scripts/dev/dev_plugin_setup.sh` keep working.
-- Plugin config: `/config/config.json` (per-plugin sections)
+- Plugin config: `config/config.json` (per-plugin sections)
 
 ---
 

docs/WIFI_NETWORK_SETUP.md

@@ -21,9 +21,8 @@ The LEDMatrix WiFi system provides automatic network configuration with intellig
 
 **If not connected to WiFi:**
 1. Wait 90 seconds after boot (AP mode activation grace period)
-2. Connect to WiFi network **LEDMatrix-Setup** (default password
-   `ledmatrix123` — change it in `config/wifi_config.json` if you want
-   an open network or a different password)
+2. Connect to WiFi network **LEDMatrix-Setup** (an open network: no
+   password)
 3. Open browser to: `http://192.168.4.1:5000`
 4. Open the **WiFi** tab
 5. Scan, select your network, and connect
@@ -78,16 +77,8 @@ WiFi settings are stored in `config/wifi_config.json`:
 ```json
 {
   "ap_ssid": "LEDMatrix-Setup",
-  "ap_password": "ledmatrix123",
   "ap_channel": 7,
-  "auto_enable_ap_mode": true,
-  "saved_networks": [
-    {
-      "ssid": "YourNetwork",
-      "password": "your-password",
-      "saved_at": 1234567890.0
-    }
-  ]
+  "auto_enable_ap_mode": true
 }
 ```
 
@@ -96,10 +87,8 @@ WiFi settings are stored in `config/wifi_config.json`:
 | Setting | Default | Description |
 |---------|---------|-------------|
 | `ap_ssid` | `LEDMatrix-Setup` | Network name broadcast in AP mode |
-| `ap_password` | `ledmatrix123` | AP password. Set to `""` to make the network open (no password). |
 | `ap_channel` | `7` | WiFi channel (1, 6, or 11 are non-overlapping) |
 | `auto_enable_ap_mode` | `true` | Automatically enable AP mode when both WiFi and Ethernet are disconnected |
-| `saved_networks` | `[]` | Array of saved WiFi credentials |
 
 ### Auto-Enable AP Mode Behavior
 
@@ -214,8 +203,10 @@ The system checks connections in this order:
 ### AP Mode Settings
 
 - **SSID**: `LEDMatrix-Setup` (configurable via `ap_ssid`)
-- **Network**: WPA2, default password `ledmatrix123` (configurable via
-  `ap_password` — set to `""` for an open network)
+- **Network**: open (no password). Both AP paths create an open network
+  (`_create_hostapd_config()` and `_enable_ap_mode_nmcli_hotspot()` in
+  `src/wifi_manager.py`); an `ap_password` key in `wifi_config.json` is not
+  read
 - **IP Address**: 192.168.4.1
 - **DHCP Range**: 192.168.4.2 – 192.168.4.20
 - **Channel**: 7 (configurable via `ap_channel`)
@@ -233,16 +224,12 @@ When AP mode is active:
 
 ### Security Recommendations
 
-**1. Change AP Password (Optional):**
-```json
-{
-  "ap_password": "your-strong-password"
-}
-```
-
-**Note:** The default password is `ledmatrix123` for easy initial
-setup. Change it for any deployment in a public area, or set
-`ap_password` to `""` if you specifically want an open network.
+**1. Keep AP mode short-lived:**
+The setup network is open, so anyone nearby can join it and reach the web
+interface while it is up. AP mode only comes up when WiFi and Ethernet are
+both disconnected (after the 90 second grace period) and goes down again once
+the Pi is connected; in a public area, consider setting
+`auto_enable_ap_mode` to `false` and enabling AP mode by hand when needed.
 
 **2. Use Non-Overlapping WiFi Channels:**
 - Channels 1, 6, 11 are non-overlapping (2.4GHz)
@@ -256,21 +243,11 @@ sudo chmod 600 config/wifi_config.json
 
 ### Network Configuration Tips
 
-**Save Multiple Networks:**
-```json
-{
-  "saved_networks": [
-    {
-      "ssid": "Home-Network",
-      "password": "home-password"
-    },
-    {
-      "ssid": "Office-Network",
-      "password": "office-password"
-    }
-  ]
-}
-```
+**Multiple Networks:**
+
+NetworkManager remembers every network you connect to and rejoins whichever is
+in range; list them with `nmcli connection show`. LEDMatrix itself does not
+store WiFi passwords.
 
 **Adjust Check Interval:**
 

docs/archive/AP_MODE_MANUAL_ENABLE.md

@@ -1,159 +0,0 @@
-# AP Mode Manual Enable Configuration
-
-## Overview
-
-By default, Access Point (AP) mode is **not automatically enabled** after installation. AP mode must be manually enabled through the web interface when needed.
-
-## Default Behavior
-
-- **Auto-enable AP mode**: `false` (disabled by default)
-- AP mode will **not** automatically activate when WiFi or Ethernet disconnects
-- AP mode can only be enabled manually through the web interface
-
-## Why Manual Enable?
-
-This prevents:
-- AP mode from activating unexpectedly after installation
-- Network conflicts when Ethernet is connected
-- SSH becoming unavailable due to automatic AP mode activation
-- Unnecessary AP mode activation on systems with stable network connections
-
-## Enabling AP Mode
-
-### Via Web Interface
-
-1. Navigate to the **WiFi** tab in the web interface
-2. Click the **"Enable AP Mode"** button
-3. AP mode will activate if:
-   - WiFi is not connected AND
-   - Ethernet is not connected
-
-### Via API
-
-```bash
-# Enable AP mode
-curl -X POST http://localhost:5001/api/v3/wifi/ap/enable
-
-# Disable AP mode
-curl -X POST http://localhost:5001/api/v3/wifi/ap/disable
-```
-
-## Enabling Auto-Enable (Optional)
-
-If you want AP mode to automatically enable when WiFi/Ethernet disconnect:
-
-### Via Web Interface
-
-1. Navigate to the **WiFi** tab
-2. Look for the **"Auto-enable AP Mode"** toggle or setting
-3. Enable the toggle
-
-### Via Configuration File
-
-Edit `config/wifi_config.json`:
-
-```json
-{
-  "auto_enable_ap_mode": true,
-  ...
-}
-```
-
-Then restart the WiFi monitor service:
-
-```bash
-sudo systemctl restart ledmatrix-wifi-monitor
-```
-
-### Via API
-
-```bash
-# Get current setting
-curl http://localhost:5001/api/v3/wifi/ap/auto-enable
-
-# Set auto-enable to true
-curl -X POST http://localhost:5001/api/v3/wifi/ap/auto-enable \
-  -H "Content-Type: application/json" \
-  -d '{"auto_enable_ap_mode": true}'
-```
-
-## Behavior Summary
-
-| Auto-Enable Setting | WiFi Status | Ethernet Status | AP Mode Behavior |
-|---------------------|-------------|-----------------|------------------|
-| `false` (default) | Any | Any | Manual enable only |
-| `true` | Connected | Any | Disabled |
-| `true` | Disconnected | Connected | Disabled |
-| `true` | Disconnected | Disconnected | **Auto-enabled** |
-
-## When Auto-Enable is Disabled (Default)
-
-- AP mode **never** activates automatically
-- Must be manually enabled via web UI or API
-- Once enabled, it will automatically disable when WiFi or Ethernet connects
-- Useful for systems with stable network connections (e.g., Ethernet)
-
-## When Auto-Enable is Enabled
-
-- AP mode automatically enables when both WiFi and Ethernet disconnect
-- AP mode automatically disables when WiFi or Ethernet connects
-- Useful for portable devices that may lose network connectivity
-
-## Troubleshooting
-
-### AP Mode Not Enabling
-
-1. **Check if WiFi or Ethernet is connected**:
-   ```bash
-   nmcli device status
-   ```
-
-2. **Check auto-enable setting**:
-   ```bash
-   python3 -c "
-   from src.wifi_manager import WiFiManager
-   wm = WiFiManager()
-   print('Auto-enable:', wm.config.get('auto_enable_ap_mode', False))
-   "
-   ```
-
-3. **Manually enable AP mode**:
-   - Use web interface: WiFi tab → Enable AP Mode button
-   - Or via API: `POST /api/v3/wifi/ap/enable`
-
-### AP Mode Enabling Unexpectedly
-
-1. **Check auto-enable setting**:
-   ```bash
-   cat config/wifi_config.json | grep auto_enable_ap_mode
-   ```
-
-2. **Disable auto-enable**:
-   ```bash
-   # Edit config file
-   nano config/wifi_config.json
-   # Set "auto_enable_ap_mode": false
-   
-   # Restart service
-   sudo systemctl restart ledmatrix-wifi-monitor
-   ```
-
-3. **Check service logs**:
-   ```bash
-   sudo journalctl -u ledmatrix-wifi-monitor -f
-   ```
-
-## Migration from Old Behavior
-
-If you have an existing installation that was auto-enabling AP mode:
-
-1. The default is now `false` (manual enable)
-2. Existing configs will be updated to include `auto_enable_ap_mode: false`
-3. If you want the old behavior, set `auto_enable_ap_mode: true` in `config/wifi_config.json`
-
-## Related Documentation
-
-- [WiFi Setup Guide](WIFI_SETUP.md)
-- [SSH Unavailable After Install](SSH_UNAVAILABLE_AFTER_INSTALL.md)
-- [WiFi Ethernet AP Mode Fix](WIFI_ETHERNET_AP_MODE_FIX.md)
-

docs/archive/AP_MODE_MANUAL_ENABLE_CHANGES.md

@@ -1,186 +0,0 @@
-# AP Mode Manual Enable - Implementation Summary
-
-## Changes Made
-
-### 1. Configuration Option Added
-
-Added `auto_enable_ap_mode` configuration option to `config/wifi_config.json`:
-- **Default value**: `false` (manual enable only)
-- **Purpose**: Controls whether AP mode automatically enables when WiFi/Ethernet disconnect
-- **Migration**: Existing configs automatically get this field set to `false` if missing
-
-### 2. WiFi Manager Updates (`src/wifi_manager.py`)
-
-#### Added Configuration Field
-- Default config now includes `"auto_enable_ap_mode": False`
-- Existing configs are automatically migrated to include this field
-
-#### Updated `check_and_manage_ap_mode()` Method
-- Now checks `auto_enable_ap_mode` setting before auto-enabling AP mode
-- AP mode only auto-enables if:
-  - `auto_enable_ap_mode` is `true` AND
-  - WiFi is NOT connected AND
-  - Ethernet is NOT connected
-- AP mode still auto-disables when WiFi or Ethernet connects (regardless of setting)
-- Manual AP mode (via web UI) works regardless of this setting
-
-### 3. Web Interface API Updates (`web_interface/blueprints/api_v3.py`)
-
-#### Updated `/wifi/status` Endpoint
-- Now returns `auto_enable_ap_mode` setting in response
-
-#### Added `/wifi/ap/auto-enable` GET Endpoint
-- Returns current `auto_enable_ap_mode` setting
-
-#### Added `/wifi/ap/auto-enable` POST Endpoint
-- Allows setting `auto_enable_ap_mode` via API
-- Accepts JSON: `{"auto_enable_ap_mode": true/false}`
-
-### 4. Documentation Updates
-
-- Updated `docs/WIFI_SETUP.md` with new configuration option
-- Created `docs/AP_MODE_MANUAL_ENABLE.md` with comprehensive guide
-- Created `docs/AP_MODE_MANUAL_ENABLE_CHANGES.md` (this file)
-
-## Behavior Changes
-
-### Before
-- AP mode automatically enabled when WiFi disconnected (if Ethernet also disconnected)
-- Could cause SSH to become unavailable after installation
-- No way to disable auto-enable behavior
-
-### After
-- AP mode **does not** automatically enable by default
-- Must be manually enabled through web UI or API
-- Can optionally enable auto-enable via configuration
-- Prevents unexpected AP mode activation
-
-## Migration
-
-### Existing Installations
-
-1. **Automatic Migration**:
-   - When WiFi manager loads config, it automatically adds `auto_enable_ap_mode: false` if missing
-   - No manual intervention required
-
-2. **To Enable Auto-Enable** (if desired):
-   ```bash
-   # Edit config file
-   nano config/wifi_config.json
-   # Set "auto_enable_ap_mode": true
-   
-   # Restart WiFi monitor service
-   sudo systemctl restart ledmatrix-wifi-monitor
-   ```
-
-### New Installations
-
-- Default behavior is manual enable only
-- No changes needed
-
-## Testing
-
-### Verify Default Behavior
-
-```bash
-# Check config
-python3 -c "
-from src.wifi_manager import WiFiManager
-wm = WiFiManager()
-print('Auto-enable:', wm.config.get('auto_enable_ap_mode', False))
-"
-# Should output: Auto-enable: False
-```
-
-### Test Manual Enable
-
-1. Disconnect WiFi and Ethernet
-2. AP mode should **not** automatically enable
-3. Enable via web UI: WiFi tab → Enable AP Mode
-4. AP mode should activate
-5. Connect WiFi or Ethernet
-6. AP mode should automatically disable
-
-### Test Auto-Enable (if enabled)
-
-1. Set `auto_enable_ap_mode: true` in config
-2. Restart WiFi monitor service
-3. Disconnect WiFi and Ethernet
-4. AP mode should automatically enable within 30 seconds
-5. Connect WiFi or Ethernet
-6. AP mode should automatically disable
-
-## API Usage Examples
-
-### Get Auto-Enable Setting
-```bash
-curl http://localhost:5001/api/v3/wifi/ap/auto-enable
-```
-
-### Set Auto-Enable to True
-```bash
-curl -X POST http://localhost:5001/api/v3/wifi/ap/auto-enable \
-  -H "Content-Type: application/json" \
-  -d '{"auto_enable_ap_mode": true}'
-```
-
-### Set Auto-Enable to False
-```bash
-curl -X POST http://localhost:5001/api/v3/wifi/ap/auto-enable \
-  -H "Content-Type: application/json" \
-  -d '{"auto_enable_ap_mode": false}'
-```
-
-### Get WiFi Status (includes auto-enable)
-```bash
-curl http://localhost:5001/api/v3/wifi/status
-```
-
-## Files Modified
-
-1. `src/wifi_manager.py`
-   - Added `auto_enable_ap_mode` to default config
-   - Added migration logic for existing configs
-   - Updated `check_and_manage_ap_mode()` to respect setting
-
-2. `web_interface/blueprints/api_v3.py`
-   - Updated `/wifi/status` to include auto-enable setting
-   - Added `/wifi/ap/auto-enable` GET endpoint
-   - Added `/wifi/ap/auto-enable` POST endpoint
-
-3. `docs/WIFI_SETUP.md`
-   - Updated documentation with new configuration option
-   - Updated WiFi monitor daemon description
-
-4. `docs/AP_MODE_MANUAL_ENABLE.md` (new)
-   - Comprehensive guide for manual enable feature
-
-## Benefits
-
-1. **Prevents SSH Loss**: AP mode won't activate automatically after installation
-2. **User Control**: Users can choose whether to enable auto-enable
-3. **Ethernet-Friendly**: Works well with hardwired connections
-4. **Backward Compatible**: Existing installations automatically migrate
-5. **Flexible**: Can still enable auto-enable if desired
-
-## Deployment
-
-### On Existing Installations
-
-1. **No action required** - automatic migration on next WiFi manager initialization
-2. **Restart WiFi monitor** (optional, to apply immediately):
-   ```bash
-   sudo systemctl restart ledmatrix-wifi-monitor
-   ```
-
-### On New Installations
-
-- Default behavior is already manual enable
-- No additional configuration needed
-
-## Related Issues Fixed
-
-- SSH becoming unavailable after installation
-- AP mode activating when Ethernet is connected
-- Unexpected AP mode activation on stable network connections
-

docs/archive/BACKGROUND_SERVICE_README.md

@@ -1,208 +0,0 @@
-# Background Data Service for LEDMatrix
-
-## Overview
-
-The Background Data Service is a new feature that implements background threading for season data fetching to prevent blocking the main display loop. This significantly improves responsiveness and user experience during data fetching operations.
-
-## Key Benefits
-
-- **Non-blocking**: Season data fetching no longer blocks the main display loop
-- **Immediate Response**: Returns cached or partial data immediately while fetching complete data in background
-- **Configurable**: Can be enabled/disabled per sport with customizable settings
-- **Thread-safe**: Uses proper synchronization for concurrent access
-- **Retry Logic**: Automatic retry with exponential backoff for failed requests
-- **Progress Tracking**: Comprehensive logging and statistics
-
-## Architecture
-
-### Core Components
-
-1. **BackgroundDataService**: Main service class managing background threads
-2. **FetchRequest**: Represents individual fetch operations
-3. **FetchResult**: Contains results of fetch operations
-4. **Sport Managers**: Updated to use background service
-
-### How It Works
-
-1. **Cache Check**: First checks for cached data and returns immediately if available
-2. **Background Fetch**: If no cache, starts background thread to fetch complete season data
-3. **Partial Data**: Returns immediate partial data (current/recent games) for quick display
-4. **Completion**: Background fetch completes and caches full dataset
-5. **Future Requests**: Subsequent requests use cached data for instant response
-
-## Configuration
-
-### NFL Configuration Example
-
-```json
-{
-    "nfl_scoreboard": {
-        "enabled": true,
-        "background_service": {
-            "enabled": true,
-            "max_workers": 3,
-            "request_timeout": 30,
-            "max_retries": 3,
-            "priority": 2
-        }
-    }
-}
-```
-
-### Configuration Options
-
-- **enabled**: Enable/disable background service (default: true)
-- **max_workers**: Maximum number of background threads (default: 3)
-- **request_timeout**: HTTP request timeout in seconds (default: 30)
-- **max_retries**: Maximum retry attempts for failed requests (default: 3)
-- **priority**: Request priority (higher = more important, default: 2)
-
-## Implementation Status
-
-### Phase 1: Background Season Data Fetching ✅ COMPLETED
-
-- [x] Created BackgroundDataService class
-- [x] Implemented thread-safe data caching
-- [x] Added retry logic with exponential backoff
-- [x] Modified NFL manager to use background service
-- [x] Added configuration support
-- [x] Created test script
-
-### Phase 2: Rollout to Other Sports (Next Steps)
-
-- [ ] Apply to NCAAFB manager
-- [ ] Apply to NBA manager
-- [ ] Apply to NHL manager
-- [ ] Apply to MLB manager
-- [ ] Apply to other sport managers
-
-## Testing
-
-### Test Script
-
-Run the test script to verify background service functionality:
-
-```bash
-python test_background_service.py
-```
-
-### Test Scenarios
-
-1. **Cache Hit**: Verify immediate return of cached data
-2. **Background Fetch**: Verify non-blocking background data fetching
-3. **Partial Data**: Verify immediate return of partial data during background fetch
-4. **Completion**: Verify background fetch completion and caching
-5. **Subsequent Requests**: Verify cache usage for subsequent requests
-6. **Service Disabled**: Verify fallback to synchronous fetching
-
-### Expected Results
-
-- Initial fetch should return partial data immediately (< 1 second)
-- Background fetch should complete within 10-30 seconds
-- Subsequent fetches should use cache (< 0.1 seconds)
-- No blocking of main display loop
-
-## Performance Impact
-
-### Before Background Service
-- Season data fetch: 10-30 seconds (blocking)
-- Display loop: Frozen during fetch
-- User experience: Poor responsiveness
-
-### After Background Service
-- Initial response: < 1 second (partial data)
-- Background fetch: 10-30 seconds (non-blocking)
-- Display loop: Continues normally
-- User experience: Excellent responsiveness
-
-## Monitoring
-
-### Logs
-
-The service provides comprehensive logging:
-
-```
-[NFL] Background service enabled with 3 workers
-[NFL] Starting background fetch for 2024 season schedule...
-[NFL] Using 15 immediate events while background fetch completes
-[NFL] Background fetch completed for 2024: 256 events
-```
-
-### Statistics
-
-Access service statistics:
-
-```python
-stats = background_service.get_statistics()
-print(f"Total requests: {stats['total_requests']}")
-print(f"Cache hits: {stats['cached_hits']}")
-print(f"Average fetch time: {stats['average_fetch_time']:.2f}s")
-```
-
-## Error Handling
-
-### Automatic Retry
-- Failed requests are automatically retried with exponential backoff
-- Maximum retry attempts are configurable
-- Failed requests are logged with error details
-
-### Fallback Behavior
-- If background service is disabled, falls back to synchronous fetching
-- If background fetch fails, returns partial data if available
-- Graceful degradation ensures system continues to function
-
-## Future Enhancements
-
-### Phase 2 Features
-- Apply to all sport managers
-- Priority-based request queuing
-- Dynamic worker scaling
-- Request batching for efficiency
-
-### Phase 3 Features
-- Real-time data streaming
-- WebSocket support for live updates
-- Advanced caching strategies
-- Performance analytics dashboard
-
-## Troubleshooting
-
-### Common Issues
-
-1. **Background service not starting**
-   - Check configuration: `background_service.enabled = true`
-   - Verify cache manager is properly initialized
-   - Check logs for initialization errors
-
-2. **Slow background fetches**
-   - Increase `request_timeout` in configuration
-   - Check network connectivity
-   - Monitor API rate limits
-
-3. **Memory usage**
-   - Background service automatically cleans up old requests
-   - Adjust `max_workers` if needed
-   - Monitor cache size
-
-### Debug Mode
-
-Enable debug logging for detailed information:
-
-```python
-logging.getLogger('src.background_data_service').setLevel(logging.DEBUG)
-```
-
-## Contributing
-
-When adding background service support to new sport managers:
-
-1. Import the background service
-2. Initialize in `__init__` method
-3. Update data fetching method to use background service
-4. Add configuration options
-5. Test thoroughly
-6. Update documentation
-
-## License
-
-This feature is part of the LEDMatrix project and follows the same license terms.

docs/archive/BROWSER_ERRORS_EXPLANATION.md

@@ -1,136 +0,0 @@
-# Browser Console Errors - Explanation
-
-## Summary
-
-**You don't need to worry about these errors.** They are harmless and don't affect functionality. We've improved error suppression to hide them from the console.
-
-## Error Types
-
-### 1. Permissions-Policy Header Warnings
-
-**Examples:**
-```text
-Error with Permissions-Policy header: Unrecognized feature: 'browsing-topics'.
-Error with Permissions-Policy header: Unrecognized feature: 'run-ad-auction'.
-Error with Permissions-Policy header: Origin trial controlled feature not enabled: 'join-ad-interest-group'.
-```
-
-**What they are:**
-- Browser warnings about experimental/advertising features in HTTP headers
-- These features are not used by our application
-- The browser is just informing you that it doesn't recognize these policy features
-
-**Why they appear:**
-- Some browsers or extensions set these headers
-- They're informational warnings, not actual errors
-- They don't affect functionality at all
-
-**Status:** ✅ **Harmless** - Now suppressed in console
-
-### 2. HTMX insertBefore Errors
-
-**Example:**
-```javascript
-TypeError: Cannot read properties of null (reading 'insertBefore')
-    at At (htmx.org@1.9.10:1:22924)
-```
-
-**What they are:**
-- HTMX library timing/race condition issues
-- Occurs when HTMX tries to swap content but the target element is temporarily null
-- Usually happens during rapid content updates or when elements are being removed/added
-
-**Why they appear:**
-- HTMX dynamically swaps HTML content
-- Sometimes the target element is removed or not yet in the DOM when HTMX tries to insert
-- This is a known issue with HTMX in certain scenarios
-
-**Impact:**
-- ✅ **No functional impact** - HTMX handles these gracefully
-- ✅ **Content still loads correctly** - The swap just fails silently and retries
-- ✅ **User experience unaffected** - Users don't see any issues
-
-**Status:** ✅ **Harmless** - Now suppressed in console
-
-## What We've Done
-
-### Error Suppression Improvements
-
-1. **Enhanced HTMX Error Suppression:**
-   - More comprehensive detection of HTMX-related errors
-   - Catches `insertBefore` errors from HTMX regardless of format
-   - Suppresses timing/race condition errors
-
-2. **Permissions-Policy Warning Suppression:**
-   - Suppresses all Permissions-Policy header warnings
-   - Includes specific feature warnings (browsing-topics, run-ad-auction, etc.)
-   - Prevents console noise from harmless browser warnings
-
-3. **HTMX Validation:**
-   - Added `htmx:beforeSwap` validation to prevent some errors
-   - Checks if target element exists before swapping
-   - Reduces but doesn't eliminate all timing issues
-
-## When to Worry
-
-You should only be concerned about errors if:
-
-1. **Functionality is broken** - If buttons don't work, forms don't submit, or content doesn't load
-2. **Errors are from your code** - Errors in `plugins.html`, `base.html`, or other application files
-3. **Network errors** - Failed API calls or connection issues
-4. **User-visible issues** - Users report problems
-
-## Current Status
-
-✅ **All harmless errors are now suppressed**
-✅ **HTMX errors are caught and handled gracefully**
-✅ **Permissions-Policy warnings are hidden**
-✅ **Application functionality is unaffected**
-
-## Technical Details
-
-### HTMX insertBefore Errors
-
-**Root Cause:**
-- HTMX uses `insertBefore` to swap content into the DOM
-- Sometimes the parent node is null when HTMX tries to insert
-- This happens due to:
-  - Race conditions during rapid updates
-  - Elements being removed before swap completes
-  - Dynamic content loading timing issues
-
-**Why It's Safe:**
-- HTMX has built-in error handling
-- Failed swaps don't break the application
-- Content still loads via other mechanisms
-- No data loss or corruption
-
-### Permissions-Policy Warnings
-
-**Root Cause:**
-- Modern browsers support Permissions-Policy HTTP headers
-- Some features are experimental or not widely supported
-- Browsers warn when they encounter unrecognized features
-
-**Why It's Safe:**
-- We don't use these features
-- The warnings are informational only
-- No security or functionality impact
-
-## Monitoring
-
-If you want to see actual errors (not suppressed ones), you can:
-
-1. **Temporarily disable suppression:**
-   - Comment out the error suppression code in `base.html`
-   - Only do this for debugging
-
-2. **Check browser DevTools:**
-   - Look for errors in the Network tab (actual failures)
-   - Check Console for non-HTMX errors
-   - Monitor user reports for functionality issues
-
-## Conclusion
-
-**These errors are completely harmless and can be safely ignored.** They're just noise in the console that doesn't affect the application's functionality. We've improved the error suppression to hide them so you can focus on actual issues if they arise.
-

docs/archive/CAPTIVE_PORTAL_TESTING.md

@@ -1,445 +0,0 @@
-# Captive Portal Testing Guide
-
-This guide explains how to test the captive portal WiFi setup functionality.
-
-## Prerequisites
-
-1. **Raspberry Pi with LEDMatrix installed**
-2. **WiFi adapter** (built-in or USB)
-3. **Test devices** (smartphone, tablet, or laptop)
-4. **Access to Pi** (SSH or direct access)
-
-## Important: Before Testing
-
-**⚠️ Make sure you have a way to reconnect!**
-
-Before starting testing, ensure you have:
-- **Ethernet cable** (if available) as backup connection
-- **SSH access** via another method (Ethernet, direct connection)
-- **Physical access** to Pi (keyboard/monitor) as last resort
-- **Your WiFi credentials** saved/noted down
-
-**If testing fails, see:** [Reconnecting After Testing](RECONNECT_AFTER_CAPTIVE_PORTAL_TESTING.md)
-
-**Quick recovery script:** `sudo ./scripts/emergency_reconnect.sh`
-
-## Pre-Testing Setup
-
-### 0. Verify WiFi is Ready (IMPORTANT!)
-
-**⚠️ CRITICAL: Run this BEFORE disconnecting Ethernet!**
-
-```bash
-sudo ./scripts/verify_wifi_before_testing.sh
-```
-
-This script will verify:
-- WiFi interface exists and is enabled
-- WiFi can scan for networks
-- You have saved WiFi connections (for reconnecting)
-- Required services are ready
-- Current network status
-
-**Do NOT disconnect Ethernet until this script passes all checks!**
-
-### 1. Ensure WiFi Monitor Service is Running
-
-```bash
-sudo systemctl status ledmatrix-wifi-monitor
-```
-
-If not running:
-```bash
-sudo systemctl start ledmatrix-wifi-monitor
-sudo systemctl enable ledmatrix-wifi-monitor
-```
-
-### 2. Disconnect Pi from WiFi/Ethernet
-
-**⚠️ Only do this AFTER running the verification script!**
-
-To test captive portal, the Pi should NOT be connected to any network:
-
-```bash
-# First, verify WiFi is ready (see step 0 above)
-sudo ./scripts/verify_wifi_before_testing.sh
-
-# Check current network status
-nmcli device status
-
-# Disconnect WiFi (if connected)
-sudo nmcli device disconnect wlan0
-
-# Disconnect Ethernet (if connected)
-# Option 1: Unplug Ethernet cable (safest)
-# Option 2: Via command (if you're sure WiFi works):
-sudo nmcli device disconnect eth0
-
-# Verify disconnection
-nmcli device status
-# Both should show "disconnected" or "unavailable"
-```
-
-### 3. Enable AP Mode
-
-You can enable AP mode manually or wait for it to auto-enable (if `auto_enable_ap_mode` is true):
-
-**Manual enable via web interface:**
-- Access web interface at `http://<pi-ip>:5000` (if still accessible)
-- Go to WiFi tab
-- Click "Enable AP Mode"
-
-**Manual enable via command line:**
-```bash
-python3 -c "from src.wifi_manager import WiFiManager; wm = WiFiManager(); print(wm.enable_ap_mode())"
-```
-
-**Or via API:**
-```bash
-curl -X POST http://localhost:5000/api/v3/wifi/ap/enable
-```
-
-### 4. Verify AP Mode is Active
-
-```bash
-# Check hostapd service
-sudo systemctl status hostapd
-
-# Check dnsmasq service
-sudo systemctl status dnsmasq
-
-# Check if wlan0 is in AP mode
-iwconfig wlan0
-# Should show "Mode:Master"
-
-# Check IP address
-ip addr show wlan0
-# Should show 192.168.4.1
-```
-
-### 5. Verify DNSMASQ Configuration
-
-```bash
-# Check dnsmasq config
-sudo cat /etc/dnsmasq.conf
-
-# Should contain:
-# - address=/#/192.168.4.1
-# - address=/captive.apple.com/192.168.4.1
-# - address=/connectivitycheck.gstatic.com/192.168.4.1
-# - address=/www.msftconnecttest.com/192.168.4.1
-# - address=/detectportal.firefox.com/192.168.4.1
-```
-
-### 6. Verify Web Interface is Running
-
-```bash
-# Check if web service is running
-sudo systemctl status ledmatrix-web
-
-# Or check if Flask app is running
-ps aux | grep "web_interface"
-```
-
-## Testing Procedures
-
-### Test 1: DNS Redirection
-
-**Purpose:** Verify that DNS queries are redirected to the Pi.
-
-**Steps:**
-1. Connect a device to "LEDMatrix-Setup" network (password: `ledmatrix123`)
-2. Try to resolve any domain name:
-   ```bash
-   # On Linux/Mac
-   nslookup google.com
-   # Should return 192.168.4.1
-   
-   # On Windows
-   nslookup google.com
-   # Should return 192.168.4.1
-   ```
-
-**Expected Result:** All DNS queries should resolve to 192.168.4.1
-
-### Test 2: HTTP Redirect (Manual Browser Test)
-
-**Purpose:** Verify that HTTP requests redirect to WiFi setup page.
-
-**Steps:**
-1. Connect device to "LEDMatrix-Setup" network
-2. Open a web browser
-3. Try to access any website:
-   - `http://google.com`
-   - `http://example.com`
-   - `http://192.168.4.1` (direct IP)
-
-**Expected Result:** All requests should redirect to `http://192.168.4.1:5000/v3` (WiFi setup interface)
-
-### Test 3: Captive Portal Detection Endpoints
-
-**Purpose:** Verify that device detection endpoints respond correctly.
-
-**Test each endpoint:**
-
-```bash
-# iOS/macOS detection
-curl http://192.168.4.1:5000/hotspot-detect.html
-# Expected: HTML response with "Success"
-
-# Android detection
-curl -I http://192.168.4.1:5000/generate_204
-# Expected: HTTP 204 No Content
-
-# Windows detection
-curl http://192.168.4.1:5000/connecttest.txt
-# Expected: "Microsoft Connect Test"
-
-# Firefox detection
-curl http://192.168.4.1:5000/success.txt
-# Expected: "success"
-```
-
-**Expected Result:** Each endpoint should return the appropriate response
-
-### Test 4: iOS Device (iPhone/iPad)
-
-**Purpose:** Test automatic captive portal detection on iOS.
-
-**Steps:**
-1. On iPhone/iPad, go to Settings > Wi-Fi
-2. Connect to "LEDMatrix-Setup" network
-3. Enter password: `ledmatrix123`
-4. Wait a few seconds
-
-**Expected Result:**
-- iOS should automatically detect the captive portal
-- A popup should appear saying "Sign in to Network" or similar
-- Tapping it should open Safari with the WiFi setup page
-- The setup page should show the captive portal banner
-
-**If it doesn't auto-open:**
-- Open Safari manually
-- Try to visit any website (e.g., apple.com)
-- Should redirect to WiFi setup page
-
-### Test 5: Android Device
-
-**Purpose:** Test automatic captive portal detection on Android.
-
-**Steps:**
-1. On Android device, go to Settings > Wi-Fi
-2. Connect to "LEDMatrix-Setup" network
-3. Enter password: `ledmatrix123`
-4. Wait a few seconds
-
-**Expected Result:**
-- Android should show a notification: "Sign in to network" or "Network sign-in required"
-- Tapping the notification should open a browser with the WiFi setup page
-- The setup page should show the captive portal banner
-
-**If notification doesn't appear:**
-- Open Chrome browser
-- Try to visit any website
-- Should redirect to WiFi setup page
-
-### Test 6: Windows Laptop
-
-**Purpose:** Test captive portal on Windows.
-
-**Steps:**
-1. Connect Windows laptop to "LEDMatrix-Setup" network
-2. Enter password: `ledmatrix123`
-3. Wait a few seconds
-
-**Expected Result:**
-- Windows may show a notification about network sign-in
-- Opening any browser and visiting any website should redirect to WiFi setup page
-- Edge/Chrome may automatically open a sign-in window
-
-**Manual test:**
-- Open any browser
-- Visit `http://www.msftconnecttest.com` or any website
-- Should redirect to WiFi setup page
-
-### Test 7: API Endpoints Still Work
-
-**Purpose:** Verify that WiFi API endpoints function normally during AP mode.
-
-**Steps:**
-1. While connected to "LEDMatrix-Setup" network
-2. Test API endpoints:
-
-```bash
-# Status endpoint
-curl http://192.168.4.1:5000/api/v3/wifi/status
-
-# Scan networks
-curl http://192.168.4.1:5000/api/v3/wifi/scan
-```
-
-**Expected Result:** API endpoints should return JSON responses normally (not redirect)
-
-### Test 8: WiFi Connection Flow
-
-**Purpose:** Test the complete flow of connecting to WiFi via captive portal.
-
-**Steps:**
-1. Connect device to "LEDMatrix-Setup" network
-2. Wait for captive portal to redirect to setup page
-3. Click "Scan" to find available networks
-4. Select a network from the list
-5. Enter WiFi password
-6. Click "Connect"
-7. Wait for connection to establish
-
-**Expected Result:**
-- Device should connect to selected WiFi network
-- AP mode should automatically disable
-- Device should now be on the new network
-- Can access Pi via new network IP address
-
-## Troubleshooting
-
-### Issue: DNS Not Redirecting
-
-**Symptoms:** DNS queries resolve to actual IPs, not 192.168.4.1
-
-**Solutions:**
-1. Check dnsmasq config:
-   ```bash
-   sudo cat /etc/dnsmasq.conf | grep address
-   ```
-2. Restart dnsmasq:
-   ```bash
-   sudo systemctl restart dnsmasq
-   ```
-3. Check dnsmasq logs:
-   ```bash
-   sudo journalctl -u dnsmasq -n 50
-   ```
-
-### Issue: HTTP Not Redirecting
-
-**Symptoms:** Browser shows actual websites instead of redirecting
-
-**Solutions:**
-1. Check if AP mode is active:
-   ```bash
-   python3 -c "from src.wifi_manager import WiFiManager; wm = WiFiManager(); print(wm._is_ap_mode_active())"
-   ```
-2. Check Flask app logs for errors
-3. Verify web interface is running on port 5000
-4. Test redirect middleware manually:
-   ```bash
-   curl -I http://192.168.4.1:5000/google.com
-   # Should return 302 redirect
-   ```
-
-### Issue: Captive Portal Not Detected by Device
-
-**Symptoms:** Device doesn't show sign-in notification/popup
-
-**Solutions:**
-1. Verify detection endpoints are accessible:
-   ```bash
-   curl http://192.168.4.1:5000/hotspot-detect.html
-   curl http://192.168.4.1:5000/generate_204
-   ```
-2. Try manually opening browser and visiting any website
-3. Some devices require specific responses - check endpoint implementations
-4. Clear device's network settings and reconnect
-
-### Issue: Infinite Redirect Loop
-
-**Symptoms:** Browser keeps redirecting in a loop
-
-**Solutions:**
-1. Check that `/v3` path is in allowed_paths list
-2. Verify redirect middleware logic in `app.py`
-3. Check Flask logs for errors
-4. Ensure WiFi API endpoints are not being redirected
-
-### Issue: AP Mode Not Enabling
-
-**Symptoms:** Can't connect to "LEDMatrix-Setup" network
-
-**Solutions:**
-1. Check WiFi monitor service:
-   ```bash
-   sudo systemctl status ledmatrix-wifi-monitor
-   ```
-2. Check WiFi config:
-   ```bash
-   cat config/wifi_config.json
-   ```
-3. Manually enable AP mode:
-   ```bash
-   python3 -c "from src.wifi_manager import WiFiManager; wm = WiFiManager(); print(wm.enable_ap_mode())"
-   ```
-4. Check hostapd logs:
-   ```bash
-   sudo journalctl -u hostapd -n 50
-   ```
-
-## Verification Checklist
-
-- [ ] DNS redirection works (all domains resolve to 192.168.4.1)
-- [ ] HTTP redirect works (all websites redirect to setup page)
-- [ ] Captive portal detection endpoints respond correctly
-- [ ] iOS device auto-opens setup page
-- [ ] Android device shows sign-in notification
-- [ ] Windows device redirects to setup page
-- [ ] WiFi API endpoints still work during AP mode
-- [ ] Can successfully connect to WiFi via setup page
-- [ ] AP mode disables after WiFi connection
-- [ ] No infinite redirect loops
-- [ ] Captive portal banner appears on setup page when AP mode is active
-
-## Quick Test Script
-
-Save this as `test_captive_portal.sh`:
-
-```bash
-#!/bin/bash
-
-echo "Testing Captive Portal Functionality"
-echo "===================================="
-
-# Test DNS redirection
-echo -e "\n1. Testing DNS redirection..."
-nslookup google.com | grep -q "192.168.4.1" && echo "✓ DNS redirection works" || echo "✗ DNS redirection failed"
-
-# Test HTTP redirect
-echo -e "\n2. Testing HTTP redirect..."
-HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" -L http://192.168.4.1:5000/google.com)
-[ "$HTTP_CODE" = "200" ] && echo "✓ HTTP redirect works" || echo "✗ HTTP redirect failed (got $HTTP_CODE)"
-
-# Test detection endpoints
-echo -e "\n3. Testing captive portal detection endpoints..."
-curl -s http://192.168.4.1:5000/hotspot-detect.html | grep -q "Success" && echo "✓ iOS endpoint works" || echo "✗ iOS endpoint failed"
-curl -s -o /dev/null -w "%{http_code}" http://192.168.4.1:5000/generate_204 | grep -q "204" && echo "✓ Android endpoint works" || echo "✗ Android endpoint failed"
-curl -s http://192.168.4.1:5000/connecttest.txt | grep -q "Microsoft" && echo "✓ Windows endpoint works" || echo "✗ Windows endpoint failed"
-curl -s http://192.168.4.1:5000/success.txt | grep -q "success" && echo "✓ Firefox endpoint works" || echo "✗ Firefox endpoint failed"
-
-# Test API endpoints
-echo -e "\n4. Testing API endpoints..."
-API_RESPONSE=$(curl -s http://192.168.4.1:5000/api/v3/wifi/status)
-echo "$API_RESPONSE" | grep -q "status" && echo "✓ API endpoints work" || echo "✗ API endpoints failed"
-
-echo -e "\nTesting complete!"
-```
-
-Make it executable and run:
-```bash
-chmod +x test_captive_portal.sh
-./test_captive_portal.sh
-```
-
-## Notes
-
-- **Port Number:** The web interface runs on port 5000 by default. If you've changed this, update all URLs accordingly.
-- **Network Range:** The AP uses 192.168.4.0/24 network. If you need a different range, update both hostapd and dnsmasq configs.
-- **Password:** Default AP password is `ledmatrix123`. Change it in `config/wifi_config.json` if needed.
-- **Testing on Same Device:** If testing from the Pi itself, you'll need a second device to connect to the AP network.
-

docs/archive/CAPTIVE_PORTAL_TROUBLESHOOTING.md

@@ -1,172 +0,0 @@
-# Captive Portal Troubleshooting Guide
-
-## Problem: Can't Access Web Interface When Connected to AP
-
-If you've connected to the "LEDMatrix-Setup" WiFi network but can't access the web interface, follow these steps:
-
-## Quick Checks
-
-### 1. Verify Web Server is Running
-
-```bash
-sudo systemctl status ledmatrix-web
-```
-
-If not running:
-```bash
-sudo systemctl start ledmatrix-web
-sudo systemctl enable ledmatrix-web
-```
-
-### 2. Try Direct IP Access
-
-On your phone/device, try accessing the web interface directly:
-- **http://192.168.4.1:5000/v3**
-- **http://192.168.4.1:5000**
-
-The port `:5000` is required - the web server runs on port 5000, not the standard port 80.
-
-### 3. Check DNS Resolution
-
-The captive portal uses DNS redirection. Try accessing:
-- **http://captive.apple.com** (should redirect to setup page)
-- **http://www.google.com** (should redirect to setup page)
-- **http://192.168.4.1:5000** (direct access - should always work)
-
-### 4. Verify AP Mode is Active
-
-```bash
-sudo systemctl status hostapd
-sudo systemctl status dnsmasq
-ip addr show wlan0 | grep 192.168.4.1
-```
-
-All should be active/running.
-
-### 5. Check Firewall
-
-If you have a firewall enabled, ensure port 5000 is open:
-
-```bash
-# For UFW
-sudo ufw allow 5000/tcp
-
-# For iptables
-sudo iptables -A INPUT -p tcp --dport 5000 -j ACCEPT
-```
-
-## Common Issues
-
-### Issue: "Can't connect to server" or "Connection refused"
-
-**Cause**: Web server not running or not listening on the correct interface.
-
-**Solution**:
-```bash
-sudo systemctl start ledmatrix-web
-sudo systemctl status ledmatrix-web
-```
-
-### Issue: DNS not resolving / "Server not found"
-
-**Cause**: dnsmasq not running or DNS redirection not configured.
-
-**Solution**:
-```bash
-# Check dnsmasq
-sudo systemctl status dnsmasq
-
-# Restart AP mode
-cd ~/LEDMatrix
-python3 -c "from src.wifi_manager import WiFiManager; wm = WiFiManager(); wm.disable_ap_mode(); wm.enable_ap_mode()"
-```
-
-### Issue: Page loads but shows "Connection Error" or blank page
-
-**Cause**: Web server is running but Flask app has errors.
-
-**Solution**:
-```bash
-# Check web server logs
-sudo journalctl -u ledmatrix-web -n 50 --no-pager
-
-# Restart web server
-sudo systemctl restart ledmatrix-web
-```
-
-### Issue: Phone connects but browser doesn't open automatically
-
-**Cause**: Some devices don't automatically detect captive portals.
-
-**Solution**: Manually open browser and go to:
-- **http://192.168.4.1:5000/v3**
-- Or try: **http://captive.apple.com** (iOS) or **http://www.google.com** (Android)
-
-## Testing Steps
-
-1. **Disconnect Ethernet** from Pi
-2. **Wait 30 seconds** for AP mode to start
-3. **Connect phone** to "LEDMatrix-Setup" network (password: `ledmatrix123`)
-4. **Open browser** on phone
-5. **Try these URLs**:
-   - `http://192.168.4.1:5000/v3` (direct access)
-   - `http://captive.apple.com` (iOS captive portal detection)
-   - `http://www.google.com` (should redirect)
-
-## Automated Troubleshooting
-
-Run the troubleshooting script:
-
-```bash
-cd ~/LEDMatrix
-./scripts/troubleshoot_captive_portal.sh
-```
-
-This will check all components and provide specific fixes.
-
-## Manual AP Mode Test
-
-To manually test AP mode (bypassing Ethernet check):
-
-```bash
-cd ~/LEDMatrix
-python3 -c "
-from src.wifi_manager import WiFiManager
-wm = WiFiManager()
-
-# Temporarily disconnect Ethernet check
-# (This is for testing only - normally AP won't start with Ethernet)
-print('Enabling AP mode...')
-result = wm.enable_ap_mode()
-print('Result:', result)
-"
-```
-
-**Note**: This will fail if Ethernet is connected (by design). You must disconnect Ethernet first.
-
-## Still Not Working?
-
-1. **Check all services**:
-   ```bash
-   sudo systemctl status ledmatrix-web hostapd dnsmasq ledmatrix-wifi-monitor
-   ```
-
-2. **Check logs**:
-   ```bash
-   sudo journalctl -u ledmatrix-web -f
-   sudo journalctl -u ledmatrix-wifi-monitor -f
-   ```
-
-3. **Verify network configuration**:
-   ```bash
-   ip addr show wlan0
-   ip route show
-   ```
-
-4. **Test from Pi itself**:
-   ```bash
-   curl http://192.168.4.1:5000/v3
-   ```
-
-If it works from the Pi but not from your phone, it's likely a DNS or firewall issue.
-

docs/archive/CURSOR_PLUGIN_SCHEMA_AUDIT_PLAN.md

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

docs/archive/DEBUG_WEB_ISSUE.md

@@ -1,75 +0,0 @@
-# Debug: Service Deactivated After Installing Dependencies
-
-## What Happened
-
-The service:
-1. ✅ Started successfully
-2. ✅ Installed dependencies
-3. ❌ Deactivated successfully (exited cleanly)
-
-This means it finished running but didn't actually launch the Flask app.
-
-## Most Likely Cause
-
-**`web_display_autostart` is probably set to `false` in your config.json**
-
-The service is designed to exit gracefully if this is false - it won't even try to start Flask.
-
-## Commands to Run RIGHT NOW
-
-### 1. Check the full logs to see what it said before exiting:
-```bash
-sudo journalctl -u ledmatrix-web -n 200 --no-pager | grep -A 5 -B 5 "web_display_autostart\|Configuration\|Launching\|will not"
-```
-
-This will show you if it said something like:
-- "Configuration 'web_display_autostart' is false or not set. Web interface will not be started."
-
-### 2. Check your config.json:
-```bash
-cat ~/LEDMatrix/config/config.json | grep web_display_autostart
-```
-
-### 3. If it's false or missing, set it to true:
-```bash
-nano ~/LEDMatrix/config/config.json
-```
-
-Find the line with `web_display_autostart` and change it to:
-```json
-"web_display_autostart": true,
-```
-
-If the line doesn't exist, add it near the top of the file (after the opening `{`):
-```json
-{
-  "web_display_autostart": true,
-  ... rest of config ...
-}
-```
-
-### 4. After fixing the config, restart the service:
-```bash
-sudo systemctl restart ledmatrix-web
-```
-
-### 5. Watch it start up:
-```bash
-sudo journalctl -u ledmatrix-web -f
-```
-
-You should see:
-- "Configuration 'web_display_autostart' is true. Starting web interface..."
-- "Dependencies installed successfully"
-- "Launching web interface v3: ..."
-- Flask starting up
-
-## Alternative: View ALL Recent Logs
-
-To see everything that happened:
-```bash
-sudo journalctl -u ledmatrix-web --since "5 minutes ago" --no-pager
-```
-
-This will show you the complete log including what happened after dependency installation.
-

docs/archive/FORM_VALIDATION_FIXES.md

@@ -1,181 +0,0 @@
-# Form Validation Fixes - Preventing "Invalid Form Control" Errors
-
-## Problem
-
-Browser was throwing errors: "An invalid form control with name='...' is not focusable" when:
-- Number inputs had values outside their min/max constraints
-- These fields were in collapsed/hidden nested sections
-- Browser couldn't focus hidden invalid fields to show validation errors
-
-## Root Cause
-
-1. **Value Clamping Missing**: Number inputs were generated with values that didn't respect min/max constraints
-2. **HTML5 Validation on Hidden Fields**: Browser validation tried to validate hidden fields but couldn't focus them
-3. **No Pre-Submit Validation**: Forms didn't fix invalid values before submission
-
-## Fixes Applied
-
-### 1. Plugin Configuration Form (`plugins.html`)
-
-**File**: `web_interface/templates/v3/partials/plugins.html`
-
-**Changes**:
-- ✅ Added value clamping in `generateFieldHtml()` (lines 1825-1844)
-  - Clamps values to min/max when generating number inputs
-  - Uses default value if provided
-  - Ensures all generated fields have valid values
-- ✅ Added `novalidate` attribute to form (line 1998)
-- ✅ Added pre-submit validation fix in `handlePluginConfigSubmit()` (lines 1518-1533)
-  - Fixes any invalid values before processing form data
-  - Prevents "invalid form control is not focusable" errors
-
-### 2. Plugin Config in Base Template (`base.html`)
-
-**File**: `web_interface/templates/v3/base.html`
-
-**Changes**:
-- ✅ Added value clamping in number input generation (lines 1386-1407)
-  - Same logic as plugins.html
-  - Clamps values to min/max constraints
-- ✅ Fixed display_duration input (line 1654)
-  - Uses `Math.max(5, Math.min(300, value))` to clamp value
-- ✅ Added global `fixInvalidNumberInputs()` function (lines 2409-2425)
-  - Can be called from any form's onsubmit handler
-  - Fixes invalid number inputs before submission
-
-### 3. Display Settings Form (`display.html`)
-
-**File**: `web_interface/templates/v3/partials/display.html`
-
-**Changes**:
-- ✅ Added `novalidate` attribute to form (line 13)
-- ✅ Added `onsubmit="fixInvalidNumberInputs(this); return true;"` (line 14)
-- ✅ Added local `fixInvalidNumberInputs()` function as fallback (lines 260-278)
-
-### 4. Durations Form (`durations.html`)
-
-**File**: `web_interface/templates/v3/partials/durations.html`
-
-**Changes**:
-- ✅ Added `novalidate` attribute to form (line 13)
-- ✅ Added `onsubmit="fixInvalidNumberInputs(this); return true;"` (line 14)
-
-## Implementation Details
-
-### Value Clamping Logic
-
-```javascript
-// Ensure value respects min/max constraints
-let fieldValue = value !== undefined ? value : (prop.default !== undefined ? prop.default : '');
-if (fieldValue !== '' && fieldValue !== undefined && fieldValue !== null) {
-    const numValue = typeof fieldValue === 'string' ? parseFloat(fieldValue) : fieldValue;
-    if (!isNaN(numValue)) {
-        // Clamp value to min/max if constraints exist
-        if (prop.minimum !== undefined && numValue < prop.minimum) {
-            fieldValue = prop.minimum;
-        } else if (prop.maximum !== undefined && numValue > prop.maximum) {
-            fieldValue = prop.maximum;
-        } else {
-            fieldValue = numValue;
-        }
-    }
-}
-```
-
-### Pre-Submit Validation Fix
-
-```javascript
-// Fix invalid hidden fields before submission
-const allInputs = form.querySelectorAll('input[type="number"]');
-allInputs.forEach(input => {
-    const min = parseFloat(input.getAttribute('min'));
-    const max = parseFloat(input.getAttribute('max'));
-    const value = parseFloat(input.value);
-    
-    if (!isNaN(value)) {
-        if (!isNaN(min) && value < min) {
-            input.value = min;
-        } else if (!isNaN(max) && value > max) {
-            input.value = max;
-        }
-    }
-});
-```
-
-## Files Modified
-
-1. ✅ `web_interface/templates/v3/partials/plugins.html`
-   - Value clamping in field generation
-   - `novalidate` on forms
-   - Pre-submit validation fix
-
-2. ✅ `web_interface/templates/v3/base.html`
-   - Value clamping in field generation
-   - Fixed display_duration input
-   - Global `fixInvalidNumberInputs()` function
-
-3. ✅ `web_interface/templates/v3/partials/display.html`
-   - `novalidate` on form
-   - `onsubmit` handler
-   - Local fallback function
-
-4. ✅ `web_interface/templates/v3/partials/durations.html`
-   - `novalidate` on form
-   - `onsubmit` handler
-
-## Prevention Strategy
-
-### For Future Forms
-
-1. **Always clamp number input values** when generating forms:
-   ```javascript
-   // Clamp value to min/max
-   if (min !== undefined && value < min) value = min;
-   if (max !== undefined && value > max) value = max;
-   ```
-
-2. **Add `novalidate` to forms** that use custom validation:
-   ```html
-   <form novalidate onsubmit="fixInvalidNumberInputs(this); return true;">
-   ```
-
-3. **Use the global helper** for pre-submit validation:
-   ```javascript
-   window.fixInvalidNumberInputs(form);
-   ```
-
-4. **Check for hidden fields** - If fields can be hidden (collapsed sections), ensure:
-   - Values are valid when fields are generated
-   - Pre-submit validation fixes any remaining issues
-   - Form has `novalidate` to prevent HTML5 validation
-
-## Testing
-
-### Test Cases
-
-1. ✅ Number input with value=0, min=60 → Should clamp to 60
-2. ✅ Number input with value=1000, max=600 → Should clamp to 600
-3. ✅ Hidden field with invalid value → Should be fixed on submit
-4. ✅ Form submission with invalid values → Should fix before submit
-5. ✅ Nested sections with number inputs → Should work correctly
-
-### Manual Testing
-
-1. Open plugin configuration with nested sections
-2. Collapse a section with number inputs
-3. Try to submit form → Should work without errors
-4. Check browser console → Should have no validation errors
-
-## Related Issues
-
-- **Issue**: "An invalid form control with name='...' is not focusable"
-- **Cause**: Hidden fields with invalid values (outside min/max)
-- **Solution**: Value clamping + pre-submit validation + `novalidate`
-
-## Notes
-
-- We use `novalidate` because we do server-side validation anyway
-- The pre-submit fix is a safety net for any edge cases
-- Value clamping at generation time prevents most issues
-- All fixes are backward compatible
-

docs/archive/INTEGRATION_COMPLETE.md

@@ -1,227 +0,0 @@
-# Web UI Reliability Improvements - Integration Complete
-
-## Summary
-
-Successfully integrated the new reliability infrastructure into the web UI's plugin and configuration management system. All critical endpoints now use the new infrastructure for improved reliability, debuggability, and maintainability.
-
-## What Was Integrated
-
-### 1. Atomic Configuration Saves ✅
-
-**Integrated Into:**
-- `save_plugin_config()` - Plugin configuration saves
-- `save_main_config()` - Main configuration saves
-- `save_schedule_config()` - Schedule configuration saves
-
-**Benefits:**
-- Automatic backups before each save (keeps last 5)
-- Atomic file writes prevent corruption
-- Automatic rollback on validation failure
-- Can restore from any backup
-
-**Usage:**
-```python
-# Automatic - happens in background
-result = config_manager.save_config_atomic(new_config, create_backup=True)
-
-# Manual rollback if needed
-config_manager.rollback_config()
-```
-
-### 2. Plugin Operation Queue ✅
-
-**Integrated Into:**
-- `install_plugin()` - Queues installation operations
-- `update_plugin()` - Queues update operations
-- `uninstall_plugin()` - Queues uninstall operations
-
-**New Endpoints:**
-- `GET /api/v3/plugins/operation/<operation_id>` - Check operation status
-- `GET /api/v3/plugins/operation/history` - Get operation history
-
-**Benefits:**
-- Prevents concurrent operations on same plugin
-- Serializes operations to avoid conflicts
-- Tracks operation status and progress
-- Operation history for debugging
-
-**Usage:**
-```python
-# Operations are automatically queued
-operation_id = operation_queue.enqueue_operation(
-    OperationType.INSTALL,
-    plugin_id,
-    operation_callback=install_callback
-)
-
-# Check status
-status = operation_queue.get_operation_status(operation_id)
-```
-
-### 3. Structured Error Handling ✅
-
-**Integrated Into:**
-- All plugin management endpoints
-- All configuration endpoints
-- All new endpoints
-
-**Benefits:**
-- Consistent error response format
-- Error codes for programmatic handling
-- Suggested fixes in error responses
-- Detailed context for debugging
-
-**Error Response Format:**
-```json
-{
-  "status": "error",
-  "error_code": "PLUGIN_NOT_FOUND",
-  "error_category": "plugin",
-  "message": "Plugin not found",
-  "details": "...",
-  "suggested_fixes": ["Check plugin ID", "Refresh plugin list"],
-  "context": {"plugin_id": "..."}
-}
-```
-
-### 4. Operation History ✅
-
-**Integrated Into:**
-- All plugin operations (install, update, uninstall, toggle, configure)
-- Automatically tracks all operations
-- Persisted to `data/operation_history.json`
-
-**Benefits:**
-- Complete audit trail
-- Debugging support
-- Operation tracking
-
-### 5. State Management ✅
-
-**Integrated Into:**
-- `toggle_plugin()` - Updates state on enable/disable
-- `install_plugin()` - Records installation state
-- `uninstall_plugin()` - Removes state on uninstall
-
-**New Endpoints:**
-- `GET /api/v3/plugins/state` - Get plugin state(s)
-- `POST /api/v3/plugins/state/reconcile` - Reconcile state inconsistencies
-
-**Benefits:**
-- Single source of truth for plugin state
-- State change notifications
-- State persistence
-- Automatic state reconciliation
-
-### 6. State Reconciliation ✅
-
-**New Endpoint:**
-- `POST /api/v3/plugins/state/reconcile` - Detect and fix state inconsistencies
-
-**Benefits:**
-- Detects inconsistencies between config, manager, disk, and state manager
-- Auto-fixes safe inconsistencies
-- Reports manual fix requirements
-
-## Integration Details
-
-### Files Modified
-
-1. **`web_interface/app.py`**
-   - Initialized operation queue
-   - Initialized state manager
-   - Initialized operation history
-   - Passed to API blueprint
-
-2. **`web_interface/blueprints/api_v3.py`**
-   - Added imports for new infrastructure
-   - Updated all plugin endpoints
-   - Updated all config endpoints
-   - Added new endpoints for operations and state
-
-### Helper Functions Added
-
-- `_save_config_atomic()` - Helper for atomic config saves
-- `validate_request_json()` - Request validation helper
-- `success_response()` - Standardized success responses
-- `error_response()` - Standardized error responses
-
-## Testing
-
-All code passes linting. To test:
-
-1. **Test atomic config saves:**
-   ```bash
-   # Save config - should create backup
-   curl -X POST http://localhost:5000/api/v3/plugins/config \
-     -H "Content-Type: application/json" \
-     -d '{"plugin_id": "test", "config": {"enabled": true}}'
-   
-   # List backups
-   # (Check config/backups/ directory)
-   ```
-
-2. **Test operation queue:**
-   ```bash
-   # Install plugin - returns operation_id
-   curl -X POST http://localhost:5000/api/v3/plugins/install \
-     -H "Content-Type: application/json" \
-     -d '{"plugin_id": "test-plugin"}'
-   
-   # Check operation status
-   curl http://localhost:5000/api/v3/plugins/operation/<operation_id>
-   ```
-
-3. **Test state reconciliation:**
-   ```bash
-   # Reconcile state
-   curl -X POST http://localhost:5000/api/v3/plugins/state/reconcile
-   ```
-
-## Data Files Created
-
-- `data/plugin_operations.json` - Operation queue history
-- `data/plugin_state.json` - Plugin state persistence
-- `data/operation_history.json` - Operation history/audit log
-- `config/backups/` - Configuration backups
-
-## Backward Compatibility
-
-All changes are backward compatible:
-- Old endpoints still work
-- New features are additive
-- Can be enabled/disabled via feature flags if needed
-- Graceful fallback if new infrastructure not available
-
-## Performance Impact
-
-- **Atomic saves**: Minimal overhead (backup creation is fast)
-- **Operation queue**: Prevents conflicts, may add small delay for queued operations
-- **State manager**: In-memory with periodic persistence (minimal overhead)
-- **Operation history**: Async writes, minimal impact
-
-## Next Steps (Optional Enhancements)
-
-1. **Frontend Integration**
-   - Update UI to use new JavaScript modules
-   - Show operation status in UI
-   - Display operation history
-   - Show state reconciliation results
-
-2. **Additional Features**
-   - Operation cancellation endpoint
-   - Scheduled state reconciliation
-   - Health monitoring integration
-   - Config diff viewer in UI
-
-3. **Testing**
-   - Integration tests for operation queue
-   - Integration tests for atomic saves
-   - Integration tests for state reconciliation
-
-## Documentation
-
-- **Implementation Guide**: `docs/WEB_UI_RELIABILITY_IMPROVEMENTS.md`
-- **Integration Status**: `docs/INTEGRATION_STATUS.md`
-- **This Document**: `docs/INTEGRATION_COMPLETE.md`
-

docs/archive/INTEGRATION_PROGRESS.md

@@ -1,91 +0,0 @@
-# Integration Progress Summary
-
-## Completed Integrations ✅
-
-### Core Infrastructure
-- ✅ Operation queue initialized and integrated into `install_plugin()`
-- ✅ State manager initialized and integrated into `toggle_plugin()` and `install_plugin()`
-- ✅ Operation history tracking for all plugin operations
-- ✅ Atomic config saves integrated into all config save endpoints
-
-### Endpoints Updated
-
-1. **`/api/v3/plugins/toggle`** ✅
-   - Uses atomic config saves
-   - Updates state manager
-   - Records operation history
-   - Uses structured error responses
-
-2. **`/api/v3/plugins/install`** ✅
-   - Uses operation queue
-   - Updates state manager
-   - Records operation history
-   - Uses structured error responses
-
-3. **`/api/v3/plugins/update`** ✅
-   - Uses operation queue
-   - Updates state manager
-   - Records operation history
-   - Uses structured error responses
-
-4. **`/api/v3/plugins/uninstall`** ✅
-   - Uses operation queue
-   - Updates state manager
-   - Records operation history
-   - Uses structured error responses
-
-5. **`/api/v3/plugins/config` (GET)** ✅
-   - Uses structured error responses
-
-6. **`/api/v3/plugins/config` (POST)** ✅
-   - Uses atomic config saves
-   - Records operation history
-   - Uses structured error responses with validation details
-
-7. **`/api/v3/config/main` (POST)** ✅
-   - Uses atomic config saves
-   - Uses structured error responses
-
-8. **`/api/v3/config/schedule` (POST)** ✅
-   - Uses atomic config saves
-   - Uses structured error responses
-
-### New Endpoints Added
-
-1. **`GET /api/v3/plugins/operation/<operation_id>`** ✅
-   - Get status of a queued operation
-
-2. **`GET /api/v3/plugins/operation/history`** ✅
-   - Get operation history with optional filtering
-
-3. **`GET /api/v3/plugins/state`** ✅
-   - Get plugin state from state manager
-
-4. **`POST /api/v3/plugins/state/reconcile`** ✅
-   - Reconcile plugin state across all sources
-
-## Benefits Realized
-
-1. **Reliability**
-   - Config saves are atomic with automatic backups
-   - Plugin operations are serialized to prevent conflicts
-   - State is tracked and can be reconciled
-
-2. **Debuggability**
-   - All operations are logged to history
-   - Structured errors provide context and suggestions
-   - Operation status can be queried
-
-3. **Consistency**
-   - Standardized API responses
-   - State manager ensures single source of truth
-   - State reconciliation detects and fixes inconsistencies
-
-## Next Steps (Optional)
-
-1. Migrate remaining endpoints to structured errors
-2. Integrate health monitoring into plugin info responses
-3. Add frontend integration for new modules
-4. Add scheduled state reconciliation
-5. Add operation cancellation endpoint
-

docs/archive/INTEGRATION_STATUS.md

@@ -1,168 +0,0 @@
-# Web UI Reliability Improvements - Integration Status
-
-This document tracks the integration of the new reliability infrastructure into the existing codebase.
-
-## Completed Integrations ✅
-
-### Phase 1 Infrastructure
-
-1. **Atomic Configuration Saves**
-   - ✅ Integrated into `save_plugin_config()` endpoint
-   - ✅ Integrated into `save_main_config()` endpoint  
-   - ✅ Integrated into `save_schedule_config()` endpoint
-   - ✅ Helper function `_save_config_atomic()` created for consistent usage
-   - ⚠️ Still using regular save in some places (can be migrated incrementally)
-
-2. **Operation Queue**
-   - ✅ Initialized in `web_interface/app.py`
-   - ✅ Integrated into `install_plugin()` endpoint
-   - ✅ New endpoints added:
-     - `GET /api/v3/plugins/operation/<operation_id>` - Get operation status
-     - `GET /api/v3/plugins/operation/history` - Get operation history
-   - ⚠️ `update_plugin()` and `uninstall_plugin()` still use direct calls (can be migrated)
-
-3. **Structured Error Handling**
-   - ✅ Imports added to `api_v3.py`
-   - ✅ `toggle_plugin()` endpoint uses structured errors
-   - ✅ `install_plugin()` endpoint uses structured errors
-   - ✅ Config save endpoints use structured errors
-   - ⚠️ Other endpoints still use old error format (can be migrated incrementally)
-
-4. **Operation History**
-   - ✅ Initialized in `web_interface/app.py`
-   - ✅ Integrated into `toggle_plugin()` endpoint
-   - ✅ Integrated into `install_plugin()` endpoint
-   - ✅ Integrated into `save_plugin_config()` endpoint
-
-### Phase 2 Infrastructure
-
-1. **State Manager**
-   - ✅ Initialized in `web_interface/app.py`
-   - ✅ Integrated into `toggle_plugin()` endpoint
-   - ✅ Integrated into `install_plugin()` endpoint
-   - ⚠️ Not yet integrated with plugin manager discovery/loading
-
-2. **State Reconciliation**
-   - ✅ Created and ready to use
-   - ⚠️ Not yet integrated (can be called manually or scheduled)
-
-3. **API Response Standardization**
-   - ✅ Helper functions imported
-   - ✅ `toggle_plugin()` uses `success_response()`
-   - ✅ `install_plugin()` uses `success_response()` and `error_response()`
-   - ✅ Config save endpoints use standardized responses
-   - ⚠️ Other endpoints still use `jsonify()` directly
-
-## Pending Integrations
-
-### High Priority
-
-1. **Complete Operation Queue Integration**
-   - Migrate `update_plugin()` to use operation queue
-   - Migrate `uninstall_plugin()` to use operation queue
-   - Add operation cancellation endpoint
-
-2. **Complete Error Handling Migration**
-   - Migrate all endpoints to use structured errors
-   - Add error handling decorator where appropriate
-   - Update frontend to handle structured error responses
-
-3. **State Manager Integration**
-   - Integrate with plugin manager discovery
-   - Update state on plugin load/unload
-   - Use state manager as source of truth for enabled status
-
-### Medium Priority
-
-4. **State Reconciliation**
-   - Add scheduled reconciliation (e.g., on startup)
-   - Add manual reconciliation endpoint
-   - Add reconciliation status to health checks
-
-5. **Health Monitoring**
-   - Integrate health monitor with plugin manager
-   - Add health status endpoint
-   - Add health status to plugin info responses
-
-6. **Frontend Module Integration**
-   - Update frontend to use new JavaScript modules
-   - Migrate from old `plugins_manager.js` to modular structure
-   - Update error handling in frontend
-
-### Low Priority
-
-7. **Testing**
-   - Add integration tests for operation queue
-   - Add integration tests for atomic config saves
-   - Add integration tests for state reconciliation
-
-8. **Documentation**
-   - Update API documentation with new endpoints
-   - Document error codes and responses
-   - Add migration guide for developers
-
-## Usage Examples
-
-### Using Atomic Config Saves
-
-```python
-# In API endpoint
-success, error_msg = _save_config_atomic(config_manager, config_data, create_backup=True)
-if not success:
-    return error_response(ErrorCode.CONFIG_SAVE_FAILED, error_msg, status_code=500)
-```
-
-### Using Operation Queue
-
-```python
-# In API endpoint
-def install_callback(operation):
-    # Perform installation
-    success = plugin_store_manager.install_plugin(operation.plugin_id)
-    if success:
-        # Update state, record history, etc.
-        return {'success': True}
-    else:
-        raise Exception("Installation failed")
-
-operation_id = operation_queue.enqueue_operation(
-    OperationType.INSTALL,
-    plugin_id,
-    operation_callback=install_callback
-)
-```
-
-### Using Structured Errors
-
-```python
-# In API endpoint
-from src.web_interface.api_helpers import error_response, success_response
-from src.web_interface.errors import ErrorCode
-
-# Success
-return success_response(data=result, message="Operation successful")
-
-# Error
-return error_response(
-    ErrorCode.PLUGIN_NOT_FOUND,
-    "Plugin not found",
-    context={"plugin_id": plugin_id},
-    status_code=404
-)
-```
-
-## Migration Strategy
-
-1. **Incremental Migration**: All changes are backward compatible
-2. **Feature Flags**: Can enable/disable new features via config
-3. **Gradual Rollout**: Migrate endpoints one at a time
-4. **Testing**: Test each migrated endpoint thoroughly before moving to next
-
-## Next Steps
-
-1. Complete operation queue integration for update/uninstall
-2. Migrate remaining endpoints to structured errors
-3. Integrate state manager with plugin discovery
-4. Add state reconciliation endpoint
-5. Update frontend to use new modules
-

docs/archive/NESTED_SCHEMA_IMPLEMENTATION.md

@@ -1,258 +0,0 @@
-# Nested Config Schema Implementation - Complete
-
-## Summary
-
-The plugin manager now fully supports **nested config schemas**, allowing complex plugins to organize their configuration options into logical, collapsible sections in the web interface.
-
-## What Was Implemented
-
-### 1. Core Functionality ✅
-
-**Updated Files:**
-- `web_interface/templates/v3/partials/plugins.html`
-
-**New Features:**
-- Recursive form generation for nested objects
-- Collapsible sections with smooth animations
-- Dot notation for form field names (e.g., `nfl.display_modes.show_live`)
-- Automatic conversion between flat form data and nested JSON
-- Support for unlimited nesting depth
-
-### 2. Helper Functions ✅
-
-Added to `plugins.html`:
-
-- **`getSchemaPropertyType(schema, path)`** - Find property type using dot notation
-- **`dotToNested(obj)`** - Convert flat dot notation to nested objects
-- **`collectBooleanFields(schema, prefix)`** - Recursively find all boolean fields
-- **`flattenConfig(obj, prefix)`** - Flatten nested config for form display
-- **`generateFieldHtml(key, prop, value, prefix)`** - Recursively generate form fields
-- **`toggleNestedSection(sectionId)`** - Toggle collapse/expand of nested sections
-
-### 3. UI Enhancements ✅
-
-**CSS Styling Added:**
-- Smooth transitions for expand/collapse
-- Visual hierarchy with indentation
-- Gray background for nested sections to differentiate from main form
-- Hover effects on section headers
-- Chevron icons that rotate on toggle
-- Responsive design for nested sections
-
-### 4. Backward Compatibility ✅
-
-**Fully Compatible:**
-- All 18 existing plugins with flat schemas work without changes
-- Mixed mode supported (flat and nested properties in same schema)
-- No backend API changes required
-- Existing configs load and save correctly
-
-### 5. Documentation ✅
-
-**Created Files:**
-- `docs/NESTED_CONFIG_SCHEMAS.md` - Complete user guide
-- `plugin-repos/ledmatrix-football-scoreboard/config_schema_nested_example.json` - Example nested schema
-
-## Why It Wasn't Supported Before
-
-Simply put: **nobody implemented it yet**. The original `generateFormFromSchema()` function only handled flat properties - it had no handler for `type: 'object'` which indicates nested structures. All existing plugins used flat schemas with prefixed names (e.g., `nfl_enabled`, `nfl_show_live`, etc.).
-
-## Technical Details
-
-### How It Works
-
-1. **Schema Definition**: Plugin defines nested objects using `type: "object"` with nested `properties`
-2. **Form Generation**: `generateFieldHtml()` recursively creates collapsible sections for nested objects
-3. **Form Submission**: Form data uses dot notation (`nfl.enabled`) which is converted to nested JSON (`{nfl: {enabled: true}}`)
-4. **Config Storage**: Stored as proper nested JSON objects in `config.json`
-
-### Example Transformation
-
-**Flat Schema (Before):**
-```json
-{
-  "nfl_enabled": true,
-  "nfl_show_live": true,
-  "nfl_favorite_teams": ["TB", "DAL"]
-}
-```
-
-**Nested Schema (After):**
-```json
-{
-  "nfl": {
-    "enabled": true,
-    "show_live": true,
-    "favorite_teams": ["TB", "DAL"]
-  }
-}
-```
-
-### Field Name Mapping
-
-Form fields use dot notation internally:
-- `nfl.enabled` → `{nfl: {enabled: true}}`
-- `nfl.display_modes.show_live` → `{nfl: {display_modes: {show_live: true}}}`
-- `ncaa_fb.game_limits.recent_games_to_show` → `{ncaa_fb: {game_limits: {recent_games_to_show: 5}}}`
-
-## Benefits
-
-### For Plugin Developers
-- **Better organization** - Group related settings logically
-- **Cleaner code** - Access config with natural nesting: `config["nfl"]["enabled"]`
-- **Easier maintenance** - Related settings are together
-- **Scalability** - Handle 50+ options without overwhelming users
-
-### For Users
-- **Less overwhelming** - Collapsible sections hide complexity
-- **Easier navigation** - Find settings quickly in logical groups
-- **Better understanding** - Clear hierarchy shows relationships
-- **Cleaner UI** - Organized sections vs. endless list
-
-## Examples
-
-### Football Plugin Comparison
-
-**Before (Flat - 32 properties):**
-All properties in one long list:
-- `nfl_enabled`
-- `nfl_favorite_teams`
-- `nfl_show_live`
-- `nfl_show_recent`
-- `nfl_show_upcoming`
-- ... (27 more)
-
-**After (Nested - Same 32 properties):**
-Organized into 2 main sections:
-- **NFL Settings** (collapsed)
-  - **Display Modes** (collapsed)
-  - **Game Limits** (collapsed)
-  - **Display Options** (collapsed)
-  - **Filtering** (collapsed)
-- **NCAA Football Settings** (collapsed)
-  - Same nested structure
-
-### Baseball Plugin Opportunity
-
-The baseball plugin has **over 100 properties**! With nested schemas, these could be organized into:
-- **MLB Settings**
-  - Display Modes
-  - Game Limits
-  - Display Options
-  - Background Service
-- **MiLB Settings**
-  - (same structure)
-- **NCAA Baseball Settings**
-  - (same structure)
-
-## Migration Guide
-
-### For New Plugins
-Use nested schemas from the start:
-
-```json
-{
-  "type": "object",
-  "properties": {
-    "enabled": {"type": "boolean", "default": true},
-    "sport_name": {
-      "type": "object",
-      "title": "Sport Name Settings",
-      "properties": {
-        "enabled": {"type": "boolean", "default": true},
-        "favorite_teams": {"type": "array", "items": {"type": "string"}, "default": []}
-      }
-    }
-  }
-}
-```
-
-### For Existing Plugins
-
-You have three options:
-
-1. **Keep flat** - No changes needed, works perfectly
-2. **Gradual migration** - Nest some sections, keep others flat
-3. **Full migration** - Restructure entire schema (requires updating plugin code to access nested config)
-
-## Testing
-
-### Backward Compatibility Verified
-- ✅ All 18 existing flat schemas work unchanged
-- ✅ Form generation works for flat schemas
-- ✅ Form submission works for flat schemas
-- ✅ Config saving/loading works for flat schemas
-
-### New Nested Schema Tested
-- ✅ Nested objects generate collapsible sections
-- ✅ Multi-level nesting works (object within object)
-- ✅ Form fields use correct dot notation
-- ✅ Form submission converts to nested JSON correctly
-- ✅ Boolean fields handled in nested structures
-- ✅ All field types work in nested sections (boolean, number, integer, array, string, enum)
-
-## Files Modified
-
-1. **`web_interface/templates/v3/partials/plugins.html`**
-   - Added helper functions for nested schema handling
-   - Updated `generateFormFromSchema()` to recursively handle nested objects
-   - Updated `handlePluginConfigSubmit()` to convert dot notation to nested JSON
-   - Added `toggleNestedSection()` for UI interaction
-   - Added CSS styles for nested sections
-
-## Files Created
-
-1. **`docs/NESTED_CONFIG_SCHEMAS.md`**
-   - Complete user and developer guide
-   - Examples and best practices
-   - Migration strategies
-   - Troubleshooting guide
-
-2. **`plugin-repos/ledmatrix-football-scoreboard/config_schema_nested_example.json`**
-   - Full working example of nested schema
-   - Demonstrates all nesting levels
-   - Shows before/after comparison
-
-## No Backend Changes Needed
-
-The existing API endpoints work perfectly:
-- `/api/v3/plugins/schema` - Returns schema (flat or nested)
-- `/api/v3/plugins/config` (GET) - Returns config (flat or nested)
-- `/api/v3/plugins/config` (POST) - Saves config (flat or nested)
-
-The backend doesn't care about structure - it just stores/retrieves JSON!
-
-## Next Steps
-
-### Immediate Use
-You can start using nested schemas right now:
-1. Create a new plugin with nested schema
-2. Or update an existing plugin's `config_schema.json` to use nesting
-3. The web interface will automatically render collapsible sections
-
-### Recommended Migrations
-Good candidates for nested schemas:
-- **Baseball plugin** (100+ properties → 3-4 main sections)
-- **Football plugin** (32 properties → 2 main sections) [example already created]
-- **Basketball plugin** (similar to football)
-- **Hockey plugin** (similar to football)
-
-### Future Enhancements
-Potential improvements (not required):
-- Remember collapsed/expanded state per user
-- Search within nested sections
-- Visual indication of which section has changes
-- Drag-and-drop to reorder sections
-
-## Conclusion
-
-The plugin manager now has full support for nested config schemas with:
-- ✅ Automatic UI generation
-- ✅ Collapsible sections
-- ✅ Full backward compatibility
-- ✅ No breaking changes
-- ✅ Complete documentation
-- ✅ Working examples
-
-Complex plugins can now be much easier to configure and maintain!
-

docs/archive/NEXT_STEPS_COMMANDS.md

@@ -1,85 +0,0 @@
-# Next Steps - Run These Commands on Your Pi
-
-## What's Happening Now
-
-✅ Service is **enabled** and **active (running)**  
-⏳ Currently **installing dependencies** (this is normal on first start)  
-⏳ Should start Flask app once dependencies are installed
-
-## Commands to Run Next
-
-### 1. Wait a Minute for Dependencies to Install
-The pip install process needs to complete first.
-
-### 2. Check Current Status
-```bash
-sudo systemctl status ledmatrix-web
-```
-
-Look for the Tasks count - when it drops from 2 to 1, pip is done.
-
-### 3. View the Logs to See What's Happening
-```bash
-sudo journalctl -u ledmatrix-web -f
-```
-
-Press `Ctrl+C` to exit when done watching.
-
-You should eventually see:
-- "Dependencies installed successfully"
-- "Installing rgbmatrix module..."
-- "Launching web interface v3: ..."
-- Messages from Flask about starting the server
-
-### 4. Check if Flask is Running on Port 5000
-```bash
-sudo netstat -tlnp | grep :5000
-```
-or
-```bash
-sudo ss -tlnp | grep :5000
-```
-
-Should show Python listening on port 5000.
-
-### 5. Test Access
-Once the logs show Flask started, try accessing:
-```bash
-curl http://localhost:5000
-```
-
-Or from your computer's browser:
-```
-http://<raspberry-pi-ip>:5000
-```
-
-## If It Gets Stuck
-
-If after 2-3 minutes the dependencies are still installing and nothing happens:
-
-```bash
-# Stop the service
-sudo systemctl stop ledmatrix-web
-
-# Check what went wrong
-sudo journalctl -u ledmatrix-web -n 100 --no-pager
-
-# Try manual start to see errors directly
-cd ~/LEDMatrix
-python3 web_interface/start.py
-```
-
-## Expected Timeline
-
-- **0-30 seconds**: Installing pip dependencies
-- **30-60 seconds**: Installing rgbmatrix module  
-- **60+ seconds**: Flask app should be running
-- **Access**: http://<pi-ip>:5000 should work
-
-## Success Indicators
-
-✅ Logs show: "Starting LED Matrix Web Interface V3..."  
-✅ Logs show: "Access the interface at: http://0.0.0.0:5000"  
-✅ Port 5000 is listening  
-✅ Web page loads in browser
-

docs/archive/ON_DEMAND_CACHE_MANAGEMENT.md

@@ -1,203 +0,0 @@
-# On-Demand Cache Management
-
-## Overview
-
-The on-demand feature uses several cache keys to manage state. Understanding these keys helps with troubleshooting and manual recovery.
-
-## Cache Keys Used
-
-### 1. `display_on_demand_request`
-**Purpose**: Stores pending on-demand requests (start/stop actions)  
-**TTL**: 1 hour  
-**When Set**: When you click "Run On-Demand" or "Stop On-Demand"  
-**When Cleared**: Automatically after processing, or manually via cache management
-
-**Structure**:
-```json
-{
-  "request_id": "uuid-string",
-  "action": "start" | "stop",
-  "plugin_id": "plugin-name",
-  "mode": "mode-name",
-  "duration": 30.0,
-  "pinned": true,
-  "timestamp": 1234567890.123
-}
-```
-
-### 2. `display_on_demand_config`
-**Purpose**: Stores the active on-demand configuration (persists across restarts)  
-**TTL**: 1 hour  
-**When Set**: When on-demand mode is activated  
-**When Cleared**: When on-demand mode is stopped, or manually via cache management
-
-**Structure**:
-```json
-{
-  "plugin_id": "plugin-name",
-  "mode": "mode-name",
-  "duration": 30.0,
-  "pinned": true,
-  "requested_at": 1234567890.123,
-  "expires_at": 1234567920.123
-}
-```
-
-### 3. `display_on_demand_state`
-**Purpose**: Current on-demand state (read-only, published by display controller)  
-**TTL**: None (updated continuously)  
-**When Set**: Continuously updated by display controller  
-**When Cleared**: Automatically when on-demand ends, or manually via cache management
-
-**Structure**:
-```json
-{
-  "active": true,
-  "mode": "mode-name",
-  "plugin_id": "plugin-name",
-  "requested_at": 1234567890.123,
-  "expires_at": 1234567920.123,
-  "duration": 30.0,
-  "pinned": true,
-  "status": "active" | "idle" | "restarting" | "error",
-  "error": null,
-  "last_event": "started",
-  "remaining": 25.5,
-  "last_updated": 1234567895.123
-}
-```
-
-### 4. `display_on_demand_processed_id`
-**Purpose**: Tracks which request_id has been processed (prevents duplicate processing)  
-**TTL**: 1 hour  
-**When Set**: When a request is processed  
-**When Cleared**: Automatically expires, or manually via cache management
-
-**Structure**: Just a string (the request_id)
-
-## When Manual Clearing is Needed
-
-### Scenario 1: Stuck On-Demand State
-**Symptoms**: 
-- Display stuck showing only one plugin
-- "Stop On-Demand" button doesn't work
-- Display controller shows on-demand as active but it shouldn't be
-
-**Solution**: Clear these keys:
-- `display_on_demand_config` - Removes the active configuration
-- `display_on_demand_state` - Resets the published state
-- `display_on_demand_request` - Clears any pending requests
-
-**How to Clear**: Use the Cache Management tab in the web UI:
-1. Go to Cache Management tab
-2. Find the keys starting with `display_on_demand_`
-3. Click "Delete" for each one
-4. Restart the display service: `sudo systemctl restart ledmatrix`
-
-### Scenario 2: On-Demand Mode Switching Issues
-**Symptoms**:
-- On-demand mode not switching to requested plugin
-- Logs show "Processing on-demand start request for plugin" but no "Activated on-demand for plugin" message
-- Display stuck in previous mode instead of switching immediately
-
-**Solution**: Clear these keys:
-- `display_on_demand_request` - Stops any pending request
-- `display_on_demand_processed_id` - Allows new requests to be processed
-- `display_on_demand_state` - Clears any stale state
-
-**How to Clear**: Same as Scenario 1, but focus on `display_on_demand_request` first. Note that on-demand now switches modes immediately without restarting the service.
-
-### Scenario 3: On-Demand Not Activating
-**Symptoms**:
-- Clicking "Run On-Demand" does nothing
-- No errors in logs, but on-demand doesn't start
-
-**Solution**: Clear these keys:
-- `display_on_demand_processed_id` - May be blocking new requests
-- `display_on_demand_request` - Clear any stale requests
-
-**How to Clear**: Same as Scenario 1
-
-### Scenario 4: After Service Crash or Unexpected Shutdown
-**Symptoms**:
-- Service was stopped unexpectedly (power loss, crash, etc.)
-- On-demand state may be inconsistent
-
-**Solution**: Clear all on-demand keys:
-- `display_on_demand_config`
-- `display_on_demand_state`
-- `display_on_demand_request`
-- `display_on_demand_processed_id`
-
-**How to Clear**: Same as Scenario 1, clear all four keys
-
-## Does Clearing from Cache Management Tab Reset It?
-
-**Yes, but with caveats:**
-
-1. **Clearing `display_on_demand_state`**: 
-   - ✅ Removes the published state from cache
-   - ⚠️ **Does NOT** immediately clear the in-memory state in the running display controller
-   - The display controller will continue using its internal state until it polls for updates or restarts
-
-2. **Clearing `display_on_demand_config`**:
-   - ✅ Removes the configuration from cache
-   - ⚠️ **Does NOT** immediately affect a running display controller
-   - The display controller only reads this on startup/restart
-
-3. **Clearing `display_on_demand_request`**:
-   - ✅ Prevents new requests from being processed
-   - ✅ Stops restart loops if that's the issue
-   - ⚠️ **Does NOT** stop an already-active on-demand session
-
-4. **Clearing `display_on_demand_processed_id`**:
-   - ✅ Allows previously-processed requests to be processed again
-   - Useful if a request got stuck
-
-## Best Practice for Manual Clearing
-
-**To fully reset on-demand state:**
-
-1. **Stop the display service** (if possible):
-   ```bash
-   sudo systemctl stop ledmatrix
-   ```
-
-2. **Clear all on-demand cache keys** via Cache Management tab:
-   - `display_on_demand_config`
-   - `display_on_demand_state`
-   - `display_on_demand_request`
-   - `display_on_demand_processed_id`
-
-3. **Clear systemd environment variable** (if set):
-   ```bash
-   sudo systemctl unset-environment LEDMATRIX_ON_DEMAND_PLUGIN
-   ```
-
-4. **Restart the display service**:
-   ```bash
-   sudo systemctl start ledmatrix
-   ```
-
-## Automatic Cleanup
-
-The display controller automatically:
-- Clears `display_on_demand_config` when on-demand mode is stopped
-- Updates `display_on_demand_state` continuously
-- Expires `display_on_demand_request` after processing
-- Expires `display_on_demand_processed_id` after 1 hour
-
-## Troubleshooting
-
-If clearing cache keys doesn't resolve the issue:
-
-1. **Check logs**: `sudo journalctl -u ledmatrix -f`
-2. **Check service status**: `sudo systemctl status ledmatrix`
-3. **Check environment variables**: `sudo systemctl show ledmatrix | grep LEDMATRIX`
-4. **Check cache files directly**: `ls -la /var/cache/ledmatrix/display_on_demand_*`
-
-## Related Files
-
-- `src/display_controller.py` - Main on-demand logic
-- `web_interface/blueprints/api_v3.py` - API endpoints for on-demand
-- `web_interface/templates/v3/partials/cache.html` - Cache management UI

docs/archive/ON_DEMAND_DISPLAY_API.md

@@ -1,554 +0,0 @@
-# On-Demand Display API
-
-## Overview
-
-The On-Demand Display API allows **manual control** of what's shown on the LED matrix. Unlike the automatic rotation or live priority system, on-demand display is **user-triggered** - typically from the web interface with a "Show Now" button.
-
-## Use Cases
-
-- 📺 **"Show Weather Now"** button in web UI
-- 🏒 **"Show Live Game"** button for specific sports
-- 📰 **"Show Breaking News"** button
-- 🎵 **"Show Currently Playing"** button for music
-- 🎮 **Quick preview** of any plugin without waiting for rotation
-
-## Priority Hierarchy
-
-The display controller processes requests in this order:
-
-```
-1. On-Demand Display (HIGHEST) ← User explicitly requested
-2. Live Priority (plugins with live content)
-3. Normal Rotation (automatic cycling)
-```
-
-On-demand overrides everything, including live priority.
-
-## API Reference
-
-### DisplayController Methods
-
-#### `show_on_demand(mode, duration=None, pinned=False) -> bool`
-
-Display a specific mode immediately, interrupting normal rotation.
-
-**Parameters:**
-- `mode` (str): The display mode to show (e.g., 'weather', 'hockey_live')
-- `duration` (float, optional): How long to show in seconds
-  - `None`: Use mode's default `display_duration` from config
-  - `0`: Show indefinitely (until cleared)
-  - `> 0`: Show for exactly this many seconds
-- `pinned` (bool): If True, stays on this mode until manually cleared
-
-**Returns:**
-- `True`: Mode was found and activated
-- `False`: Mode doesn't exist
-
-**Example:**
-```python
-# Show weather for 30 seconds then return to rotation
-controller.show_on_demand('weather', duration=30)
-
-# Show weather indefinitely
-controller.show_on_demand('weather', duration=0)
-
-# Pin to hockey live (stays until unpinned)
-controller.show_on_demand('hockey_live', pinned=True)
-
-# Use plugin's default duration
-controller.show_on_demand('weather')  # Uses display_duration from config
-```
-
-#### `clear_on_demand() -> None`
-
-Clear on-demand display and return to normal rotation.
-
-**Example:**
-```python
-controller.clear_on_demand()
-```
-
-#### `is_on_demand_active() -> bool`
-
-Check if on-demand display is currently active.
-
-**Returns:**
-- `True`: On-demand mode is active
-- `False`: Normal rotation or live priority
-
-**Example:**
-```python
-if controller.is_on_demand_active():
-    print("User is viewing on-demand content")
-```
-
-#### `get_on_demand_info() -> dict`
-
-Get detailed information about current on-demand display.
-
-**Returns:**
-```python
-{
-    'active': True,              # Whether on-demand is active
-    'mode': 'weather',           # Current mode being displayed
-    'duration': 30.0,            # Total duration (None if indefinite)
-    'elapsed': 12.5,             # Seconds elapsed
-    'remaining': 17.5,           # Seconds remaining (None if indefinite)
-    'pinned': False              # Whether pinned
-}
-
-# Or if not active:
-{
-    'active': False
-}
-```
-
-**Example:**
-```python
-info = controller.get_on_demand_info()
-if info['active']:
-    print(f"Showing {info['mode']}, {info['remaining']}s remaining")
-```
-
-## Web Interface Integration
-
-### API Endpoint Example
-
-```python
-# In web_interface/blueprints/api_v3.py
-
-from flask import jsonify, request
-
-@api_v3.route('/display/show', methods=['POST'])
-def show_on_demand():
-    """Show a specific plugin on-demand"""
-    data = request.json
-    mode = data.get('mode')
-    duration = data.get('duration')  # Optional
-    pinned = data.get('pinned', False)  # Optional
-    
-    # Get display controller instance
-    controller = get_display_controller()
-    
-    success = controller.show_on_demand(mode, duration, pinned)
-    
-    if success:
-        return jsonify({
-            'success': True,
-            'message': f'Showing {mode}',
-            'info': controller.get_on_demand_info()
-        })
-    else:
-        return jsonify({
-            'success': False,
-            'error': f'Mode {mode} not found'
-        }), 404
-
-@api_v3.route('/display/clear', methods=['POST'])
-def clear_on_demand():
-    """Clear on-demand display"""
-    controller = get_display_controller()
-    controller.clear_on_demand()
-    
-    return jsonify({
-        'success': True,
-        'message': 'On-demand display cleared'
-    })
-
-@api_v3.route('/display/on-demand-info', methods=['GET'])
-def get_on_demand_info():
-    """Get on-demand display status"""
-    controller = get_display_controller()
-    info = controller.get_on_demand_info()
-    
-    return jsonify(info)
-```
-
-### Frontend Example (JavaScript)
-
-```javascript
-// Show weather for 30 seconds
-async function showWeather() {
-    const response = await fetch('/api/v3/display/show', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            mode: 'weather',
-            duration: 30
-        })
-    });
-    
-    const data = await response.json();
-    if (data.success) {
-        updateStatus(`Showing weather for ${data.info.duration}s`);
-    }
-}
-
-// Pin to live hockey game
-async function pinHockeyLive() {
-    const response = await fetch('/api/v3/display/show', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            mode: 'hockey_live',
-            pinned: true
-        })
-    });
-    
-    const data = await response.json();
-    if (data.success) {
-        updateStatus('Pinned to hockey live');
-    }
-}
-
-// Clear on-demand
-async function clearOnDemand() {
-    const response = await fetch('/api/v3/display/clear', {
-        method: 'POST'
-    });
-    
-    const data = await response.json();
-    if (data.success) {
-        updateStatus('Returned to normal rotation');
-    }
-}
-
-// Check status
-async function checkOnDemandStatus() {
-    const response = await fetch('/api/v3/display/on-demand-info');
-    const info = await response.json();
-    
-    if (info.active) {
-        updateStatus(`On-demand: ${info.mode} (${info.remaining}s remaining)`);
-    } else {
-        updateStatus('Normal rotation');
-    }
-}
-```
-
-### UI Example (HTML)
-
-```html
-<!-- Plugin controls -->
-<div class="plugin-card">
-    <h3>Weather</h3>
-    <button onclick="showWeather()">Show Now (30s)</button>
-    <button onclick="showWeatherIndefinite()">Show Until Cleared</button>
-    <button onclick="pinWeather()">Pin Weather</button>
-</div>
-
-<!-- On-demand status display -->
-<div id="on-demand-status" class="status-bar">
-    <span id="status-text">Normal rotation</span>
-    <button id="clear-btn" onclick="clearOnDemand()" style="display: none;">
-        Clear On-Demand
-    </button>
-</div>
-
-<script>
-// Poll for status updates
-setInterval(async () => {
-    const info = await fetch('/api/v3/display/on-demand-info').then(r => r.json());
-    
-    const statusText = document.getElementById('status-text');
-    const clearBtn = document.getElementById('clear-btn');
-    
-    if (info.active) {
-        let text = `On-demand: ${info.mode}`;
-        if (info.remaining) {
-            text += ` (${Math.ceil(info.remaining)}s)`;
-        } else if (info.pinned) {
-            text += ' (pinned)';
-        }
-        statusText.textContent = text;
-        clearBtn.style.display = 'inline-block';
-    } else {
-        statusText.textContent = 'Normal rotation';
-        clearBtn.style.display = 'none';
-    }
-}, 1000);  // Update every second
-</script>
-```
-
-## Behavior Details
-
-### Duration Modes
-
-| Duration Value | Behavior | Use Case |
-|---------------|----------|----------|
-| `None` | Use plugin's `display_duration` from config | Default behavior |
-| `0` | Show indefinitely until cleared | Quick preview |
-| `> 0` | Show for exactly N seconds | Timed preview |
-| `pinned=True` | Stay on mode until unpinned | Extended viewing |
-
-### Auto-Clear Behavior
-
-On-demand display automatically clears when:
-- Duration expires (if set and > 0)
-- User manually clears it
-- System restarts
-
-On-demand does NOT clear when:
-- `duration=0` (indefinite)
-- `pinned=True`
-- Live priority content appears (on-demand still has priority)
-
-### Interaction with Live Priority
-
-```python
-# Scenario 1: On-demand overrides live priority
-controller.show_on_demand('weather', duration=30)
-# → Shows weather even if live game is happening
-
-# Scenario 2: After on-demand expires, live priority takes over
-controller.show_on_demand('weather', duration=10)
-# → Shows weather for 10s
-# → If live game exists, switches to live game
-# → Otherwise returns to normal rotation
-```
-
-## Use Case Examples
-
-### Example 1: Quick Weather Check
-
-```python
-# User clicks "Show Weather" button
-controller.show_on_demand('weather', duration=30)
-# Shows weather for 30 seconds, then returns to rotation
-```
-
-### Example 2: Monitor Live Game
-
-```python
-# User clicks "Watch Live Game" button
-controller.show_on_demand('hockey_live', pinned=True)
-# Stays on live game until user clicks "Back to Rotation"
-```
-
-### Example 3: Preview Plugin
-
-```python
-# User clicks "Preview" in plugin settings
-controller.show_on_demand('my-plugin', duration=15)
-# Shows plugin for 15 seconds to test configuration
-```
-
-### Example 4: Emergency Override
-
-```python
-# Admin needs to show important message
-controller.show_on_demand('text-display', pinned=True)
-# Display stays on message until admin clears it
-```
-
-## Testing
-
-### Manual Test from Python
-
-```python
-# Access display controller
-from src.display_controller import DisplayController
-controller = DisplayController()  # Or get existing instance
-
-# Test show on-demand
-controller.show_on_demand('weather', duration=20)
-print(controller.get_on_demand_info())
-
-# Test clear
-time.sleep(5)
-controller.clear_on_demand()
-print(controller.get_on_demand_info())
-```
-
-### Test with Web API
-
-```bash
-# Show weather for 30 seconds
-curl -X POST http://pi-ip:5001/api/v3/display/show \
-  -H "Content-Type: application/json" \
-  -d '{"mode": "weather", "duration": 30}'
-
-# Check status
-curl http://pi-ip:5001/api/v3/display/on-demand-info
-
-# Clear on-demand
-curl -X POST http://pi-ip:5001/api/v3/display/clear
-```
-
-### Monitor Logs
-
-```bash
-sudo journalctl -u ledmatrix -f | grep -i "on-demand"
-```
-
-Expected output:
-```
-On-demand display activated: weather (duration: 30s, pinned: False)
-On-demand display expired after 30.1s
-Clearing on-demand display: weather
-```
-
-## Best Practices
-
-### 1. Provide Visual Feedback
-
-Always show users when on-demand is active:
-
-```javascript
-// Update UI to show on-demand status
-function updateOnDemandUI(info) {
-    const banner = document.getElementById('on-demand-banner');
-    if (info.active) {
-        banner.style.display = 'block';
-        banner.textContent = `Showing: ${info.mode}`;
-        if (info.remaining) {
-            banner.textContent += ` (${Math.ceil(info.remaining)}s)`;
-        }
-    } else {
-        banner.style.display = 'none';
-    }
-}
-```
-
-### 2. Default to Timed Display
-
-Unless explicitly requested, use a duration:
-
-```python
-# Good: Auto-clears after 30 seconds
-controller.show_on_demand('weather', duration=30)
-
-# Risky: Stays indefinitely
-controller.show_on_demand('weather', duration=0)
-```
-
-### 3. Validate Modes
-
-Check if mode exists before showing:
-
-```python
-# Get available modes
-available_modes = controller.available_modes + list(controller.plugin_modes.keys())
-
-if mode in available_modes:
-    controller.show_on_demand(mode, duration=30)
-else:
-    return jsonify({'error': 'Mode not found'}), 404
-```
-
-### 4. Handle Concurrent Requests
-
-Last request wins:
-
-```python
-# Request 1: Show weather
-controller.show_on_demand('weather', duration=30)
-
-# Request 2: Show hockey (overrides weather)
-controller.show_on_demand('hockey_live', duration=20)
-# Hockey now shows for 20s, weather request is forgotten
-```
-
-## Troubleshooting
-
-### On-Demand Not Working
-
-**Check 1:** Verify mode exists
-```python
-info = controller.get_on_demand_info()
-print(f"Active: {info['active']}, Mode: {info.get('mode')}")
-print(f"Available modes: {controller.available_modes}")
-```
-
-**Check 2:** Check logs
-```bash
-sudo journalctl -u ledmatrix -f | grep "on-demand\|available modes"
-```
-
-### On-Demand Not Clearing
-
-**Check if pinned:**
-```python
-info = controller.get_on_demand_info()
-if info['pinned']:
-    print("Mode is pinned - must clear manually")
-    controller.clear_on_demand()
-```
-
-**Check duration:**
-```python
-if info['duration'] == 0:
-    print("Duration is indefinite - must clear manually")
-```
-
-### Mode Shows But Looks Wrong
-
-This is a **display** issue, not an on-demand issue. Check:
-- Plugin's `update()` method is fetching data
-- Plugin's `display()` method is rendering correctly
-- Cache is not stale
-
-## Security Considerations
-
-### 1. Authentication Required
-
-Always require authentication for on-demand control:
-
-```python
-@api_v3.route('/display/show', methods=['POST'])
-@login_required  # Add authentication
-def show_on_demand():
-    # ... implementation
-```
-
-### 2. Rate Limiting
-
-Prevent spam:
-
-```python
-from flask_limiter import Limiter
-
-limiter = Limiter(app, key_func=get_remote_address)
-
-@api_v3.route('/display/show', methods=['POST'])
-@limiter.limit("10 per minute")  # Max 10 requests per minute
-def show_on_demand():
-    # ... implementation
-```
-
-### 3. Input Validation
-
-Sanitize mode names:
-
-```python
-import re
-
-def validate_mode(mode):
-    # Only allow alphanumeric, underscore, hyphen
-    if not re.match(r'^[a-zA-Z0-9_-]+$', mode):
-        raise ValueError("Invalid mode name")
-    return mode
-```
-
-## Implementation Checklist
-
-- [ ] Add API endpoint to web interface
-- [ ] Add "Show Now" buttons to plugin UI
-- [ ] Add on-demand status indicator
-- [ ] Add "Clear" button when on-demand active
-- [ ] Add authentication/authorization
-- [ ] Add rate limiting
-- [ ] Test with multiple plugins
-- [ ] Test duration expiration
-- [ ] Test pinned mode
-- [ ] Document for end users
-
-## Future Enhancements
-
-Consider adding:
-1. **Queue system** - Queue multiple on-demand requests
-2. **Scheduled on-demand** - Show mode at specific time
-3. **Recurring on-demand** - Show every N minutes
-4. **Permission levels** - Different users can show different modes
-5. **History tracking** - Log who triggered what and when
-

docs/archive/ON_DEMAND_DISPLAY_QUICK_START.md

@@ -1,425 +0,0 @@
-# On-Demand Display - Quick Start Guide
-
-## 🎯 What Is It?
-
-On-Demand Display lets users **manually trigger** specific plugins to show on the LED matrix - perfect for "Show Now" buttons in your web interface!
-
-> **2025 update:** The LEDMatrix web interface now ships with first-class on-demand controls. You can trigger plugins directly from the Plugin Management page or by calling the new `/api/v3/display/on-demand/*` endpoints described below. The legacy quick-start steps are still documented for bespoke integrations.
-
-## ✅ Built-In Controls
-
-### Web Interface (no-code)
-
-- Navigate to **Settings → Plugin Management**.
-- Each installed plugin now exposes a **Run On-Demand** button:
-  - Choose the display mode (when a plugin exposes multiple views).
-  - Optionally set a fixed duration (leave blank to use the plugin default or `0` to run until you stop it).
-  - Pin the plugin so rotation stays paused.
-  - The dashboard shows real-time status and lets you stop the session. **Shift+click** the stop button to stop the display service after clearing the plugin.
-- The status card refreshes automatically and indicates whether the display service is running.
-
-### REST Endpoints
-
-All endpoints live under `/api/v3/display/on-demand`.
-
-| Endpoint | Method | Description |
-|----------|--------|-------------|
-| `/status` | GET | Returns the current on-demand state plus display service health. |
-| `/start`  | POST | Requests a plugin/mode to run. Automatically starts the display service (unless `start_service: false`). |
-| `/stop`   | POST | Clears on-demand mode. Include `{"stop_service": true}` to stop the systemd service. |
-
-Example `curl` calls:
-
-```bash
-# Start the default mode for football-scoreboard for 45 seconds
-curl -X POST http://localhost:5000/api/v3/display/on-demand/start \
-     -H "Content-Type: application/json" \
-     -d '{
-            "plugin_id": "football-scoreboard",
-            "duration": 45,
-            "pinned": true
-         }'
-
-# Start by mode name (plugin id inferred automatically)
-curl -X POST http://localhost:5000/api/v3/display/on-demand/start \
-     -H "Content-Type: application/json" \
-     -d '{ "mode": "football_live" }'
-
-# Stop on-demand and shut down the display service
-curl -X POST http://localhost:5000/api/v3/display/on-demand/stop \
-     -H "Content-Type: application/json" \
-     -d '{ "stop_service": true }'
-
-# Check current status
-curl http://localhost:5000/api/v3/display/on-demand/status | jq
-```
-
-**Notes**
-
-- The display controller will honour the plugin’s configured `display_duration` when no duration is provided.
-- When you pass `duration: 0` (or omit it) and `pinned: true`, the plugin stays active until you issue `/stop`.
-- The service automatically resumes normal rotation after the on-demand session expires or is cleared.
-
-## 🚀 Quick Implementation (3 Steps)
-
-> The steps below describe a lightweight custom implementation that predates the built-in API. You generally no longer need this unless you are integrating with a separate control surface.
-
-### Step 1: Add API Endpoint
-
-```python
-# In web_interface/blueprints/api_v3.py
-
-@api_v3.route('/display/show', methods=['POST'])
-def show_on_demand():
-    data = request.json
-    mode = data.get('mode')
-    duration = data.get('duration', 30)  # Default 30 seconds
-    
-    # Get display controller (implementation depends on your setup)
-    controller = get_display_controller()
-    
-    success = controller.show_on_demand(mode, duration=duration)
-    
-    return jsonify({'success': success})
-
-@api_v3.route('/display/clear', methods=['POST'])
-def clear_on_demand():
-    controller = get_display_controller()
-    controller.clear_on_demand()
-    return jsonify({'success': True})
-```
-
-### Step 2: Add UI Button
-
-```html
-<!-- Show weather button -->
-<button onclick="showWeather()">Show Weather Now</button>
-
-<script>
-async function showWeather() {
-    await fetch('/api/v3/display/show', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            mode: 'weather',
-            duration: 30  // Show for 30 seconds
-        })
-    });
-}
-</script>
-```
-
-### Step 3: Done! 🎉
-
-Users can now click the button to show weather immediately!
-
-## 📋 Complete Web UI Example
-
-```html
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Display Control</title>
-    <style>
-        .plugin-card {
-            border: 1px solid #ccc;
-            padding: 15px;
-            margin: 10px;
-            border-radius: 5px;
-        }
-        .show-now-btn {
-            background: #4CAF50;
-            color: white;
-            padding: 10px 20px;
-            border: none;
-            border-radius: 5px;
-            cursor: pointer;
-        }
-        .pin-btn {
-            background: #2196F3;
-            color: white;
-            padding: 10px 20px;
-            border: none;
-            border-radius: 5px;
-            cursor: pointer;
-        }
-        .clear-btn {
-            background: #f44336;
-            color: white;
-            padding: 10px 20px;
-            border: none;
-            border-radius: 5px;
-            cursor: pointer;
-        }
-        #status-bar {
-            background: #ff9800;
-            color: white;
-            padding: 15px;
-            text-align: center;
-            display: none;
-        }
-    </style>
-</head>
-<body>
-    <!-- Status bar (shown when on-demand is active) -->
-    <div id="status-bar">
-        <span id="status-text"></span>
-        <button class="clear-btn" onclick="clearOnDemand()">
-            Return to Rotation
-        </button>
-    </div>
-
-    <!-- Plugin controls -->
-    <div class="plugin-grid">
-        <div class="plugin-card">
-            <h3>⛅ Weather</h3>
-            <button class="show-now-btn" onclick="showPlugin('weather', 30)">
-                Show for 30s
-            </button>
-            <button class="pin-btn" onclick="pinPlugin('weather')">
-                Pin Weather
-            </button>
-        </div>
-
-        <div class="plugin-card">
-            <h3>🏒 Hockey</h3>
-            <button class="show-now-btn" onclick="showPlugin('hockey_live', 45)">
-                Show Live Game
-            </button>
-            <button class="pin-btn" onclick="pinPlugin('hockey_live')">
-                Pin Game
-            </button>
-        </div>
-
-        <div class="plugin-card">
-            <h3>🎵 Music</h3>
-            <button class="show-now-btn" onclick="showPlugin('music', 20)">
-                Show Now Playing
-            </button>
-        </div>
-    </div>
-
-    <script>
-    // Show plugin for specific duration
-    async function showPlugin(mode, duration) {
-        const response = await fetch('/api/v3/display/show', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ mode, duration })
-        });
-        
-        const data = await response.json();
-        if (data.success) {
-            updateStatus();
-        } else {
-            alert('Failed to show plugin');
-        }
-    }
-
-    // Pin plugin (stays until cleared)
-    async function pinPlugin(mode) {
-        const response = await fetch('/api/v3/display/show', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ 
-                mode, 
-                pinned: true 
-            })
-        });
-        
-        const data = await response.json();
-        if (data.success) {
-            updateStatus();
-        }
-    }
-
-    // Clear on-demand and return to rotation
-    async function clearOnDemand() {
-        await fetch('/api/v3/display/clear', { method: 'POST' });
-        updateStatus();
-    }
-
-    // Update status display
-    async function updateStatus() {
-        const response = await fetch('/api/v3/display/on-demand-info');
-        const info = await response.json();
-        
-        const statusBar = document.getElementById('status-bar');
-        const statusText = document.getElementById('status-text');
-        
-        if (info.active) {
-            let text = `Showing: ${info.mode}`;
-            if (info.remaining) {
-                text += ` (${Math.ceil(info.remaining)}s remaining)`;
-            } else if (info.pinned) {
-                text += ' (pinned)';
-            }
-            statusText.textContent = text;
-            statusBar.style.display = 'block';
-        } else {
-            statusBar.style.display = 'none';
-        }
-    }
-
-    // Poll for status updates every second
-    setInterval(updateStatus, 1000);
-    
-    // Initial status check
-    updateStatus();
-    </script>
-</body>
-</html>
-```
-
-## ⚡ Usage Patterns
-
-### Pattern 1: Timed Preview
-```javascript
-// Show for 30 seconds then return to rotation
-showPlugin('weather', 30);
-```
-
-### Pattern 2: Pinned Display
-```javascript
-// Stay on this plugin until manually cleared
-pinPlugin('hockey_live');
-```
-
-### Pattern 3: Quick Check
-```javascript
-// Show for 10 seconds
-showPlugin('clock', 10);
-```
-
-### Pattern 4: Indefinite Display
-```javascript
-// Show until cleared (duration=0)
-fetch('/api/v3/display/show', {
-    method: 'POST',
-    body: JSON.stringify({ mode: 'weather', duration: 0 })
-});
-```
-
-## 📊 Priority Order
-
-```
-User clicks "Show Weather" button
-         ↓
-1. On-Demand (Highest) ← Shows immediately
-2. Live Priority        ← Overridden
-3. Normal Rotation      ← Paused
-```
-
-On-demand has **highest priority** - it overrides everything!
-
-## 🎮 Common Use Cases
-
-### Quick Weather Check
-```html
-<button onclick="showPlugin('weather', 20)">
-    Check Weather
-</button>
-```
-
-### Monitor Live Game
-```html
-<button onclick="pinPlugin('hockey_live')">
-    Watch Game
-</button>
-```
-
-### Test Plugin Configuration
-```html
-<button onclick="showPlugin('my-plugin', 15)">
-    Preview Plugin
-</button>
-```
-
-### Emergency Message
-```html
-<button onclick="pinPlugin('text-display')">
-    Show Alert
-</button>
-```
-
-## 🔧 Duration Options
-
-| Value | Behavior | Example |
-|-------|----------|---------|
-| `30` | Show for 30s then return | Quick preview |
-| `0` | Show until cleared | Extended viewing |
-| `null` | Use plugin's default | Let plugin decide |
-| `pinned: true` | Stay until unpinned | Monitor mode |
-
-## ❓ FAQ
-
-### Q: What happens when duration expires?
-**A:** Display automatically returns to normal rotation (or live priority if active).
-
-### Q: Can I show multiple modes at once?
-**A:** No, only one mode at a time. Last request wins.
-
-### Q: Does it override live games?
-**A:** Yes! On-demand has highest priority, even over live priority.
-
-### Q: How do I go back to normal rotation?
-**A:** Either wait for duration to expire, or call `clearOnDemand()`.
-
-### Q: What if the mode doesn't exist?
-**A:** API returns `success: false` and logs a warning.
-
-## 🐛 Testing
-
-### Test 1: Show for 30 seconds
-```bash
-curl -X POST http://pi-ip:5001/api/v3/display/show \
-  -H "Content-Type: application/json" \
-  -d '{"mode": "weather", "duration": 30}'
-```
-
-### Test 2: Pin mode
-```bash
-curl -X POST http://pi-ip:5001/api/v3/display/show \
-  -H "Content-Type: application/json" \
-  -d '{"mode": "hockey_live", "pinned": true}'
-```
-
-### Test 3: Clear on-demand
-```bash
-curl -X POST http://pi-ip:5001/api/v3/display/clear
-```
-
-### Test 4: Check status
-```bash
-curl http://pi-ip:5001/api/v3/display/on-demand-info
-```
-
-## 📝 Implementation Checklist
-
-- [ ] Add API endpoints to web interface
-- [ ] Add "Show Now" buttons to plugin cards
-- [ ] Add status bar showing current on-demand mode
-- [ ] Add "Clear" button when on-demand active
-- [ ] Add authentication to API endpoints
-- [ ] Test with multiple plugins
-- [ ] Test duration expiration
-- [ ] Test pinned mode
-
-## 📚 Full Documentation
-
-See `ON_DEMAND_DISPLAY_API.md` for:
-- Complete API reference
-- Security best practices
-- Troubleshooting guide
-- Advanced examples
-
-## 🎯 Key Points
-
-1. **User-triggered** - Manual control from web UI
-2. **Highest priority** - Overrides everything
-3. **Auto-clear** - Returns to rotation after duration
-4. **Pin mode** - Stay on mode until manually cleared
-5. **Simple API** - Just 3 endpoints needed
-
-That's it! Your users can now control what shows on the display! 🚀
-

docs/archive/OPTIMAL_WIFI_AP_FAILOVER_SETUP.md

@@ -1,413 +0,0 @@
-# Optimal WiFi Configuration with Failover AP Mode
-
-## Overview
-
-This guide explains the optimal way to configure WiFi with automatic failover to Access Point (AP) mode, ensuring you can always connect to your Raspberry Pi even when the primary WiFi network is unavailable.
-
-## System Architecture
-
-### How It Works
-
-The LEDMatrix WiFi system uses a **grace period mechanism** to prevent false positives from transient network hiccups:
-
-1. **WiFi Monitor Daemon** runs as a background service (every 30 seconds by default)
-2. **Grace Period**: Requires **3 consecutive disconnected checks** before enabling AP mode
-   - At 30-second intervals, this means **90 seconds** of confirmed disconnection
-   - This prevents AP mode from activating during brief network interruptions
-3. **Automatic Failover**: When both WiFi and Ethernet are disconnected for the grace period, AP mode activates
-4. **Automatic Recovery**: When WiFi or Ethernet reconnects, AP mode automatically disables
-
-### Connection Priority
-
-The system checks connections in this order:
-1. **WiFi Connection** (highest priority)
-2. **Ethernet Connection** (fallback)
-3. **AP Mode** (last resort - only when both WiFi and Ethernet are disconnected)
-
-## Optimal Configuration
-
-### Recommended Settings
-
-For a **reliable failover system**, use these settings:
-
-```json
-{
-  "ap_ssid": "LEDMatrix-Setup",
-  "ap_password": "ledmatrix123",
-  "ap_channel": 7,
-  "auto_enable_ap_mode": true,
-  "saved_networks": [
-    {
-      "ssid": "YourPrimaryNetwork",
-      "password": "your-password"
-    }
-  ]
-}
-```
-
-### Key Configuration Options
-
-| Setting | Recommended Value | Purpose |
-|---------|------------------|---------|
-| `auto_enable_ap_mode` | `true` | Enables automatic failover to AP mode |
-| `ap_ssid` | `LEDMatrix-Setup` | Network name for AP mode (customizable) |
-| `ap_password` | `ledmatrix123` | Password for AP mode (change for security) |
-| `ap_channel` | `7` (or 1, 6, 11) | WiFi channel (use non-overlapping channels) |
-| `saved_networks` | Array of networks | Pre-configured networks for quick connection |
-
-## Step-by-Step Setup
-
-### 1. Initial Configuration
-
-**Via Web Interface (Recommended):**
-
-1. Connect to your Raspberry Pi (via Ethernet or existing WiFi)
-2. Navigate to the **WiFi** tab in the web interface
-3. Configure your primary WiFi network:
-   - Click **Scan** to find networks
-   - Select your network from the dropdown
-   - Enter your WiFi password
-   - Click **Connect**
-4. Enable auto-failover:
-   - Toggle **"Auto-Enable AP Mode"** to **ON**
-   - This enables automatic failover when WiFi disconnects
-
-**Via Configuration File:**
-
-```bash
-# Edit the WiFi configuration
-nano config/wifi_config.json
-```
-
-Set `auto_enable_ap_mode` to `true`:
-
-```json
-{
-  "auto_enable_ap_mode": true,
-  ...
-}
-```
-
-### 2. Verify WiFi Monitor Service
-
-The WiFi monitor daemon must be running for automatic failover:
-
-```bash
-# Check service status
-sudo systemctl status ledmatrix-wifi-monitor
-
-# If not running, start it
-sudo systemctl start ledmatrix-wifi-monitor
-
-# Enable on boot
-sudo systemctl enable ledmatrix-wifi-monitor
-```
-
-### 3. Test Failover Behavior
-
-**Test Scenario 1: WiFi Disconnection**
-
-1. Disconnect your WiFi router or move the Pi out of range
-2. Wait **90 seconds** (3 check intervals × 30 seconds)
-3. AP mode should automatically activate
-4. Connect to **LEDMatrix-Setup** network from your device
-5. Access web interface at `http://192.168.4.1:5000`
-
-**Test Scenario 2: WiFi Reconnection**
-
-1. Reconnect WiFi router or move Pi back in range
-2. Within **30 seconds**, AP mode should automatically disable
-3. Pi should reconnect to your primary WiFi network
-
-## How the Grace Period Works
-
-### Disconnected Check Counter
-
-The system uses a **disconnected check counter** to prevent false positives:
-
-```
-Check Interval: 30 seconds (configurable)
-Required Checks: 3 consecutive
-Grace Period: 90 seconds total
-```
-
-**Example Timeline:**
-
-```
-Time 0s:   WiFi disconnects
-Time 30s:  Check 1 - Disconnected (counter = 1)
-Time 60s:  Check 2 - Disconnected (counter = 2)
-Time 90s:  Check 3 - Disconnected (counter = 3) → AP MODE ENABLED
-```
-
-If WiFi reconnects at any point, the counter resets to 0.
-
-### Why Grace Period is Important
-
-Without a grace period, AP mode would activate during:
-- Brief network hiccups
-- Router reboots
-- Temporary signal interference
-- NetworkManager reconnection attempts
-
-The 90-second grace period ensures AP mode only activates when there's a **sustained disconnection**.
-
-## Best Practices
-
-### 1. Security Considerations
-
-**Change Default AP Password:**
-
-```json
-{
-  "ap_password": "your-strong-password-here"
-}
-```
-
-**Use Non-Overlapping WiFi Channels:**
-
-- Channels 1, 6, 11 are non-overlapping (2.4GHz)
-- Choose a channel that doesn't conflict with your primary network
-- Example: If primary network uses channel 1, use channel 11 for AP mode
-
-### 2. Network Configuration
-
-**Save Multiple Networks:**
-
-You can save multiple WiFi networks for automatic connection:
-
-```json
-{
-  "saved_networks": [
-    {
-      "ssid": "Home-Network",
-      "password": "home-password"
-    },
-    {
-      "ssid": "Office-Network",
-      "password": "office-password"
-    }
-  ]
-}
-```
-
-**Note:** Saved networks are stored for reference but connection still requires manual selection or NetworkManager auto-connect.
-
-### 3. Monitoring and Troubleshooting
-
-**Check Service Logs:**
-
-```bash
-# View real-time logs
-sudo journalctl -u ledmatrix-wifi-monitor -f
-
-# View recent logs
-sudo journalctl -u ledmatrix-wifi-monitor -n 50
-```
-
-**Check WiFi Status:**
-
-```bash
-# Via Python
-python3 -c "
-from src.wifi_manager import WiFiManager
-wm = WiFiManager()
-status = wm.get_wifi_status()
-print(f'Connected: {status.connected}')
-print(f'SSID: {status.ssid}')
-print(f'IP: {status.ip_address}')
-print(f'AP Mode: {status.ap_mode_active}')
-print(f'Auto-Enable: {wm.config.get(\"auto_enable_ap_mode\", False)}')
-"
-```
-
-**Check NetworkManager Status:**
-
-```bash
-# View device status
-nmcli device status
-
-# View connections
-nmcli connection show
-
-# View WiFi networks
-nmcli device wifi list
-```
-
-### 4. Customization Options
-
-**Adjust Check Interval:**
-
-Edit the systemd service file:
-
-```bash
-sudo systemctl edit ledmatrix-wifi-monitor
-```
-
-Add:
-
-```ini
-[Service]
-ExecStart=
-ExecStart=/usr/bin/python3 /path/to/LEDMatrix/scripts/utils/wifi_monitor_daemon.py --interval 20
-```
-
-Then restart:
-
-```bash
-sudo systemctl daemon-reload
-sudo systemctl restart ledmatrix-wifi-monitor
-```
-
-**Note:** Changing the interval affects the grace period:
-- 20-second interval = 60-second grace period (3 × 20)
-- 30-second interval = 90-second grace period (3 × 30) ← Default
-- 60-second interval = 180-second grace period (3 × 60)
-
-## Configuration Scenarios
-
-### Scenario 1: Always-On Failover (Recommended)
-
-**Use Case:** Portable device that may lose WiFi connection
-
-**Configuration:**
-```json
-{
-  "auto_enable_ap_mode": true
-}
-```
-
-**Behavior:**
-- AP mode activates automatically after 90 seconds of disconnection
-- Always provides a way to connect to the device
-- Best for devices that move or have unreliable WiFi
-
-### Scenario 2: Manual AP Mode Only
-
-**Use Case:** Stable network connection (e.g., Ethernet or reliable WiFi)
-
-**Configuration:**
-```json
-{
-  "auto_enable_ap_mode": false
-}
-```
-
-**Behavior:**
-- AP mode must be manually enabled via web UI
-- Prevents unnecessary AP mode activation
-- Best for stationary devices with stable connections
-
-### Scenario 3: Ethernet Primary with WiFi Failover
-
-**Use Case:** Device primarily uses Ethernet, WiFi as backup
-
-**Configuration:**
-```json
-{
-  "auto_enable_ap_mode": true
-}
-```
-
-**Behavior:**
-- Ethernet connection prevents AP mode activation
-- If Ethernet disconnects, WiFi is attempted
-- If both disconnect, AP mode activates after grace period
-- Best for devices with both Ethernet and WiFi
-
-## Troubleshooting
-
-### AP Mode Not Activating
-
-**Check 1: Auto-Enable Setting**
-```bash
-cat config/wifi_config.json | grep auto_enable_ap_mode
-```
-Should show `"auto_enable_ap_mode": true`
-
-**Check 2: Service Status**
-```bash
-sudo systemctl status ledmatrix-wifi-monitor
-```
-Service should be `active (running)`
-
-**Check 3: Grace Period**
-- Wait at least 90 seconds after disconnection
-- Check logs: `sudo journalctl -u ledmatrix-wifi-monitor -f`
-
-**Check 4: Ethernet Connection**
-- If Ethernet is connected, AP mode won't activate
-- Disconnect Ethernet to test AP mode
-
-### AP Mode Activating Unexpectedly
-
-**Check 1: Network Stability**
-- Verify WiFi connection is stable
-- Check for router issues or signal problems
-
-**Check 2: Grace Period Too Short**
-- Current grace period is 90 seconds
-- Brief disconnections shouldn't trigger AP mode
-- Check logs for disconnection patterns
-
-**Check 3: Disable Auto-Enable**
-```bash
-# Set to false
-nano config/wifi_config.json
-# Change: "auto_enable_ap_mode": false
-sudo systemctl restart ledmatrix-wifi-monitor
-```
-
-### Cannot Connect to AP Mode
-
-**Check 1: AP Mode Active**
-```bash
-sudo systemctl status hostapd
-sudo systemctl status dnsmasq
-```
-
-**Check 2: Network Interface**
-```bash
-ip addr show wlan0
-```
-Should show IP `192.168.4.1`
-
-**Check 3: Firewall**
-```bash
-sudo iptables -L -n
-```
-Check if port 5000 is accessible
-
-**Check 4: Manual Enable**
-- Try manually enabling AP mode via web UI
-- Or via API: `curl -X POST http://localhost:5001/api/v3/wifi/ap/enable`
-
-## Summary
-
-### Optimal Configuration Checklist
-
-- [ ] `auto_enable_ap_mode` set to `true`
-- [ ] WiFi monitor service running and enabled
-- [ ] Primary WiFi network configured and tested
-- [ ] AP password changed from default
-- [ ] AP channel configured (non-overlapping)
-- [ ] Grace period understood (90 seconds)
-- [ ] Failover behavior tested
-
-### Key Takeaways
-
-1. **Grace Period**: 90 seconds prevents false positives
-2. **Auto-Enable**: Set to `true` for reliable failover
-3. **Service**: WiFi monitor daemon must be running
-4. **Priority**: WiFi → Ethernet → AP Mode
-5. **Automatic**: AP mode disables when WiFi/Ethernet connects
-
-This configuration provides a robust failover system that ensures you can always access your Raspberry Pi, even when the primary network connection fails.
-
-
-
-
-
-
-
-

docs/archive/PERMISSION_MANAGEMENT_GUIDE.md

@@ -1,514 +0,0 @@
-# Permission Management Guide
-
-## Overview
-
-LEDMatrix runs with a dual-user architecture: the main display service runs as `root` (for hardware access), while the web interface runs as a regular user. This guide explains how to properly manage file and directory permissions to ensure both services can access the files they need.
-
-## Table of Contents
-
-1. [Why Permission Management Matters](#why-permission-management-matters)
-2. [Permission Utilities](#permission-utilities)
-3. [When to Use Permission Utilities](#when-to-use-permission-utilities)
-4. [How to Use Permission Utilities](#how-to-use-permission-utilities)
-5. [Common Patterns and Examples](#common-patterns-and-examples)
-6. [Permission Standards](#permission-standards)
-7. [Troubleshooting](#troubleshooting)
-
----
-
-## Why Permission Management Matters
-
-### The Problem
-
-Without proper permission management, you may encounter errors like:
-- `PermissionError: [Errno 13] Permission denied` when saving config files
-- `PermissionError` when downloading team logos
-- Files created by the root service not accessible by the web user
-- Files created by the web user not accessible by the root service
-
-### The Solution
-
-The LEDMatrix codebase includes centralized permission utilities (`src/common/permission_utils.py`) that ensure files and directories are created with appropriate permissions for both users.
-
----
-
-## Permission Utilities
-
-### Available Functions
-
-The permission utilities module provides the following functions:
-
-#### Directory Management
-
-- `ensure_directory_permissions(path: Path, mode: int = 0o775) -> None`
-  - Creates directory if it doesn't exist
-  - Sets permissions to the specified mode
-  - Default mode: `0o775` (rwxrwxr-x) - group-writable
-
-#### File Management
-
-- `ensure_file_permissions(path: Path, mode: int = 0o644) -> None`
-  - Sets permissions on an existing file
-  - Default mode: `0o644` (rw-r--r--) - world-readable
-
-#### Mode Helpers
-
-These functions return the appropriate permission mode for different file types:
-
-- `get_config_file_mode(file_path: Path) -> int`
-  - Returns `0o640` for secrets files, `0o644` for regular config files
-
-- `get_assets_file_mode() -> int`
-  - Returns `0o664` (rw-rw-r--) for asset files (logos, images)
-
-- `get_assets_dir_mode() -> int`
-  - Returns `0o2775` (rwxrwsr-x) for asset directories
-  - Setgid bit enforces inherited group ownership for new files/directories
-
-- `get_config_dir_mode() -> int`
-  - Returns `0o2775` (rwxrwsr-x) for config directories
-  - Setgid bit enforces inherited group ownership for new files/directories
-
-- `get_plugin_file_mode() -> int`
-  - Returns `0o664` (rw-rw-r--) for plugin files
-
-- `get_plugin_dir_mode() -> int`
-  - Returns `0o2775` (rwxrwsr-x) for plugin directories
-  - Setgid bit enforces inherited group ownership for new files/directories
-
-- `get_cache_dir_mode() -> int`
-  - Returns `0o2775` (rwxrwsr-x) for cache directories
-  - Setgid bit enforces inherited group ownership for new files/directories
-
----
-
-## When to Use Permission Utilities
-
-### Always Use Permission Utilities When:
-
-1. **Creating directories** - Use `ensure_directory_permissions()` instead of `os.makedirs()` or `Path.mkdir()`
-2. **Saving files** - Use `ensure_file_permissions()` after writing files
-3. **Downloading assets** - Set permissions after downloading logos, images, or other assets
-4. **Creating config files** - Set permissions after saving configuration files
-5. **Creating cache files** - Set permissions when creating cache directories or files
-6. **Plugin file operations** - Set permissions when plugins create their own files/directories
-
-### You Don't Need Permission Utilities When:
-
-1. **Reading files** - Reading doesn't require permission changes
-2. **Using core utilities** - Core utilities (LogoHelper, CacheManager, ConfigManager) already handle permissions
-3. **Temporary files** - Files in `/tmp` or created with `tempfile` don't need special permissions
-
----
-
-## How to Use Permission Utilities
-
-### Basic Import
-
-```python
-from pathlib import Path
-from src.common.permission_utils import (
-    ensure_directory_permissions,
-    ensure_file_permissions,
-    get_assets_dir_mode,
-    get_assets_file_mode,
-    get_config_dir_mode,
-    get_config_file_mode
-)
-```
-
-### Creating a Directory
-
-**Before (incorrect):**
-```python
-import os
-os.makedirs("assets/sports/logos", exist_ok=True)
-# Problem: Permissions may not be set correctly
-```
-
-**After (correct):**
-```python
-from pathlib import Path
-from src.common.permission_utils import ensure_directory_permissions, get_assets_dir_mode
-
-logo_dir = Path("assets/sports/logos")
-ensure_directory_permissions(logo_dir, get_assets_dir_mode())
-```
-
-### Saving a File
-
-**Before (incorrect):**
-```python
-with open("config/my_config.json", 'w') as f:
-    json.dump(data, f, indent=4)
-# Problem: File may not be readable by root service
-```
-
-**After (correct):**
-```python
-from pathlib import Path
-from src.common.permission_utils import (
-    ensure_directory_permissions,
-    ensure_file_permissions,
-    get_config_dir_mode,
-    get_config_file_mode
-)
-
-config_path = Path("config/my_config.json")
-# Ensure directory exists with proper permissions
-ensure_directory_permissions(config_path.parent, get_config_dir_mode())
-
-# Write file
-with open(config_path, 'w') as f:
-    json.dump(data, f, indent=4)
-
-# Set file permissions
-ensure_file_permissions(config_path, get_config_file_mode(config_path))
-```
-
-### Downloading and Saving an Image
-
-**Before (incorrect):**
-```python
-response = requests.get(image_url)
-with open("assets/sports/logo.png", 'wb') as f:
-    f.write(response.content)
-# Problem: File may not be writable by root service
-```
-
-**After (correct):**
-```python
-from pathlib import Path
-from src.common.permission_utils import (
-    ensure_directory_permissions,
-    ensure_file_permissions,
-    get_assets_dir_mode,
-    get_assets_file_mode
-)
-
-logo_path = Path("assets/sports/logo.png")
-# Ensure directory exists
-ensure_directory_permissions(logo_path.parent, get_assets_dir_mode())
-
-# Download and save
-response = requests.get(image_url)
-with open(logo_path, 'wb') as f:
-    f.write(response.content)
-
-# Set file permissions
-ensure_file_permissions(logo_path, get_assets_file_mode())
-```
-
----
-
-## Common Patterns and Examples
-
-### Pattern 1: Config File Save
-
-```python
-from pathlib import Path
-from src.common.permission_utils import (
-    ensure_directory_permissions,
-    ensure_file_permissions,
-    get_config_dir_mode,
-    get_config_file_mode
-)
-
-def save_config(config_data: dict, config_path: str) -> None:
-    """Save configuration file with proper permissions."""
-    path = Path(config_path)
-    
-    # Ensure directory exists
-    ensure_directory_permissions(path.parent, get_config_dir_mode())
-    
-    # Write file
-    with open(path, 'w') as f:
-        json.dump(config_data, f, indent=4)
-    
-    # Set permissions
-    ensure_file_permissions(path, get_config_file_mode(path))
-```
-
-### Pattern 2: Asset Directory Setup
-
-```python
-from pathlib import Path
-from src.common.permission_utils import (
-    ensure_directory_permissions,
-    get_assets_dir_mode
-)
-
-def setup_asset_directory(base_dir: str, subdir: str) -> Path:
-    """Create asset directory with proper permissions."""
-    asset_dir = Path(base_dir) / subdir
-    ensure_directory_permissions(asset_dir, get_assets_dir_mode())
-    return asset_dir
-```
-
-### Pattern 3: Plugin File Creation
-
-```python
-from pathlib import Path
-from src.common.permission_utils import (
-    ensure_directory_permissions,
-    ensure_file_permissions,
-    get_plugin_dir_mode,
-    get_plugin_file_mode
-)
-
-def save_plugin_data(plugin_id: str, data: dict) -> None:
-    """Save plugin data file with proper permissions."""
-    plugin_dir = Path("plugins") / plugin_id
-    data_file = plugin_dir / "data.json"
-    
-    # Ensure plugin directory exists
-    ensure_directory_permissions(plugin_dir, get_plugin_dir_mode())
-    
-    # Write file
-    with open(data_file, 'w') as f:
-        json.dump(data, f, indent=2)
-    
-    # Set permissions
-    ensure_file_permissions(data_file, get_plugin_file_mode())
-```
-
-### Pattern 4: Cache Directory Creation
-
-```python
-from pathlib import Path
-from src.common.permission_utils import (
-    ensure_directory_permissions,
-    get_cache_dir_mode
-)
-
-def get_cache_directory() -> Path:
-    """Get or create cache directory with proper permissions."""
-    cache_dir = Path("/var/cache/ledmatrix")
-    ensure_directory_permissions(cache_dir, get_cache_dir_mode())
-    return cache_dir
-```
-
-### Pattern 5: Atomic File Write with Permissions
-
-```python
-from pathlib import Path
-import tempfile
-import os
-from src.common.permission_utils import (
-    ensure_directory_permissions,
-    ensure_file_permissions,
-    get_config_dir_mode,
-    get_config_file_mode
-)
-
-def save_config_atomic(config_data: dict, config_path: str) -> None:
-    """Save config file atomically with proper permissions."""
-    path = Path(config_path)
-    
-    # Ensure directory exists
-    ensure_directory_permissions(path.parent, get_config_dir_mode())
-    
-    # Write to temp file first
-    temp_path = path.with_suffix('.tmp')
-    with open(temp_path, 'w') as f:
-        json.dump(config_data, f, indent=4)
-    
-    # Set permissions on temp file
-    ensure_file_permissions(temp_path, get_config_file_mode(path))
-    
-    # Atomic move
-    temp_path.replace(path)
-    
-    # Permissions are preserved after move, but ensure they're correct
-    ensure_file_permissions(path, get_config_file_mode(path))
-```
-
----
-
-## Permission Standards
-
-### File Permissions
-
-| File Type | Mode | Octal | Description |
-|-----------|------|-------|-------------|
-| Config files | `rw-r--r--` | `0o644` | Readable by all, writable by owner |
-| Secrets files | `rw-r-----` | `0o640` | Readable by owner and group only |
-| Asset files | `rw-rw-r--` | `0o664` | Group-writable for root:user access |
-| Plugin files | `rw-rw-r--` | `0o664` | Group-writable for root:user access |
-
-### Directory Permissions
-
-| Directory Type | Mode | Octal | Description |
-|----------------|------|-------|-------------|
-| Config directories | `rwxrwsr-x` | `0o2775` (setgid) | Group-writable with setgid bit for inherited group ownership |
-| Asset directories | `rwxrwsr-x` | `0o2775` (setgid) | Group-writable with setgid bit for inherited group ownership |
-| Plugin directories | `rwxrwsr-x` | `0o2775` (setgid) | Group-writable with setgid bit for inherited group ownership |
-| Cache directories | `rwxrwsr-x` | `0o2775` (setgid) | Group-writable with setgid bit for inherited group ownership |
-
-### Why These Permissions?
-
-- **Group-writable (664)**: Allows both root service and web user to read/write files
-- **Directory setgid bit (2775)**: Ensures new files and directories inherit the group ownership, maintaining consistent permissions
-- **World-readable (644)**: Config files need to be readable by root service
-- **Restricted (640)**: Secrets files should only be readable by owner and group
-
----
-
-## Troubleshooting
-
-### Common Issues
-
-#### Issue: Permission denied when saving config
-
-**Symptoms:**
-```
-PermissionError: [Errno 13] Permission denied: 'config/config.json'
-```
-
-**Solution:**
-Ensure you're using `ensure_directory_permissions()` and `ensure_file_permissions()`:
-
-```python
-from src.common.permission_utils import (
-    ensure_directory_permissions,
-    ensure_file_permissions,
-    get_config_dir_mode,
-    get_config_file_mode
-)
-
-path = Path("config/config.json")
-ensure_directory_permissions(path.parent, get_config_dir_mode())
-# ... write file ...
-ensure_file_permissions(path, get_config_file_mode(path))
-```
-
-#### Issue: Logo downloads fail with permission errors
-
-**Symptoms:**
-```
-PermissionError: Cannot write to directory assets/sports/logos
-```
-
-**Solution:**
-Use permission utilities when creating directories and saving files:
-
-```python
-from src.common.permission_utils import (
-    ensure_directory_permissions,
-    ensure_file_permissions,
-    get_assets_dir_mode,
-    get_assets_file_mode
-)
-
-logo_path = Path("assets/sports/logos/team.png")
-ensure_directory_permissions(logo_path.parent, get_assets_dir_mode())
-# ... download and save ...
-ensure_file_permissions(logo_path, get_assets_file_mode())
-```
-
-#### Issue: Files created by root service not accessible by web user
-
-**Symptoms:**
-- Web interface can't read files created by the service
-- Files show as owned by root with restrictive permissions
-
-**Solution:**
-Always use permission utilities when creating files. The utilities set group-writable permissions (664/775) that allow both users to access files.
-
-#### Issue: Plugin can't write to its directory
-
-**Symptoms:**
-```
-PermissionError: Cannot write to plugins/my-plugin/data.json
-```
-
-**Solution:**
-Use permission utilities in your plugin:
-
-```python
-from src.common.permission_utils import (
-    ensure_directory_permissions,
-    ensure_file_permissions,
-    get_plugin_dir_mode,
-    get_plugin_file_mode
-)
-
-# In your plugin code
-plugin_dir = Path("plugins") / self.plugin_id
-ensure_directory_permissions(plugin_dir, get_plugin_dir_mode())
-# ... create files ...
-ensure_file_permissions(file_path, get_plugin_file_mode())
-```
-
-### Verification
-
-To verify permissions are set correctly:
-
-```bash
-# Check file permissions
-ls -l config/config.json
-# Should show: -rw-r--r-- or -rw-rw-r--
-
-# Check directory permissions
-ls -ld assets/sports/logos
-# Should show: drwxrwxr-x or drwxr-xr-x
-
-# Check if both users can access
-sudo -u root test -r config/config.json && echo "Root can read"
-sudo -u $USER test -r config/config.json && echo "User can read"
-```
-
-### Manual Fix
-
-If you need to manually fix permissions:
-
-```bash
-# Fix assets directory
-sudo ./scripts/fix_perms/fix_assets_permissions.sh
-
-# Fix plugin directory
-sudo ./scripts/fix_perms/fix_plugin_permissions.sh
-
-# Fix config directory
-sudo chmod 755 config
-sudo chmod 644 config/config.json
-sudo chmod 640 config/config_secrets.json
-```
-
----
-
-## Best Practices
-
-1. **Always use permission utilities** when creating files or directories
-2. **Use the appropriate mode helper** (`get_assets_file_mode()`, etc.) rather than hardcoding modes
-3. **Set directory permissions before creating files** in that directory
-4. **Set file permissions immediately after writing** the file
-5. **Use atomic writes** (temp file + move) for critical files like config
-6. **Test with both users** - verify files work when created by root service and web user
-
----
-
-## Integration with Core Utilities
-
-Many core utilities already handle permissions automatically:
-
-- **LogoHelper** (`src/common/logo_helper.py`) - Sets permissions when downloading logos
-- **LogoDownloader** (`src/logo_downloader.py`) - Sets permissions for directories and files
-- **CacheManager** - Sets permissions when creating cache directories
-- **ConfigManager** - Sets permissions when saving config files
-- **PluginManager** - Sets permissions for plugin directories and marker files
-
-If you're using these utilities, you don't need to manually set permissions. However, if you're creating files directly (not through these utilities), you should use the permission utilities.
-
----
-
-## Summary
-
-- **Always use** `ensure_directory_permissions()` when creating directories
-- **Always use** `ensure_file_permissions()` after writing files
-- **Use mode helpers** (`get_assets_file_mode()`, etc.) for consistency
-- **Core utilities handle permissions** - you only need to set permissions for custom file operations
-- **Group-writable permissions (664/775)** allow both root service and web user to access files
-
-For questions or issues, refer to the troubleshooting section or check existing code in the LEDMatrix codebase for examples.
-

docs/archive/PLAN_STATUS.md

@@ -1,157 +0,0 @@
-# Web UI Reliability Plan - Implementation Status
-
-## ✅ Completed
-
-### Phase 1: Foundation & Reliability Layer
-
-- ✅ **1.1 Atomic Configuration Saves** - Fully implemented and integrated
-- ✅ **1.2 Plugin Operation Queue** - Fully implemented and integrated
-- ✅ **1.3 Structured Error Handling** - Fully implemented and integrated
-- ⚠️ **1.4 Health Monitoring** - Created but not fully integrated (not initialized/started)
-
-### Phase 2: State Management & Synchronization
-
-- ✅ **2.1 Centralized Plugin State Management** - Fully implemented and integrated
-- ✅ **2.2 State Reconciliation System** - Fully implemented and integrated
-- ✅ **2.3 API Response Standardization** - Fully implemented and integrated
-
-### Phase 4: Testing & Monitoring
-
-- ✅ **4.2 Structured Logging** - Fully implemented
-- ✅ **4.3 Operation History** - Backend implemented, API endpoints created
-
-## ⚠️ Partially Completed
-
-### Phase 1
-- **1.4 Health Monitoring Infrastructure**
-  - ✅ `health_monitor.py` created
-  - ✅ API endpoints exist (`/plugins/health`)
-  - ✅ Initialized in `app.py` (with graceful fallback if health_tracker not available)
-  - ✅ Started/activated when health_tracker is available
-  - ⚠️ Fully integrated (depends on health_tracker being set by display_controller)
-
-### Phase 3: Frontend Refactoring & UX
-
-- **3.1 Modularize JavaScript**
-  - ✅ All modules created (`api_client.js`, `store_manager.js`, `config_manager.js`, `install_manager.js`, `state_manager.js`, `error_handler.js`)
-  - ✅ **Integrated into templates** - Modules loaded in `base.html` before `plugins_manager.js`
-  - ✅ Modules loaded/imported (using window.* pattern for browser compatibility)
-  - ⚠️ Legacy `plugins_manager.js` still loaded for backward compatibility during migration
-
-- **3.2 Improve Error Messages in UI**
-  - ✅ `error_handler.js` created
-  - ⚠️ Not fully integrated into all plugin management code
-  - ❌ No `error_formatter.js` for user-friendly messages
-  - ❌ No "Copy error details" button
-  - ❌ No links to troubleshooting docs
-
-- **3.3 Configuration UI Enhancements**
-  - ❌ No config diff viewer
-  - ❌ No real-time validation feedback
-  - ❌ No config export/import functionality
-  - ❌ No config templates/presets
-
-### Phase 4: Testing & Monitoring
-
-- **4.1 Testing Infrastructure**
-  - ✅ `test_config_manager_atomic.py` - Created
-  - ✅ `test_plugin_operation_queue.py` - Created
-  - ❌ `test_state_reconciliation.py` - **Missing**
-  - ❌ Integration tests in `test/web_interface/integration/` - **Empty directory**
-
-- **4.3 Operation History & Audit Log**
-  - ✅ Backend implemented (`operation_history.py`)
-  - ✅ API endpoints created
-  - ✅ **UI template created** (`operation_history.html`)
-  - ✅ UI for viewing history with filtering, search, and pagination
-  - ✅ Tab added to navigation menu
-
-## 📋 Remaining Work Summary
-
-### High Priority (Core Functionality)
-
-1. ✅ **Integrate JavaScript Modules** (Phase 3.1) - **COMPLETED**
-   - ✅ Updated `base.html` to load new modules
-   - ✅ Modules loaded in correct order (utilities first, then API client, then managers)
-   - ⚠️ Legacy `plugins_manager.js` still loaded for backward compatibility
-
-2. ✅ **Initialize Health Monitoring** (Phase 1.4) - **COMPLETED**
-   - ✅ Initialized `PluginHealthMonitor` in `app.py`
-   - ✅ Monitoring thread started when health_tracker is available
-   - ✅ Graceful fallback if health_tracker not set
-
-3. ✅ **Operation History UI** (Phase 4.3) - **COMPLETED**
-   - ✅ Created `operation_history.html` template
-   - ✅ UI for viewing operation history with table display
-   - ✅ Filtering (plugin, operation type, status) and search capabilities
-   - ✅ Pagination support
-   - ✅ Tab added to navigation menu
-
-### Medium Priority (User Experience)
-
-4. ✅ **Error Message Improvements** (Phase 3.2) - **COMPLETED**
-   - ✅ Enhanced `error_handler.js` with comprehensive error code mappings
-   - ✅ Added rich error modal with "Copy error details" button
-   - ✅ Added troubleshooting documentation links
-   - ✅ Integrated error display with suggestions and context
-   - ⚠️ Can be further integrated into all error displays (modules already use it)
-
-5. ✅ **Configuration UI Enhancements** (Phase 3.3) - **PARTIALLY COMPLETED**
-   - ✅ Created config diff viewer (`diff_viewer.js`)
-   - ✅ Diff viewer shows added, removed, and changed configuration keys
-   - ✅ Visual diff display with color coding
-   - ⚠️ Needs integration into config save flow (can be added to `config_manager.js`)
-   - ❌ Real-time validation feedback (can be added later)
-   - ❌ Config export/import (can be added later)
-   - ❌ Config templates/presets (can be added later)
-
-### Low Priority (Testing & Polish)
-
-6. ✅ **Complete Testing Infrastructure** (Phase 4.1) - **COMPLETED**
-   - ✅ Created `test_state_reconciliation.py` with comprehensive tests
-   - ✅ Added integration tests for plugin operations (`test_plugin_operations.py`)
-   - ✅ Added integration tests for config flows (`test_config_flows.py`)
-   - ✅ Tests cover install/update/uninstall flows
-   - ✅ Tests cover config save/rollback flows
-   - ✅ Tests cover state reconciliation scenarios
-   - ✅ Tests cover error handling and edge cases
-
-## Files That Need Updates
-
-1. **`web_interface/templates/v3/base.html`**
-   - Replace `plugins_manager.js` with new modular JavaScript files
-   - Add module imports
-
-2. **`web_interface/app.py`**
-   - Initialize `PluginHealthMonitor`
-   - Start health monitoring
-
-3. **`web_interface/templates/v3/partials/operation_history.html`** (NEW)
-   - Create UI for viewing operation history
-
-4. **`web_interface/static/v3/js/utils/error_formatter.js`** (NEW)
-   - User-friendly error formatting
-
-5. **`web_interface/static/v3/js/config/diff_viewer.js`** (NEW)
-   - Config diff functionality
-
-6. **`test/web_interface/test_state_reconciliation.py`** (NEW)
-   - State reconciliation tests
-
-7. **`test/web_interface/integration/`** (NEW FILES)
-   - Integration tests for full flows
-
-## Estimated Remaining Work
-
-- **High Priority**: ~4-6 hours
-- **Medium Priority**: ~6-8 hours  
-- **Low Priority**: ~4-6 hours
-- **Total**: ~14-20 hours
-
-## Next Steps Recommendation
-
-1. **Start with High Priority items** - These are core functionality gaps
-2. **Integrate JavaScript modules** - This is blocking frontend improvements
-3. **Initialize health monitoring** - Quick win, just needs initialization
-4. **Add operation history UI** - Users can see what's happening
-

docs/archive/PLUGIN_CONFIG_IMPROVEMENTS_COMPARISON.md

@@ -1,293 +0,0 @@
-# Plugin Configuration System: Old vs New Comparison
-
-## Overview
-
-This document explains how the new plugin configuration system improves upon the previous implementation, addressing reliability issues and providing a more scalable, user-friendly experience.
-
-## Key Problems with the Previous System
-
-### 1. **Unreliable Schema Loading**
-**Old System:**
-- Schema files loaded directly from filesystem on every request
-- Multiple fallback paths tried sequentially (inefficient)
-- No caching, leading to excessive file I/O
-- Path resolution was fragile and could fail silently
-- Schema loading errors weren't handled gracefully
-
-**New System:**
-- Centralized `SchemaManager` with intelligent path resolution
-- In-memory caching reduces file I/O by ~90%
-- Handles multiple plugin directory locations reliably
-- Case-insensitive directory matching
-- Manifest-based plugin discovery as fallback
-- Graceful error handling with fallback defaults
-
-### 2. **No Server-Side Validation**
-**Old System:**
-- Configuration saved without validation
-- Invalid configs could be saved, causing runtime errors
-- No type checking (strings saved as numbers, etc.)
-- No constraint validation (min/max, enum values, etc.)
-- Errors only discovered when plugin tried to use invalid config
-
-**New System:**
-- **Pre-save validation** using JSON Schema Draft-07 standard
-- Validates all types, constraints, and required fields
-- Returns detailed error messages with field paths
-- Prevents invalid configs from being saved
-- Uses industry-standard `jsonschema` library
-
-### 3. **No Default Value Management**
-**Old System:**
-- Defaults had to be hardcoded in multiple places
-- No automatic default extraction from schemas
-- Missing values could cause plugin failures
-- Inconsistent default handling across plugins
-
-**New System:**
-- **Automatic default extraction** from JSON Schema
-- Recursively handles nested objects and arrays
-- Defaults merged intelligently with user values
-- Single source of truth (schema file)
-- Reset to defaults functionality
-
-### 4. **Limited User Interface**
-**Old System:**
-- Form-based editing only
-- No way to edit complex nested configs easily
-- No validation feedback until save
-- No reset functionality
-- Errors shown only as generic messages
-
-**New System:**
-- **Dual interface**: Form view + JSON editor
-- CodeMirror editor with syntax highlighting
-- Real-time JSON validation
-- Inline validation error display
-- Reset to defaults button
-- Better error messages with field paths
-
-### 5. **No Configuration Cleanup**
-**Old System:**
-- Plugin configs left in files after uninstall
-- Orphaned configs accumulated over time
-- Manual cleanup required
-- Could cause confusion with reinstalled plugins
-
-**New System:**
-- **Automatic cleanup** on uninstall (optional)
-- `cleanup_orphaned_plugin_configs()` utility
-- Keeps config files clean
-- Prevents stale config issues
-
-### 6. **Fragile Form-to-Config Conversion**
-**Old System:**
-- Type conversion logic scattered in form handler
-- Nested configs handled inconsistently
-- Dot notation parsing was error-prone
-- Array handling was basic (comma-separated only)
-
-**New System:**
-- **Schema-driven type conversion**
-- Proper nested object handling
-- Robust dot notation parsing
-- Handles arrays, objects, and all JSON types
-- Deep merge preserves existing nested structures
-
-## Detailed Improvements
-
-### Schema Management
-
-#### Before:
-```python
-# Old: Direct file loading, no caching
-schema_path = plugins_dir / plugin_id / 'config_schema.json'
-if schema_path.exists():
-    with open(schema_path, 'r') as f:
-        schema = json.load(f)
-# No error handling, no fallback paths
-```
-
-#### After:
-```python
-# New: Cached, reliable, with fallbacks
-schema = schema_mgr.load_schema(plugin_id, use_cache=True)
-# - Checks cache first
-# - Tries multiple paths intelligently
-# - Handles errors gracefully
-# - Returns None if not found (safe)
-```
-
-### Validation
-
-#### Before:
-```python
-# Old: No validation before save
-# Config saved directly, errors discovered at runtime
-api_v3.config_manager.save_config(current_config)
-```
-
-#### After:
-```python
-# New: Validate before save
-is_valid, errors = schema_mgr.validate_config_against_schema(
-    plugin_config, schema, plugin_id
-)
-if not is_valid:
-    return jsonify({
-        'status': 'error',
-        'validation_errors': errors  # Detailed field-level errors
-    }), 400
-# Only saves if valid
-```
-
-### Default Generation
-
-#### Before:
-```python
-# Old: Hardcoded defaults or missing
-config = {
-    'enabled': False,  # Hardcoded
-    'display_duration': 15  # Hardcoded
-}
-# No way to get defaults from schema
-```
-
-#### After:
-```python
-# New: Extracted from schema automatically
-defaults = schema_mgr.generate_default_config(plugin_id)
-# Recursively extracts all defaults from schema
-# Handles nested objects, arrays, all types
-# Merges with user values intelligently
-```
-
-### User Interface
-
-#### Before:
-- Single form view
-- No JSON editing
-- Generic error messages
-- No reset functionality
-
-#### After:
-- **Form View**: User-friendly form with proper input types
-- **JSON View**: Full JSON editor with syntax highlighting
-- **Toggle**: Easy switching between views
-- **Validation Errors**: Detailed, field-specific error messages
-- **Reset Button**: One-click reset to schema defaults
-- **Real-time Feedback**: JSON syntax validation as you type
-
-## Reliability Improvements
-
-### 1. **Path Resolution**
-- **Old**: Single path, fails if plugin in different location
-- **New**: Multiple fallback paths, case-insensitive matching, manifest-based discovery
-
-### 2. **Error Handling**
-- **Old**: Silent failures, generic error messages
-- **New**: Detailed errors with field paths, graceful fallbacks
-
-### 3. **Type Safety**
-- **Old**: No type checking, strings could be saved as numbers
-- **New**: Full type validation against schema, automatic type coercion
-
-### 4. **State Management**
-- **Old**: Config state scattered, no central management
-- **New**: Centralized `currentPluginConfigState` object, proper cleanup
-
-### 5. **Cache Management**
-- **Old**: No caching, repeated file reads
-- **New**: In-memory cache with invalidation on plugin changes
-
-## Scalability Improvements
-
-### 1. **Dynamic Plugin Support**
-- System automatically adapts as plugins are installed/removed
-- Config sections added/removed automatically
-- Schema cache invalidated on changes
-- No manual configuration file editing needed
-
-### 2. **Schema-Driven**
-- All behavior derived from plugin schemas
-- New plugin features (nested configs, arrays, etc.) work automatically
-- No code changes needed for new schema types
-
-### 3. **Performance**
-- Schema caching reduces file I/O by ~90%
-- Defaults caching prevents repeated extraction
-- Efficient validation using compiled validators
-
-### 4. **Maintainability**
-- Single source of truth (schema files)
-- Centralized validation logic
-- Reusable SchemaManager class
-- Clear separation of concerns
-
-## User Experience Improvements
-
-### Before:
-1. Edit form fields
-2. Save (no validation feedback)
-3. Discover errors at runtime
-4. Manually edit config.json to fix
-5. No way to reset to defaults
-
-### After:
-1. **Choose view**: Form or JSON editor
-2. **Edit with validation**: Real-time feedback
-3. **Save with validation**: Detailed errors if invalid
-4. **Reset if needed**: One-click reset to defaults
-5. **Type-safe editing**: JSON editor with syntax highlighting
-
-## Technical Benefits
-
-### Code Quality
-- **Separation of Concerns**: SchemaManager handles all schema operations
-- **DRY Principle**: No duplicated schema loading/validation code
-- **Type Safety**: Proper validation prevents runtime errors
-- **Error Handling**: Comprehensive error handling throughout
-
-### Testing
-- **Testable Components**: SchemaManager can be unit tested
-- **Validation Logic**: Centralized, easy to test
-- **Error Cases**: All error paths handled
-
-### Extensibility
-- **Easy to Add Features**: New schema features work automatically
-- **Plugin-Friendly**: Plugins just need valid JSON Schema
-- **Future-Proof**: Uses industry standards (JSON Schema Draft-07)
-
-## Migration Path
-
-The new system is **backward compatible**:
-- Existing configs continue to work
-- Old plugins without schemas get default schema
-- Gradual migration as plugins add schemas
-- No breaking changes to existing functionality
-
-## Performance Metrics
-
-### Schema Loading
-- **Old**: ~50-100ms per request (file I/O)
-- **New**: ~1-5ms per request (cached) - **10-20x faster**
-
-### Validation
-- **Old**: No validation (errors at runtime)
-- **New**: ~5-10ms validation (prevents runtime errors)
-
-### Default Generation
-- **Old**: N/A (hardcoded)
-- **New**: ~2-5ms (cached after first generation)
-
-## Conclusion
-
-The new system provides:
-- ✅ **Reliability**: Proper validation, error handling, path resolution
-- ✅ **Scalability**: Automatic adaptation to plugin changes
-- ✅ **User Experience**: Dual interface, validation feedback, reset functionality
-- ✅ **Maintainability**: Centralized logic, schema-driven, well-structured
-- ✅ **Performance**: Caching, efficient validation, reduced I/O
-
-The previous system was functional but fragile. The new system is production-ready, scalable, and provides a much better user experience.
-

docs/archive/PLUGIN_CONFIG_SYSTEM_EXPLANATION.md

@@ -1,336 +0,0 @@
-# Plugin Configuration System: How It's Better
-
-## Executive Summary
-
-The new plugin configuration system solves critical reliability and scalability issues in the previous implementation. It provides **server-side validation**, **automatic default management**, **dual editing interfaces**, and **intelligent caching** - making the system production-ready and user-friendly.
-
-## Problems Solved
-
-### Problem 1: "Configuration settings aren't working reliably"
-
-**Root Cause**: No validation before saving, schema loading was fragile, defaults were hardcoded.
-
-**Solution**:
-- ✅ **Pre-save validation** using JSON Schema Draft-07
-- ✅ **Reliable schema loading** with caching and multiple fallback paths
-- ✅ **Automatic default extraction** from schemas
-- ✅ **Detailed error messages** showing exactly what's wrong
-
-**Before**: Invalid configs saved → runtime errors → user confusion
-**After**: Invalid configs rejected → clear error messages → user fixes immediately
-
-### Problem 2: "Config schema isn't working as reliably as hoped"
-
-**Root Cause**: Schema files loaded on every request, path resolution was fragile, no caching.
-
-**Solution**:
-- ✅ **SchemaManager** with intelligent path resolution
-- ✅ **In-memory caching** (10-20x faster)
-- ✅ **Multiple fallback paths** (handles different plugin directory locations)
-- ✅ **Case-insensitive matching** (handles naming mismatches)
-- ✅ **Manifest-based discovery** (finds plugins even with directory name mismatches)
-
-**Before**: Schema loading failed silently, slow performance, fragile paths
-**After**: Reliable loading, fast performance, robust path resolution
-
-### Problem 3: "Need scalable system that grows/shrinks with plugins"
-
-**Root Cause**: Manual config management, no automatic cleanup, orphaned configs accumulated.
-
-**Solution**:
-- ✅ **Automatic config cleanup** on plugin uninstall
-- ✅ **Orphaned config detection** and cleanup utility
-- ✅ **Dynamic schema loading** (no hardcoded plugin lists)
-- ✅ **Cache invalidation** on plugin lifecycle events
-
-**Before**: Manual cleanup required, orphaned configs, doesn't scale
-**After**: Automatic management, clean configs, scales infinitely
-
-### Problem 4: "Web interface not accurately saving configuration"
-
-**Root Cause**: No validation, type conversion issues, nested configs handled incorrectly.
-
-**Solution**:
-- ✅ **Server-side validation** before save
-- ✅ **Schema-driven type conversion**
-- ✅ **Proper nested config handling** (deep merge)
-- ✅ **Validation error display** in UI
-
-**Before**: Configs saved incorrectly, type mismatches, nested values lost
-**After**: Configs validated and saved correctly, proper types, nested values preserved
-
-### Problem 5: "Need JSON editor for typed changes"
-
-**Root Cause**: Form-only interface, difficult to edit complex nested configs.
-
-**Solution**:
-- ✅ **CodeMirror JSON editor** with syntax highlighting
-- ✅ **Real-time JSON validation**
-- ✅ **Toggle between form and JSON views**
-- ✅ **Bidirectional sync** between views
-
-**Before**: Form-only, difficult for complex configs
-**After**: Dual interface, easy editing for all config types
-
-### Problem 6: "Need reset to defaults button"
-
-**Root Cause**: No way to reset configs, had to manually edit files.
-
-**Solution**:
-- ✅ **Reset endpoint** (`/api/v3/plugins/config/reset`)
-- ✅ **Reset button** in UI
-- ✅ **Preserves secrets** by default
-- ✅ **Regenerates form** with defaults
-
-**Before**: Manual file editing required
-**After**: One-click reset with confirmation
-
-## Technical Improvements
-
-### 1. Schema Management Architecture
-
-**Old Approach**:
-```text
-Every Request:
-  → Try path 1
-  → Try path 2
-  → Try path 3
-  → Load file
-  → Parse JSON
-  → Return schema
-```
-**Problems**: Slow, fragile, no caching, errors not handled
-
-**New Approach**:
-```
-First Request:
-  → Check cache (miss)
-  → Intelligent path resolution
-  → Load and validate schema
-  → Cache schema
-  → Return schema
-
-Subsequent Requests:
-  → Check cache (hit)
-  → Return schema immediately
-```
-**Benefits**: 10-20x faster, reliable, cached, error handling
-
-### 2. Validation Architecture
-
-**Old Approach**:
-```text
-Save Request:
-  → Accept config
-  → Save directly
-  → Errors discovered at runtime
-```
-**Problems**: Invalid configs saved, runtime errors, poor UX
-
-**New Approach**:
-```
-Save Request:
-  → Load schema (cached)
-  → Inject core properties (enabled, display_duration, live_priority) into schema
-  → Remove core properties from required array (system-managed)
-  → Validate config against schema
-  → If invalid: return detailed errors
-  → If valid: apply defaults (including core property defaults)
-  → Separate secrets
-  → Save configs
-  → Notify plugin
-```
-**Benefits**: Invalid configs rejected, clear errors, proper defaults, system-managed properties handled correctly
-
-### 3. Default Management
-
-**Old Approach**:
-```python
-# Hardcoded in multiple places
-defaults = {
-    'enabled': False,
-    'display_duration': 15
-}
-```
-**Problems**: Duplicated, inconsistent, not schema-driven
-
-**New Approach**:
-```python
-# Extracted from schema automatically
-defaults = schema_mgr.extract_defaults_from_schema(schema)
-# Recursively handles nested objects, arrays, all types
-```
-**Benefits**: Single source of truth, consistent, schema-driven
-
-### 4. User Interface
-
-**Old Approach**:
-- Single form view
-- No validation feedback
-- Generic error messages
-- No reset functionality
-
-**New Approach**:
-- **Dual interface**: Form + JSON editor
-- **Real-time validation**: JSON syntax checked as you type
-- **Detailed errors**: Field-level error messages
-- **Reset button**: One-click reset to defaults
-- **Better UX**: Toggle views, see errors immediately
-
-## Reliability Improvements
-
-### Before vs After
-
-| Aspect | Before | After |
-|--------|--------|-------|
-| **Schema Loading** | Fragile, slow, no caching | Reliable, fast, cached |
-| **Validation** | None (runtime errors) | Pre-save validation |
-| **Error Messages** | Generic | Detailed with field paths |
-| **Default Management** | Hardcoded, inconsistent | Schema-driven, automatic |
-| **Nested Configs** | Handled incorrectly | Proper deep merge |
-| **Type Safety** | No type checking | Full type validation |
-| **Config Cleanup** | Manual | Automatic |
-| **Path Resolution** | Single path, fails easily | Multiple paths, robust |
-
-## Performance Improvements
-
-### Schema Loading
-- **Before**: 50-100ms per request (file I/O every time)
-- **After**: 1-5ms per request (cached) - **10-20x faster**
-
-### Validation
-- **Before**: No validation (errors discovered at runtime)
-- **After**: 5-10ms validation (prevents runtime errors)
-
-### Default Generation
-- **Before**: N/A (hardcoded)
-- **After**: 2-5ms (cached after first generation)
-
-## User Experience Improvements
-
-### Configuration Editing
-
-**Before**:
-1. Edit form
-2. Save (no feedback)
-3. Discover errors later
-4. Manually edit config.json
-5. Restart service
-
-**After**:
-1. Choose view (Form or JSON)
-2. Edit with real-time validation
-3. Save with immediate feedback
-4. See detailed errors if invalid
-5. Reset to defaults if needed
-6. All changes validated before save
-
-### Error Handling
-
-**Before**:
-- Generic error: "Error saving configuration"
-- No indication of what's wrong
-- Must check logs or config file
-
-**After**:
-- Detailed errors: "Field 'nfl.live_priority': Expected type boolean, got string"
-- Field paths shown
-- Errors displayed in UI
-- Clear guidance on how to fix
-
-## Scalability
-
-### Plugin Installation/Removal
-
-**Before**:
-- Config sections manually added/removed
-- Orphaned configs accumulate
-- Manual cleanup required
-
-**After**:
-- Config sections automatically managed
-- Orphaned configs detected and cleaned
-- Automatic cleanup on uninstall
-- System adapts automatically
-
-### Schema Evolution
-
-**Before**:
-- Schema changes require code updates
-- Defaults hardcoded in multiple places
-- Validation logic scattered
-
-**After**:
-- Schema changes work automatically
-- Defaults extracted from schema
-- Validation logic centralized
-- No code changes needed for new schema features
-
-## Code Quality
-
-### Architecture
-
-**Before**:
-- Schema loading duplicated
-- Validation logic scattered
-- No centralized management
-
-**After**:
-- **SchemaManager**: Centralized schema operations
-- **Single responsibility**: Each component has clear purpose
-- **DRY principle**: No code duplication
-- **Separation of concerns**: Clear boundaries
-
-### Maintainability
-
-**Before**:
-- Changes require updates in multiple places
-- Hard to test
-- Error-prone
-
-**After**:
-- Changes isolated to specific components
-- Easy to test (unit testable components)
-- Type-safe and validated
-
-## Verification
-
-### How We Know It Works
-
-1. **Schema Loading**: ✅ Tested with multiple plugin locations, case variations
-2. **Validation**: ✅ Uses industry-standard jsonschema library (Draft-07)
-3. **Default Extraction**: ✅ Handles all JSON Schema types (tested recursively)
-4. **Caching**: ✅ Cache hit/miss logic verified, invalidation tested
-5. **Frontend Sync**: ✅ Form ↔ JSON sync tested with nested configs
-6. **Error Handling**: ✅ All error paths have proper handling
-7. **Edge Cases**: ✅ Missing schemas, invalid JSON, nested configs all handled
-
-### Testing Coverage
-
-**Backend**:
-- ✅ Schema loading with various paths
-- ✅ Validation with invalid configs
-- ✅ Default generation with nested schemas
-- ✅ Cache invalidation
-- ✅ Config cleanup
-
-**Frontend**:
-- ✅ JSON editor initialization
-- ✅ View switching
-- ✅ Form/JSON sync
-- ✅ Reset functionality
-- ✅ Error display
-
-## Conclusion
-
-The new system is **significantly better** than the previous implementation:
-
-1. **More Reliable**: Validation prevents errors, robust path resolution
-2. **More Scalable**: Automatic management, adapts to plugin changes
-3. **Better UX**: Dual interface, validation feedback, reset functionality
-4. **Better Performance**: Caching reduces I/O by 90%
-5. **More Maintainable**: Centralized logic, schema-driven, well-structured
-6. **Production-Ready**: Comprehensive error handling, edge cases covered
-
-The previous system worked but was fragile. The new system is robust, scalable, and provides an excellent user experience.
-

docs/archive/PLUGIN_CONFIG_SYSTEM_IMPROVEMENTS_PROGRESS.md

@@ -1,183 +0,0 @@
-# Plugin Configuration System Improvements - Progress
-
-## Overview
-This document tracks the progress of implementing improvements to the plugin configuration system for better reliability, scalability, and user experience.
-
-## Completed Items
-
-### Backend Implementation (100% Complete)
-
-#### 1. Schema Management System ✅
-- **Created**: `src/plugin_system/schema_manager.py`
-  - Schema caching with invalidation support
-  - Reliable path resolution for schema files (handles multiple plugin directory locations)
-  - Default value extraction from JSON Schema (recursive, handles nested objects and arrays)
-  - Configuration validation against schema using jsonschema library
-  - Detailed error reporting with field paths
-  - Default config generation from schemas
-
-#### 2. API Endpoints Enhanced ✅
-- **Updated**: `web_interface/blueprints/api_v3.py`
-  - `save_plugin_config()`: Now validates config against schema before saving, applies defaults, returns detailed validation errors
-  - `get_plugin_schema()`: Uses SchemaManager with caching support
-  - **New**: `reset_plugin_config()`: Resets plugin config to schema defaults, supports preserving secrets
-  - Schema cache invalidation integrated into install/update/uninstall endpoints
-
-#### 3. Configuration Management ✅
-- **Updated**: `src/config_manager.py`
-  - `cleanup_plugin_config()`: Removes plugin config from main and secrets files
-  - `cleanup_orphaned_plugin_configs()`: Removes configs for uninstalled plugins
-  - `validate_all_plugin_configs()`: Validates all plugin configs against their schemas
-
-#### 4. Plugin Lifecycle Integration ✅
-- **Updated**: Uninstall/Install/Update endpoints
-  - Automatic schema cache invalidation on plugin changes
-  - Optional config cleanup on uninstall (preserve_config flag)
-  - Schema reloading after plugin updates
-
-#### 5. Dependencies ✅
-- **Updated**: `requirements.txt`
-  - Added `jsonschema>=4.20.0,<5.0.0` for comprehensive schema validation
-
-#### 6. Initialization ✅
-- **Updated**: `web_interface/app.py`
-  - SchemaManager initialization and registration with API blueprint
-
-## Completed Items (Frontend)
-
-### Frontend Implementation (100% Complete) ✅
-
-#### 1. JSON Editor Integration ✅
-- **Added**: CodeMirror editor to plugin config modal
-- **Features**: 
-  - Syntax highlighting for JSON
-  - Real-time JSON syntax validation
-  - Line numbers and code folding
-  - Auto-close brackets and match brackets
-  - Monokai theme for better readability
-  - Error highlighting for invalid JSON
-
-#### 2. Form/Editor Sync ✅
-- **View Toggle**: Form/JSON toggle buttons in modal header
-- **Bidirectional Sync**: 
-  - Form → JSON: Syncs form data to JSON editor when switching to JSON view
-  - JSON → Form: Updates config state when switching back (form regenerated on next open)
-- **State Management**: Centralized state object (`currentPluginConfigState`) tracks plugin ID, config, schema, and editor instance
-
-#### 3. UI Enhancements ✅
-- **Reset Button**: Yellow "Reset" button in modal header that calls `/api/v3/plugins/config/reset`
-  - Confirmation dialog before reset
-  - Preserves secrets by default
-  - Regenerates form with defaults
-  - Updates JSON editor if visible
-- **Validation Error Display**: 
-  - Red error banner at top of modal
-  - Lists all validation errors from server
-  - Automatically shown when save fails with validation errors
-  - Hidden on successful save
-- **Better Error Messages**: 
-  - Server-side validation errors displayed inline
-  - JSON syntax errors shown in editor and error banner
-  - Clear error messages for all failure scenarios
-
-## Implementation Details
-
-### Schema Validation
-- Uses JSON Schema Draft-07 specification
-- Validates all schema types: boolean, string, number, integer, array, object, enum
-- Recursively validates nested objects
-- Validates constraints: min, max, minLength, maxLength, minItems, maxItems
-- Validates required fields
-- Provides detailed error messages with field paths
-
-### Default Generation
-- Recursively extracts defaults from schema properties
-- Handles nested objects and arrays
-- Merges user config with defaults (preserves user values)
-- Supports all JSON Schema default value types
-
-### Cache Management
-- Schema cache stored in memory per plugin
-- Cache invalidation on:
-  - Plugin install
-  - Plugin update
-  - Plugin uninstall
-- Defaults cache invalidated when schema changes
-
-### Configuration Cleanup
-- On plugin uninstall (if preserve_config=False):
-  - Removes plugin section from config.json
-  - Removes plugin section from config_secrets.json
-- Orphaned config cleanup utility available
-- Can be called manually or scheduled
-
-## Implementation Summary
-
-### Files Modified/Created
-
-**Backend:**
-- ✅ `src/plugin_system/schema_manager.py` (NEW) - Schema management with caching and validation
-- ✅ `web_interface/blueprints/api_v3.py` - Enhanced endpoints with validation
-- ✅ `src/config_manager.py` - Added cleanup and validation methods
-- ✅ `web_interface/app.py` - SchemaManager initialization
-- ✅ `requirements.txt` - Added jsonschema library
-
-**Frontend:**
-- ✅ `web_interface/templates/v3/base.html` - Added CodeMirror CDN links
-- ✅ `web_interface/templates/v3/partials/plugins.html` - Complete UI overhaul:
-  - Modal structure with view toggle
-  - JSON editor integration
-  - Reset button
-  - Validation error display
-  - Bidirectional sync functions
-  - CSS styles for editor and toggle buttons
-
-## Testing Status
-
-### Backend Testing Needed
-- [ ] Test schema validation with various invalid configs
-- [ ] Test default generation with nested schemas
-- [ ] Test reset endpoint with preserve_secrets flag
-- [ ] Test cache invalidation on plugin lifecycle events
-- [ ] Test config cleanup on uninstall
-- [ ] Test orphaned config cleanup
-
-### Frontend Testing Needed
-- [ ] Test JSON editor integration and syntax highlighting
-- [ ] Test form/editor sync (both directions)
-- [ ] Test reset to defaults button
-- [ ] Test validation error display with various error types
-- [ ] Test error handling for malformed JSON
-- [ ] Test view switching with unsaved changes
-- [ ] Test CodeMirror editor initialization and cleanup
-
-## Next Steps
-
-1. **Testing & Validation**
-   - Test all new features end-to-end
-   - Verify schema validation works correctly
-   - Test edge cases (nested configs, arrays, etc.)
-   - Test with various plugin schemas
-
-2. **Potential Enhancements** (Future)
-   - Add change detection warning when switching views with unsaved changes
-   - Add JSON auto-format button
-   - Add field-level validation errors (show errors next to specific fields)
-   - Add config diff view (show what changed)
-   - Add config export/import functionality
-   - Add config history/versioning
-
-3. **Documentation**
-   - Update user documentation with new features
-   - Document JSON editor usage
-   - Document reset functionality
-   - Document validation error handling
-
-## Notes
-
-- All backend endpoints are complete and functional
-- Schema validation uses industry-standard jsonschema library
-- Cache management ensures fresh schemas without excessive file I/O
-- Configuration cleanup maintains config file hygiene
-- Reset functionality preserves secrets by default (good security practice)
-

docs/archive/PLUGIN_CONFIG_SYSTEM_VERIFICATION.md

@@ -1,345 +0,0 @@
-# Plugin Configuration System Verification
-
-## Implementation Verification
-
-### Backend Components ✅
-
-#### 1. SchemaManager (`src/plugin_system/schema_manager.py`)
-**Status**: ✅ Complete and Verified
-
-**Key Functions:**
-- `get_schema_path()`: ✅ Handles multiple plugin directory locations, case-insensitive matching
-- `load_schema()`: ✅ Caching implemented, error handling present
-- `extract_defaults_from_schema()`: ✅ Recursive extraction for nested objects/arrays
-- `generate_default_config()`: ✅ Uses cache, fallback defaults provided
-- `validate_config_against_schema()`: ✅ Uses jsonschema Draft7Validator, detailed error formatting, handles core/system-managed properties correctly
-- `merge_with_defaults()`: ✅ Deep merge preserves user values
-- `invalidate_cache()`: ✅ Clears both schema and defaults cache
-
-**Verification Points:**
-- ✅ Handles missing schemas gracefully (returns None)
-- ✅ Cache invalidation works correctly
-- ✅ Path resolution tries multiple locations
-- ✅ Default extraction handles all JSON Schema types
-- ✅ Validation uses industry-standard library
-- ✅ Error messages include field paths
-
-#### 2. API Endpoints (`web_interface/blueprints/api_v3.py`)
-**Status**: ✅ Complete and Verified
-
-**save_plugin_config()** ✅
-- ✅ Validates config before saving
-- ✅ Applies defaults from schema
-- ✅ Returns detailed validation errors
-- ✅ Separates secrets correctly
-- ✅ Deep merges with existing config
-- ✅ Notifies plugin of config changes
-
-**get_plugin_schema()** ✅
-- ✅ Uses SchemaManager with caching
-- ✅ Returns default schema if not found
-- ✅ Error handling present
-
-**reset_plugin_config()** ✅
-- ✅ Generates defaults from schema
-- ✅ Preserves secrets by default
-- ✅ Updates both main and secrets config
-- ✅ Notifies plugin of changes
-- ✅ Returns new config in response
-
-**Plugin Lifecycle Integration** ✅
-- ✅ Cache invalidation on install
-- ✅ Cache invalidation on update
-- ✅ Cache invalidation on uninstall
-- ✅ Config cleanup on uninstall (optional)
-
-#### 3. ConfigManager (`src/config_manager.py`)
-**Status**: ✅ Complete and Verified
-
-**cleanup_plugin_config()** ✅
-- ✅ Removes from main config
-- ✅ Removes from secrets config (optional)
-- ✅ Error handling present
-
-**cleanup_orphaned_plugin_configs()** ✅
-- ✅ Finds orphaned configs in both files
-- ✅ Removes them safely
-- ✅ Returns list of removed plugin IDs
-
-**validate_all_plugin_configs()** ✅
-- ✅ Validates all plugin configs
-- ✅ Skips non-plugin sections
-- ✅ Returns validation results per plugin
-
-### Frontend Components ✅
-
-#### 1. Modal Structure
-**Status**: ✅ Complete and Verified
-
-- ✅ View toggle buttons (Form/JSON)
-- ✅ Reset button
-- ✅ Validation error display area
-- ✅ Separate containers for form and JSON views
-- ✅ Proper styling and layout
-
-#### 2. JSON Editor Integration
-**Status**: ✅ Complete and Verified
-
-**initJsonEditor()** ✅
-- ✅ Checks for CodeMirror availability
-- ✅ Properly cleans up previous editor instance
-- ✅ Configures CodeMirror with appropriate settings
-- ✅ Real-time JSON syntax validation
-- ✅ Error highlighting
-
-**View Switching** ✅
-- ✅ `switchPluginConfigView()` handles both directions
-- ✅ Syncs form data to JSON when switching to JSON view
-- ✅ Syncs JSON to config state when switching to form view
-- ✅ Properly initializes editor on first JSON view
-- ✅ Updates editor content when already initialized
-
-#### 3. Data Synchronization
-**Status**: ✅ Complete and Verified
-
-**syncFormToJson()** ✅
-- ✅ Handles nested keys (dot notation)
-- ✅ Type conversion based on schema
-- ✅ Deep merge preserves existing nested structures
-- ✅ Skips 'enabled' field (managed separately)
-
-**syncJsonToForm()** ✅
-- ✅ Validates JSON syntax before parsing
-- ✅ Updates config state
-- ✅ Shows error if JSON invalid
-- ✅ Prevents view switch on invalid JSON
-
-#### 4. Reset Functionality
-**Status**: ✅ Complete and Verified
-
-**resetPluginConfigToDefaults()** ✅
-- ✅ Confirmation dialog
-- ✅ Calls reset endpoint
-- ✅ Updates form with defaults
-- ✅ Updates JSON editor if visible
-- ✅ Shows success/error notifications
-
-#### 5. Validation Error Display
-**Status**: ✅ Complete and Verified
-
-**displayValidationErrors()** ✅
-- ✅ Shows/hides error container
-- ✅ Lists all errors
-- ✅ Escapes HTML for security
-- ✅ Called on save failure
-- ✅ Hidden on successful save
-
-**Integration** ✅
-- ✅ `savePluginConfiguration()` displays errors
-- ✅ `handlePluginConfigSubmit()` displays errors
-- ✅ `saveConfigFromJsonEditor()` displays errors
-- ✅ JSON syntax errors displayed
-
-## How It Works Correctly
-
-### 1. Configuration Save Flow
-
-```text
-User edits form/JSON
-    ↓
-Frontend: syncFormToJson() or parse JSON
-    ↓
-Frontend: POST /api/v3/plugins/config
-    ↓
-Backend: save_plugin_config()
-    ↓
-Backend: Load schema (cached)
-    ↓
-Backend: Validate config against schema
-    ↓
-    ├─ Invalid → Return 400 with validation_errors
-    └─ Valid → Continue
-    ↓
-Backend: Apply defaults (merge with user values)
-    ↓
-Backend: Separate secrets
-    ↓
-Backend: Deep merge with existing config
-    ↓
-Backend: Save to config.json and config_secrets.json
-    ↓
-Backend: Notify plugin of config change
-    ↓
-Frontend: Display success or validation errors
-```
-
-### 2. Schema Loading Flow
-
-```text
-Request for schema
-    ↓
-SchemaManager.load_schema()
-    ↓
-Check cache
-    ├─ Cached → Return immediately (~1ms)
-    └─ Not cached → Continue
-    ↓
-Find schema file (multiple paths)
-    ├─ Found → Load and cache
-    └─ Not found → Return None
-    ↓
-Return schema or None
-```
-
-### 3. Default Generation Flow
-
-```text
-Request for defaults
-    ↓
-SchemaManager.generate_default_config()
-    ↓
-Check defaults cache
-    ├─ Cached → Return immediately
-    └─ Not cached → Continue
-    ↓
-Load schema
-    ↓
-Extract defaults recursively
-    ↓
-Ensure common fields (enabled, display_duration)
-    ↓
-Cache and return defaults
-```
-
-### 4. Reset Flow
-
-```text
-User clicks Reset button
-    ↓
-Confirmation dialog
-    ↓
-Frontend: POST /api/v3/plugins/config/reset
-    ↓
-Backend: reset_plugin_config()
-    ↓
-Backend: Generate defaults from schema
-    ↓
-Backend: Separate secrets
-    ↓
-Backend: Update config files
-    ↓
-Backend: Notify plugin
-    ↓
-Frontend: Regenerate form with defaults
-    ↓
-Frontend: Update JSON editor if visible
-```
-
-## Edge Cases Handled
-
-### 1. Missing Schema
-- ✅ Returns default minimal schema
-- ✅ Validation skipped (no errors)
-- ✅ Defaults use minimal values
-
-### 2. Invalid JSON in Editor
-- ✅ Syntax error detected on change
-- ✅ Editor highlighted with error class
-- ✅ Save blocked with error message
-- ✅ View switch blocked with error
-
-### 3. Nested Configs
-- ✅ Form handles dot notation (nfl.enabled)
-- ✅ JSON editor shows full nested structure
-- ✅ Deep merge preserves nested values
-- ✅ Secrets separated recursively
-
-### 4. Plugin Not Found
-- ✅ Schema loading returns None gracefully
-- ✅ Default schema used
-- ✅ No crashes or errors
-
-### 5. CodeMirror Not Loaded
-- ✅ Check for CodeMirror availability
-- ✅ Shows error notification
-- ✅ Falls back gracefully
-
-### 6. Cache Invalidation
-- ✅ Invalidated on install
-- ✅ Invalidated on update
-- ✅ Invalidated on uninstall
-- ✅ Both schema and defaults cache cleared
-
-### 7. Config Cleanup
-- ✅ Optional on uninstall
-- ✅ Removes from both config files
-- ✅ Handles missing sections gracefully
-
-## Testing Checklist
-
-### Backend Testing
-- [ ] Test schema loading with various plugin locations
-- [ ] Test validation with invalid configs (wrong types, missing required, out of range)
-- [ ] Test default generation with nested schemas
-- [ ] Test reset endpoint with preserve_secrets=true and false
-- [ ] Test cache invalidation on plugin lifecycle events
-- [ ] Test config cleanup on uninstall
-- [ ] Test orphaned config cleanup
-
-### Frontend Testing
-- [ ] Test JSON editor initialization
-- [ ] Test form → JSON sync with nested configs
-- [ ] Test JSON → form sync
-- [ ] Test reset button functionality
-- [ ] Test validation error display
-- [ ] Test view switching
-- [ ] Test with CodeMirror not loaded (graceful fallback)
-- [ ] Test with invalid JSON in editor
-- [ ] Test save from both form and JSON views
-
-### Integration Testing
-- [ ] Install plugin → verify schema cache
-- [ ] Update plugin → verify cache invalidation
-- [ ] Uninstall plugin → verify config cleanup
-- [ ] Save invalid config → verify error display
-- [ ] Reset config → verify defaults applied
-- [ ] Edit nested config → verify proper saving
-
-## Known Limitations
-
-1. **Form Regeneration**: When switching from JSON to form view, the form is not regenerated immediately. The config state is updated, and the form will reflect changes on next modal open. This is acceptable as it's a complex operation.
-
-2. **Change Detection**: No warning when switching views with unsaved changes. This could be added in the future.
-
-3. **Field-Level Errors**: Validation errors are shown in a banner, not next to specific fields. This could be enhanced.
-
-## Performance Characteristics
-
-- **Schema Loading**: ~1-5ms (cached) vs ~50-100ms (uncached)
-- **Validation**: ~5-10ms for typical configs
-- **Default Generation**: ~2-5ms (cached) vs ~10-20ms (uncached)
-- **Form Generation**: ~50-200ms depending on schema complexity
-- **JSON Editor Init**: ~10-20ms first time, instant on subsequent uses
-
-## Security Considerations
-
-- ✅ HTML escaping in error messages
-- ✅ JSON parsing with error handling
-- ✅ Secrets properly separated
-- ✅ Input validation before processing
-- ✅ No code injection vectors
-
-## Conclusion
-
-The implementation is **complete and correct**. All components work together properly:
-
-1. ✅ Schema management is reliable and performant
-2. ✅ Validation prevents invalid configs from being saved
-3. ✅ Default generation works for all schema types
-4. ✅ Frontend provides excellent user experience
-5. ✅ Error handling is comprehensive
-6. ✅ System scales with plugin installation/removal
-7. ✅ Code is maintainable and well-structured
-
-The system is ready for production use and testing.
-

docs/archive/PLUGIN_CONFIG_TABS_SUMMARY.md

@@ -1,213 +0,0 @@
-# Plugin Configuration Tabs - Implementation Summary
-
-## What Was Changed
-
-### Backend (web_interface_v2.py)
-
-**Modified `/api/plugins/installed` endpoint:**
-- Now loads each plugin's `config_schema.json` if it exists
-- Returns `config_schema_data` along with plugin information
-- Enables frontend to generate configuration forms dynamically
-
-```python
-# Added schema loading logic
-schema_file = info.get('config_schema')
-if schema_file:
-    schema_path = Path('plugins') / plugin_id / schema_file
-    if schema_path.exists():
-        with open(schema_path, 'r', encoding='utf-8') as f:
-            info['config_schema_data'] = json.load(f)
-```
-
-### Frontend (templates/index_v2.html)
-
-**New Functions:**
-
-1. `generatePluginTabs(plugins)` - Creates dynamic tabs for each installed plugin
-2. `generatePluginConfigForm(plugin)` - Generates HTML form from JSON Schema
-3. `savePluginConfiguration(pluginId)` - Saves configuration with type conversion
-4. `resetPluginConfig(pluginId)` - Resets settings to schema defaults
-
-**Modified Functions:**
-
-1. `refreshPlugins()` - Now calls `generatePluginTabs()` to create dynamic tabs
-2. `configurePlugin(pluginId)` - Navigates to plugin's configuration tab
-
-**Initialization:**
-
-- Plugins are now loaded on page load to generate tabs immediately
-- Dynamic tabs use the `.plugin-tab-btn` and `.plugin-tab-content` classes for easy cleanup
-
-## How It Works
-
-### Tab Generation Flow
-
-```
-1. Page loads → DOMContentLoaded
-2. refreshPlugins() called
-3. Fetches /api/plugins/installed with config_schema_data
-4. generatePluginTabs() creates:
-   - Tab button: <button class="tab-btn plugin-tab-btn">
-   - Tab content: <div class="tab-content plugin-tab-content">
-5. generatePluginConfigForm() creates form from schema
-6. Current config values populated into form
-```
-
-### Form Generation Logic
-
-Based on JSON Schema `type`:
-
-- **boolean** → Toggle switch
-- **number/integer** → Number input with min/max
-- **string** → Text input with maxLength
-- **array** → Comma-separated text input
-- **enum** → Dropdown select
-
-### Save Process
-
-1. User submits form
-2. `savePluginConfiguration()` processes form data:
-   - Converts types per schema (parseInt, parseFloat, split for arrays)
-   - Handles boolean checkbox state
-3. Each field sent to `/api/plugins/config` individually
-4. Backend updates `config.json`
-5. Success notification shown
-6. Plugins refreshed to update display
-
-## Benefits
-
-### For Users
-
-- **Organized UI**: Plugin management separate from configuration
-- **Better UX**: Each plugin has its own dedicated space
-- **Type Safety**: Inputs validated based on schema constraints
-- **Easy Reset**: One-click reset to defaults
-- **Clear Labels**: Schema descriptions shown as help text
-
-### For Developers
-
-- **Automatic**: No custom UI code needed
-- **Declarative**: Just define JSON Schema
-- **Flexible**: Supports all common data types
-- **Validated**: Schema constraints enforced automatically
-
-## Key Features
-
-1. **Dynamic Tab Creation**: Tabs appear/disappear as plugins are installed/uninstalled
-2. **JSON Schema Driven**: Forms generated from standard JSON Schema
-3. **Type Conversion**: Automatic conversion between HTML form strings and config types
-4. **Default Values**: Schema defaults used when config value missing
-5. **Backward Compatible**: Plugins without schemas still work normally
-
-## File Structure
-
-```
-LEDMatrix/
-├── web_interface_v2.py              # Backend API changes
-├── templates/
-│   └── index_v2.html                # Frontend tab generation
-└── docs/
-    ├── PLUGIN_CONFIGURATION_TABS.md # Full documentation
-    └── PLUGIN_CONFIG_TABS_SUMMARY.md # This file
-
-plugins/
-├── hello-world/
-│   ├── manifest.json                # References config_schema.json
-│   └── config_schema.json           # Defines configuration structure
-└── clock-simple/
-    ├── manifest.json
-    └── config_schema.json
-```
-
-## Usage Example
-
-### For Users
-
-1. Install a plugin via Plugin Store
-2. Navigate to Plugins tab
-3. Click "Configure" on plugin card
-4. Plugin's configuration tab opens automatically
-5. Modify settings and click "Save Configuration"
-6. Restart display to apply changes
-
-### For Plugin Developers
-
-Create `config_schema.json`:
-
-```json
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "type": "object",
-  "properties": {
-    "enabled": {
-      "type": "boolean",
-      "default": true
-    },
-    "message": {
-      "type": "string",
-      "default": "Hello!",
-      "maxLength": 50
-    }
-  }
-}
-```
-
-Reference in `manifest.json`:
-
-```json
-{
-  "id": "my-plugin",
-  "name": "My Plugin",
-  "icon": "fas fa-star",         // Optional: custom icon
-  "config_schema": "config_schema.json"
-}
-```
-
-That's it! The configuration tab will be automatically generated.
-
-**Tip:** Add an `icon` field to customize your plugin's tab icon. Supports Font Awesome icons, emoji, or custom images. See [PLUGIN_CUSTOM_ICONS.md](PLUGIN_CUSTOM_ICONS.md) for details.
-
-## Testing Checklist
-
-- [x] Backend loads config schemas
-- [x] Tabs generated for installed plugins
-- [x] Forms render all field types correctly
-- [x] Current values populated
-- [x] Save updates config.json
-- [x] Type conversion works (string → number, string → array)
-- [x] Reset to defaults works
-- [x] Configure button navigates to tab
-- [x] Tabs removed when plugin uninstalled
-- [x] Backward compatible with plugins without schemas
-
-## Known Limitations
-
-1. **Nested Objects**: Only supports flat property structures
-2. **Conditional Fields**: No support for JSON Schema conditionals
-3. **Custom Validation**: Only basic schema validation supported
-4. **Array of Objects**: Arrays must be primitive types or simple lists
-
-## Future Improvements
-
-1. Support nested object properties
-2. Add visual validation feedback
-3. Color picker for RGB arrays
-4. File upload support for assets
-5. Configuration presets/templates
-6. Export/import configurations
-7. Plugin-specific custom renderers
-
-## Migration Notes
-
-- Existing plugins continue to work without changes
-- Plugins with `config_schema.json` automatically get tabs
-- No breaking changes to existing APIs
-- The Plugins tab still handles management operations
-- Raw JSON editor still available as fallback
-
-## Related Documentation
-
-- [PLUGIN_CONFIGURATION_TABS.md](PLUGIN_CONFIGURATION_TABS.md) - Full user and developer guide
-- [Plugin Store Documentation](plugin_docs/) - Plugin system overview
-- [JSON Schema Draft 07](https://json-schema.org/draft-07/schema) - Schema specification
-

docs/archive/PLUGIN_CUSTOM_ICONS_FEATURE.md

@@ -1,434 +0,0 @@
-# Plugin Custom Icons Feature
-
-> **Note:** this doc was originally written against the v2 web
-> interface. The v3 web interface now honors the same `icon` field
-> in `manifest.json` — the API passes it through at
-> `web_interface/blueprints/api_v3.py` and the three plugin-tab
-> render sites in `web_interface/templates/v3/base.html` read it
-> with a `fas fa-puzzle-piece` fallback. The guidance below still
-> applies; only the referenced template/helper names differ.
-
-## What Was Implemented
-
-You asked: **"How could a plugin add their own custom icon?"**
-
-**Answer:** Plugins can now specify custom icons in their `manifest.json` file using the `icon` field!
-
-## Features Delivered
-
-✅ **Font Awesome Support** - Use any Font Awesome icon (e.g., `fas fa-clock`)  
-✅ **Emoji Support** - Use any emoji character (e.g., `⏰` or `👋`)  
-✅ **Custom Image Support** - Use custom image files or URLs  
-✅ **Automatic Detection** - System automatically detects icon type  
-✅ **Fallback Support** - Default puzzle piece icon if none specified  
-✅ **Tab & Header Icons** - Icons appear in both tab buttons and configuration page headers  
-
-## How It Works
-
-### For Plugin Developers
-
-Simply add an `icon` field to your plugin's `manifest.json`:
-
-```json
-{
-  "id": "my-plugin",
-  "name": "My Plugin",
-  "icon": "fas fa-star",  // ← Add this line
-  "config_schema": "config_schema.json",
-  ...
-}
-```
-
-### Three Icon Types Supported
-
-#### 1. Font Awesome Icons (Recommended)
-```json
-"icon": "fas fa-clock"
-```
-
-Best for: Professional, consistent UI appearance
-
-#### 2. Emoji Icons (Fun!)
-```json
-"icon": "⏰"
-```
-
-Best for: Colorful, fun plugins; no setup needed
-
-#### 3. Custom Images
-```json
-"icon": "/plugins/my-plugin/logo.png"
-```
-
-Best for: Unique branding; requires image file
-
-## Implementation Details
-
-### Frontend Changes (`templates/index_v2.html`)
-
-**New Function: `getPluginIcon(plugin)`**
-- Checks if plugin has `icon` field in manifest
-- Detects icon type automatically:
-  - Contains `fa-` → Font Awesome
-  - 1-4 characters → Emoji
-  - Starts with URL/path → Custom image
-  - Otherwise → Default puzzle piece
-
-**Updated Functions:**
-- `generatePluginTabs()` - Uses custom icon for tab button
-- `generatePluginConfigForm()` - Uses custom icon in page header
-
-### Example Plugin Updates
-
-**hello-world plugin:**
-```json
-"icon": "👋"
-```
-
-**clock-simple plugin:**
-```json
-"icon": "fas fa-clock"
-```
-
-## Code Example
-
-Here's what the icon detection logic does. **Important:** Plugin manifests must be treated as untrusted input and require escaping/validation before rendering.
-
-```javascript
-// Helper function to escape HTML entities
-function escapeHtml(text) {
-    const div = document.createElement('div');
-    div.textContent = text;
-    return div.innerHTML;
-}
-
-// Helper function to validate and sanitize image URLs
-function isValidImageUrl(url) {
-    if (!url || typeof url !== 'string') {
-        return false;
-    }
-    
-    // Only allow http, https, or relative paths starting with /
-    const allowedProtocols = ['http:', 'https:'];
-    const urlLower = url.toLowerCase().trim();
-    
-    // Reject dangerous protocols
-    if (urlLower.startsWith('javascript:') || 
-        urlLower.startsWith('data:') || 
-        urlLower.startsWith('vbscript:') ||
-        urlLower.startsWith('onerror=') ||
-        urlLower.startsWith('onload=')) {
-        return false;
-    }
-    
-    // Allow relative paths starting with /
-    if (url.startsWith('/')) {
-        return true;
-    }
-    
-    // Validate absolute URLs
-    try {
-        const urlObj = new URL(url);
-        return allowedProtocols.includes(urlObj.protocol);
-    } catch (e) {
-        // Invalid URL format
-        return false;
-    }
-}
-
-// Helper function to safely validate Font Awesome class names
-function isValidFontAwesomeClass(icon) {
-    // Whitelist pattern: only allow alphanumeric, dash, underscore, and spaces
-    // Must contain 'fa-' for Font Awesome
-    const faPattern = /^[a-zA-Z0-9\s_-]*fa-[a-zA-Z0-9-]+[a-zA-Z0-9\s_-]*$/;
-    return faPattern.test(icon) && icon.includes('fa-');
-}
-
-function getPluginIcon(plugin) {
-    if (plugin.icon) {
-        const icon = String(plugin.icon).trim();
-        
-        // Font Awesome icon - escape class name to prevent XSS
-        if (isValidFontAwesomeClass(icon)) {
-            const escapedIcon = escapeHtml(icon);
-            return `<i class="${escapedIcon}"></i>`;
-        }
-        
-        // Emoji - use textContent to safely render (no HTML injection possible)
-        if (icon.length <= 4) {
-            // Create element and set textContent (safe from XSS)
-            const span = document.createElement('span');
-            span.style.fontSize = '1.1em';
-            span.textContent = icon; // textContent automatically escapes
-            return span.outerHTML;
-        }
-        
-        // Custom image - validate URL and set src attribute safely
-        if (isValidImageUrl(icon)) {
-            // Create img element and set attributes safely
-            const img = document.createElement('img');
-            img.src = icon; // URL already validated
-            img.alt = '';
-            img.style.width = '16px';
-            img.style.height = '16px';
-            return img.outerHTML;
-        }
-    }
-    
-    // Default fallback
-    return '<i class="fas fa-puzzle-piece"></i>';
-}
-```
-
-**Security Notes:**
-- Plugin manifests are treated as untrusted input
-- All text content is escaped using `escapeHtml()` or `textContent`
-- Image URLs are validated to only allow `http://`, `https://`, or relative paths starting with `/`
-- Dangerous protocols (`javascript:`, `data:`, etc.) are explicitly rejected
-- Font Awesome class names are validated against a whitelist pattern
-- DOM elements are created and attributes set directly rather than using string interpolation
-
-## Visual Examples
-
-### Before (No Custom Icons)
-```
-[🧩 Hello World] [🧩 Clock Simple] [🧩 Weather Display]
-```
-
-### After (With Custom Icons)
-```
-[👋 Hello World] [⏰ Clock Simple] [☀️ Weather Display]
-```
-
-## Documentation Created
-
-📚 **Comprehensive guide:** `docs/PLUGIN_CUSTOM_ICONS.md`
-
-Contains:
-- Complete icon type explanations
-- Font Awesome icon recommendations by category
-- Emoji suggestions for common plugin types
-- Custom image guidelines
-- Best practices and troubleshooting
-- Examples for every use case
-
-📝 **Updated existing docs:**
-- `PLUGIN_CONFIGURATION_TABS.md` - Added icon reference
-- `PLUGIN_CONFIG_TABS_SUMMARY.md` - Added icon quick tip
-- `PLUGIN_CONFIG_QUICK_START.md` - Added icon bonus section
-
-## Popular Icon Recommendations
-
-### By Plugin Category
-
-**Time & Calendar**
-- Font Awesome: `fas fa-clock`, `fas fa-calendar`, `fas fa-hourglass`
-- Emoji: ⏰ 📅 ⏱️
-
-**Weather**
-- Font Awesome: `fas fa-cloud-sun`, `fas fa-temperature-high`
-- Emoji: ☀️ 🌧️ ⛈️
-
-**Finance**
-- Font Awesome: `fas fa-chart-line`, `fas fa-dollar-sign`
-- Emoji: 💰 📈 💵
-
-**Sports**
-- Font Awesome: `fas fa-football-ball`, `fas fa-trophy`
-- Emoji: ⚽ 🏀 🎮
-
-**Music**
-- Font Awesome: `fas fa-music`, `fas fa-headphones`
-- Emoji: 🎵 🎶 🎸
-
-**News**
-- Font Awesome: `fas fa-newspaper`, `fas fa-rss`
-- Emoji: 📰 📡 📻
-
-**Utilities**
-- Font Awesome: `fas fa-tools`, `fas fa-cog`
-- Emoji: 🔧 ⚙️ 🛠️
-
-## Usage Examples
-
-### Weather Plugin
-```json
-{
-  "id": "weather-pro",
-  "name": "Weather Pro",
-  "icon": "fas fa-cloud-sun",
-  "description": "Advanced weather display"
-}
-```
-Result: `☁️ Weather Pro` tab
-
-### Game Scores
-```json
-{
-  "id": "game-scores",
-  "name": "Game Scores",
-  "icon": "🎮",
-  "description": "Live game scores"
-}
-```
-Result: `🎮 Game Scores` tab
-
-### Custom Branding
-```json
-{
-  "id": "company-metrics",
-  "name": "Company Metrics",
-  "icon": "/plugins/company-metrics/logo.svg",
-  "description": "Internal dashboard"
-}
-```
-Result: `[logo] Company Metrics` tab
-
-## Benefits
-
-### For Users
-- **Visual Recognition** - Instantly identify plugins
-- **Better Navigation** - Find plugins faster
-- **Professional Appearance** - Polished, modern UI
-
-### For Developers
-- **Easy to Add** - Just one line in manifest
-- **Flexible Options** - Choose what fits your plugin
-- **No Code Required** - Pure configuration
-
-### For the Project
-- **Plugin Differentiation** - Each plugin stands out
-- **Enhanced UX** - More intuitive interface
-- **Branding Support** - Plugins can show identity
-
-## Backward Compatibility
-
-✅ **Fully backward compatible**  
-- Plugins without `icon` field still work  
-- Default puzzle piece icon used automatically  
-- No breaking changes to existing plugins  
-
-## Testing
-
-To test custom icons:
-
-1. **Open web interface** at `http://your-pi-ip:5000`
-2. **Check installed plugins**:
-   - Hello World should show 👋
-   - Clock Simple should show 🕐
-3. **Install a new plugin** with custom icon
-4. **Verify icon appears** in:
-   - Tab navigation bar
-   - Plugin configuration page header
-
-## File Changes
-
-### Modified Files
-- `templates/index_v2.html`
-  - Added `getPluginIcon()` function
-  - Updated `generatePluginTabs()` 
-  - Updated `generatePluginConfigForm()`
-
-### Updated Plugin Manifests
-- `ledmatrix-plugins/plugins/hello-world/manifest.json` - Added emoji icon
-- `ledmatrix-plugins/plugins/clock-simple/manifest.json` - Added Font Awesome icon
-
-### New Documentation
-- `docs/PLUGIN_CUSTOM_ICONS.md` - Complete guide (80+ lines)
-
-### Updated Documentation
-- `docs/PLUGIN_CONFIGURATION_TABS.md`
-- `docs/PLUGIN_CONFIG_TABS_SUMMARY.md`
-- `docs/PLUGIN_CONFIG_QUICK_START.md`
-
-## Quick Reference
-
-### Add Icon to Your Plugin
-
-```json
-{
-  "id": "your-plugin",
-  "name": "Your Plugin Name",
-  "icon": "fas fa-star",  // or emoji or image URL
-  "config_schema": "config_schema.json",
-  ...
-}
-```
-
-### Icon Format Examples
-
-```json
-// Font Awesome
-"icon": "fas fa-star"
-"icon": "far fa-heart"
-"icon": "fab fa-twitter"
-
-// Emoji
-"icon": "⭐"
-"icon": "❤️"
-"icon": "🐦"
-
-// Custom Image
-"icon": "/plugins/my-plugin/icon.png"
-"icon": "https://example.com/logo.svg"
-```
-
-## Browse Available Icons
-
-- **Font Awesome:** [fontawesome.com/icons](https://fontawesome.com/icons) (Free tier includes 2,000+ icons)
-- **Emojis:** [unicode.org/emoji](https://unicode.org/emoji/charts/full-emoji-list.html)
-
-## Best Practices
-
-1. **Choose meaningful icons** - Icon should relate to plugin function
-2. **Keep it simple** - Works better at small sizes
-3. **Test visibility** - Ensure icon is clear at 16px
-4. **Match UI style** - Font Awesome recommended for consistency
-5. **Document choice** - Note icon meaning in plugin README
-
-## Troubleshooting
-
-**Icon not showing?**
-- Check manifest syntax (JSON valid?)
-- Verify icon field spelling
-- Refresh plugins in web interface
-- Check browser console for errors
-
-**Wrong icon appearing?**
-- Font Awesome: Verify class name at fontawesome.com
-- Emoji: Try different emoji (platform rendering varies)
-- Custom image: Check file path and permissions
-
-## Future Enhancements
-
-Possible future improvements:
-- Icon picker in plugin store
-- Animated icons support
-- SVG path support
-- Icon themes/styles
-- Dynamic icon changes based on state
-
-## Summary
-
-**Mission accomplished!** 🎉
-
-Plugins can now have custom icons by adding one line to their manifest:
-
-```json
-"icon": "fas fa-your-icon"
-```
-
-Three formats supported:
-- ✅ Font Awesome (professional)
-- ✅ Emoji (fun)
-- ✅ Custom images (branded)
-
-The feature is:
-- ✅ Easy to use (one line)
-- ✅ Flexible (three options)
-- ✅ Backward compatible
-- ✅ Well documented
-- ✅ Already working in example plugins
-
-**Ready to use!** 🚀
-

docs/archive/PLUGIN_DISPATCH_IMPLEMENTATION.md

@@ -1,144 +0,0 @@
-# Plugin-First Dispatch Implementation
-
-## Summary
-
-Successfully implemented a minimal, zero-risk plugin dispatch system that allows plugins to work seamlessly alongside legacy managers without refactoring existing code.
-
-## Changes Made
-
-### 1. Plugin Modes Dictionary (Lines 393, 422-425)
-Added `self.plugin_modes = {}` dictionary to track mode-to-plugin mappings:
-```python
-self.plugin_modes = {}  # mode -> plugin_instance mapping for plugin-first dispatch
-```
-
-During plugin loading, each plugin's display modes are registered:
-```python
-for mode in display_modes:
-    self.plugin_modes[mode] = plugin_instance
-    logger.info(f"Registered plugin mode: {mode} -> {plugin_id}")
-```
-
-### 2. Plugin Display Dispatcher (Lines 628-642)
-Added `_try_display_plugin()` method that handles plugin display:
-```python
-def _try_display_plugin(self, mode, force_clear=False):
-    """
-    Try to display a plugin for the given mode.
-    Returns True if plugin handled it, False if should fall through to legacy.
-    """
-    plugin = self.plugin_modes.get(mode)
-    if not plugin:
-        return False
-    
-    try:
-        plugin.display(force_clear=force_clear)
-        return True
-    except Exception as e:
-        logger.error(f"Error displaying plugin for mode {mode}: {e}", exc_info=True)
-        return False
-```
-
-### 3. Plugin Duration Support (Lines 648-661)
-Added plugin duration check at the start of `get_current_duration()`:
-```python
-# Check if current mode is a plugin and get its duration
-if mode_key in self.plugin_modes:
-    try:
-        plugin = self.plugin_modes[mode_key]
-        duration = plugin.get_display_duration()
-        # Only log if duration has changed
-        if not hasattr(self, '_last_logged_plugin_duration') or self._last_logged_plugin_duration != (mode_key, duration):
-            logger.info(f"Using plugin duration for {mode_key}: {duration} seconds")
-            self._last_logged_plugin_duration = (mode_key, duration)
-        return duration
-    except Exception as e:
-        logger.error(f"Error getting plugin duration for {mode_key}: {e}")
-        return self.display_durations.get(mode_key, 15)
-```
-
-### 4. Plugin-First Display Logic (Lines 1476-1480)
-Added plugin check before the legacy if/elif chain:
-```python
-# Try plugin-first dispatch
-if self._try_display_plugin(self.current_display_mode, force_clear=self.force_clear):
-    # Plugin handled it, reset force_clear and continue
-    if self.force_clear:
-        self.force_clear = False
-elif self.current_display_mode == 'music' and self.music_manager:
-    # Existing legacy code continues...
-```
-
-### 5. Removed Old Plugin Logic
-Removed two instances of the old plugin iteration logic that looped through all plugins (previously at lines ~1354-1363 and ~1476-1485).
-
-## Total Impact
-
-- **Lines Added**: ~36 lines of new code
-- **Lines Removed**: ~20 lines of old plugin iteration code
-- **Net Change**: +16 lines
-- **Files Modified**: 1 file (`src/display_controller.py`)
-- **Files Created**: 0
-- **Breaking Changes**: None
-
-## How It Works
-
-1. **Plugin Registration**: When plugins are loaded during initialization, their display modes are registered in `plugin_modes` dict
-2. **Mode Rotation**: Plugin modes are added to `available_modes` list and participate in normal rotation
-3. **Display Dispatch**: When a display mode is active:
-   - First check: Is it a plugin mode? → Call `plugin.display()`
-   - If not: Fall through to existing legacy if/elif chain
-4. **Duration Management**: When getting display duration:
-   - First check: Is it a plugin mode? → Call `plugin.get_display_duration()`
-   - If not: Use existing legacy duration logic
-
-## Benefits
-
-✅ **Zero Risk**: All legacy code paths remain intact and unchanged  
-✅ **Minimal Code**: Only ~36 new lines added  
-✅ **Works Immediately**: Plugins now work seamlessly with legacy managers  
-✅ **No Refactoring**: No changes to working code  
-✅ **Easy to Test**: Only need to test plugin dispatch, legacy is unchanged  
-✅ **Gradual Migration**: Can migrate managers to plugins one-by-one  
-✅ **Error Handling**: Plugin errors don't crash the system  
-
-## Testing Checklist
-
-- [x] No linting errors
-- [ ] Test plugins display correctly in rotation
-- [ ] Test legacy managers still work correctly
-- [ ] Test mode switching between plugin and legacy
-- [ ] Test plugin duration handling
-- [ ] Test plugin error handling (plugin crashes don't affect system)
-- [ ] Test on actual Raspberry Pi hardware
-
-## Future Migration Path
-
-When migrating a legacy manager to a plugin:
-1. Create the plugin version in `plugins/`
-2. Enable the plugin in config
-3. Disable the legacy manager in config
-4. Test
-5. Eventually remove legacy manager initialization code
-
-**No changes to display loop needed!** The plugin-first dispatch automatically handles it.
-
-## Example: Current Behavior
-
-**With hello-world plugin enabled:**
-```
-[INFO] Registered plugin mode: hello-world -> hello-world
-[INFO] Added plugin mode to rotation: hello-world
-[INFO] Available display modes: ['clock', 'weather_current', ..., 'hello-world']
-[INFO] Showing hello-world
-[INFO] Using plugin duration for hello-world: 15 seconds
-```
-
-**Plugin displays, then rotates to next mode (e.g., clock):**
-```
-[INFO] Switching to clock from hello-world
-[INFO] Showing clock
-```
-
-**Everything works together seamlessly!**
-

docs/archive/PLUGIN_SCHEMA_AUDIT_SUMMARY.md

@@ -1,157 +0,0 @@
-# Plugin Config Schema Audit and Standardization - Summary
-
-## Overview
-
-Completed comprehensive audit and standardization of all 12 plugin configuration schemas in the LEDMatrix project.
-
-## Results
-
-### Validation Status
-- ✅ **All 12 schemas pass JSON Schema Draft-07 validation**
-- ✅ **All schemas successfully load via SchemaManager**
-- ✅ **All schemas generate default configurations correctly**
-
-### Standardization Achievements
-
-1. **Common Fields Standardized**
-   - ✅ All plugins now have `enabled` as the first property
-   - ✅ All plugins have standardized `display_duration` field (where applicable)
-   - ✅ Added `live_priority` to plugins that support live content
-   - ✅ Added `high_performance_transitions` to all plugins
-   - ✅ Added `transition` object to all plugins
-   - ✅ Standardized `update_interval` naming (replaced `update_interval_seconds` where appropriate)
-
-2. **Metadata Improvements**
-   - ✅ Added `title` field to all schemas (12/12)
-   - ✅ Added `description` field to all schemas (12/12)
-   - ✅ Improved descriptions to be clearer and more user-friendly
-
-3. **Property Ordering**
-   - ✅ All schemas follow consistent ordering: common fields first, then plugin-specific
-   - ✅ Order: `enabled` → `display_duration` → `live_priority` → `high_performance_transitions` → `update_interval` → `transition` → plugin-specific
-
-4. **Formatting**
-   - ✅ Consistent 2-space indentation throughout
-   - ✅ Consistent spacing and structure
-   - ✅ All schemas use `additionalProperties: false` for strict validation
-
-## Plugins Updated
-
-1. **baseball-scoreboard** - Added common fields, standardized naming
-2. **clock-simple** - Added title, description, common fields, improved descriptions
-3. **football-scoreboard** - Reordered properties (enabled first), added common fields, standardized naming
-4. **hockey-scoreboard** - Added title, description, common fields, standardized naming
-5. **ledmatrix-flights** - Added common fields
-6. **ledmatrix-leaderboard** - Added common fields, moved update_interval to top level
-7. **ledmatrix-stocks** - Added common fields, fixed update_interval type
-8. **ledmatrix-weather** - Added missing `enabled` field, added title/description, reordered properties, added common fields
-9. **odds-ticker** - Added common fields
-10. **static-image** - Added title and description
-11. **text-display** - Added title, description, common fields, improved descriptions
-
-## Key Changes by Plugin
-
-### clock-simple
-- Added title and description
-- Added `live_priority`, `high_performance_transitions`, `transition`
-- Improved field descriptions
-- Reordered properties
-
-### text-display
-- Added title and description
-- Added `live_priority`, `high_performance_transitions`, `update_interval`, `transition`
-- Improved field descriptions
-- Reordered properties
-
-### ledmatrix-weather
-- **Critical fix**: Added missing `enabled` field (was completely missing)
-- Added title and description
-- Reordered properties (enabled first)
-- Added `live_priority`, `high_performance_transitions`, `transition`
-- Added `enabled` to required fields
-
-### football-scoreboard
-- Reordered properties (enabled first)
-- Renamed `update_interval_seconds` to `update_interval` at top level
-- Added `live_priority`, `high_performance_transitions`, `transition`
-- Added `enabled` to required fields
-- Improved title and description
-
-### hockey-scoreboard
-- Added title and description
-- Renamed top-level `update_interval_seconds` to `update_interval`
-- Added `live_priority`, `high_performance_transitions`, `transition`
-- Note: Nested league configs still use `update_interval_seconds` (intentional for clarity in nested contexts)
-
-### baseball-scoreboard
-- Renamed `update_interval_seconds` to `update_interval` at top level
-- Added `high_performance_transitions`, `transition`
-- Note: Nested league configs still use `update_interval_seconds` (intentional)
-
-### ledmatrix-leaderboard
-- Added `display_duration`, `live_priority`, `high_performance_transitions`, `update_interval`, `transition` at top level
-- Removed duplicate `update_interval` from `global` object (moved to top level)
-
-### ledmatrix-stocks
-- Changed `update_interval` type from `number` to `integer`
-- Added `live_priority`, `high_performance_transitions`, `transition`
-
-### odds-ticker
-- Added `live_priority`, `high_performance_transitions`, `transition`
-
-### ledmatrix-flights
-- Added `live_priority`, `high_performance_transitions`, `transition`
-
-### static-image
-- Added title and description
-
-## Notes on "Duplicates"
-
-The analysis script detected many "duplicate" fields, but these are **false positives**. The script flags nested objects with the same field names (e.g., `enabled` in multiple nested objects), which is **valid and expected** in JSON Schema. These are not actual duplicates - they're properly scoped within their respective object contexts.
-
-For example:
-- `enabled` at root level vs `enabled` in `nfl.enabled` - these are different properties in different contexts
-- `dynamic_duration` at root vs `nfl.dynamic_duration` - these are separate, valid nested configurations
-
-## Validation Alignment
-
-The `validate_config()` methods in plugin managers focus on business logic validation (e.g., timezone validation, enum checks), while the JSON Schema handles:
-- Type validation
-- Constraint validation (min/max, pattern matching)
-- Required field validation
-- Default value application
-
-This separation is correct and follows best practices.
-
-## Testing
-
-All schemas were verified to:
-1. ✅ Pass JSON Schema Draft-07 validation
-2. ✅ Load successfully via SchemaManager
-3. ✅ Generate default configurations correctly
-4. ✅ Have consistent formatting and structure
-
-## Next Steps (Optional)
-
-1. Consider updating plugin manager code that uses `update_interval_seconds` to use `update_interval` for consistency (if not in nested contexts)
-2. Review validate_config() methods to ensure they align with schema constraints (most already do)
-3. Consider adding more detailed enum descriptions where helpful
-
-## Files Modified
-
-- `plugins/baseball-scoreboard/config_schema.json`
-- `plugins/clock-simple/config_schema.json`
-- `plugins/football-scoreboard/config_schema.json`
-- `plugins/hockey-scoreboard/config_schema.json`
-- `plugins/ledmatrix-flights/config_schema.json`
-- `plugins/ledmatrix-leaderboard/config_schema.json`
-- `plugins/ledmatrix-stocks/config_schema.json`
-- `plugins/ledmatrix-weather/config_schema.json`
-- `plugins/odds-ticker/config_schema.json`
-- `plugins/static-image/config_schema.json`
-- `plugins/text-display/config_schema.json`
-
-## Analysis Script
-
-Created `scripts/analyze_plugin_schemas.py` for ongoing schema validation and analysis.
-

docs/archive/PLUGIN_STORE_QUICK_REFERENCE.md

@@ -1,167 +0,0 @@
-# Plugin Store - Quick Reference Card
-
-## For Users
-
-### Install Plugin from Store
-```bash
-# Web UI: Plugin Store → Search → Click Install
-# API:
-curl -X POST http://pi:5050/api/plugins/install \
-  -d '{"plugin_id": "clock-simple"}'
-```
-
-### Install Plugin from GitHub URL ⭐
-```bash
-# Web UI: Plugin Store → "Install from URL" → Paste URL
-# API:
-curl -X POST http://pi:5050/api/plugins/install-from-url \
-  -d '{"repo_url": "https://github.com/user/ledmatrix-plugin"}'
-```
-
-### Search Plugins
-```bash
-# Web UI: Use search bar and filters
-# API:
-curl "http://pi:5050/api/plugins/store/search?q=hockey&category=sports"
-```
-
-### List Installed
-```bash
-curl "http://pi:5050/api/plugins/installed"
-```
-
-### Enable/Disable
-```bash
-curl -X POST http://pi:5050/api/plugins/toggle \
-  -d '{"plugin_id": "clock-simple", "enabled": true}'
-```
-
-### Update Plugin
-```bash
-curl -X POST http://pi:5050/api/plugins/update \
-  -d '{"plugin_id": "clock-simple"}'
-```
-
-### Uninstall
-```bash
-curl -X POST http://pi:5050/api/plugins/uninstall \
-  -d '{"plugin_id": "clock-simple"}'
-```
-
-## For Developers
-
-### Share Your Plugin
-```markdown
-1. Create plugin following manifest structure
-2. Push to GitHub: https://github.com/you/ledmatrix-your-plugin
-3. Share URL with users:
-   "Install my plugin from: https://github.com/you/ledmatrix-your-plugin"
-4. Users paste URL in "Install from URL" section
-```
-
-### Python Usage
-```python
-from src.plugin_system.store_manager import PluginStoreManager
-
-store = PluginStoreManager()
-
-# Install from URL
-result = store.install_from_url('https://github.com/user/plugin')
-if result['success']:
-    print(f"Installed: {result['plugin_id']}")
-
-# Install from registry
-store.install_plugin('clock-simple')
-
-# Search
-results = store.search_plugins(query='hockey', category='sports')
-
-# List installed
-for plugin_id in store.list_installed_plugins():
-    info = store.get_installed_plugin_info(plugin_id)
-    print(f"{plugin_id}: {info['name']}")
-```
-
-## Required Plugin Structure
-
-```
-my-plugin/
-├── manifest.json       # Required: Plugin metadata
-├── manager.py          # Required: Plugin class
-├── requirements.txt    # Optional: Python dependencies
-├── config_schema.json  # Optional: Config validation
-├── README.md          # Recommended: Documentation
-└── assets/            # Optional: Logos, fonts, etc.
-```
-
-### Minimal manifest.json
-```json
-{
-  "id": "my-plugin",
-  "name": "My Plugin",
-  "version": "1.0.0",
-  "author": "Your Name",
-  "description": "What it does",
-  "entry_point": "manager.py",
-  "class_name": "MyPlugin",
-  "category": "custom"
-}
-```
-
-## Key Features
-
-✅ **Install from Official Registry** - Curated, verified plugins  
-✅ **Install from GitHub URL** - Any repo, instant install  
-✅ **Search & Filter** - Find plugins by category, tags, query  
-✅ **Auto Dependencies** - requirements.txt installed automatically  
-✅ **Git or ZIP** - Git clone preferred, ZIP fallback  
-✅ **Update System** - Keep plugins current  
-✅ **Safe Uninstall** - Clean removal  
-
-## Safety Notes
-
-⚠️ **Verified** (✓) = Reviewed by maintainers, safe  
-⚠️ **Unverified** = From custom URL, review before installing  
-⚠️ **Always** review plugin code before installing from URL  
-⚠️ **Only** install from sources you trust  
-
-## Common Issues
-
-**"Failed to clone"**  
-→ Check git is installed: `which git`  
-→ Verify GitHub URL is correct  
-→ System will try ZIP download as fallback  
-
-**"No manifest.json"**  
-→ Plugin repo must have manifest.json in root  
-→ Check repo structure  
-
-**"Dependencies failed"**  
-→ Manually install: `pip3 install -r plugins/plugin-id/requirements.txt`  
-
-**Plugin won't load**  
-→ Check enabled in config: `"enabled": true`  
-→ Restart display: `sudo systemctl restart ledmatrix`  
-→ Check logs: `sudo journalctl -u ledmatrix -f`  
-
-## Documentation
-
-- Full Guide: `PLUGIN_STORE_USER_GUIDE.md`
-- Implementation: `PLUGIN_STORE_IMPLEMENTATION_SUMMARY.md`
-- Architecture: `PLUGIN_ARCHITECTURE_SPEC.md`
-- Developer Guide: `PLUGIN_DEVELOPER_GUIDE.md` (coming soon)
-
-## Support
-
-- Report issues on GitHub
-- Check wiki for troubleshooting
-- Join community discussions
-
----
-
-**Quick Tip**: To install your own plugin for testing:
-1. Push to GitHub
-2. Paste URL in web interface
-3. Click install
-4. Done!
-

docs/archive/PLUGIN_STORE_USER_GUIDE.md

@@ -1,450 +0,0 @@
-# LEDMatrix Plugin Store - User Guide
-
-## Overview
-
-The LEDMatrix Plugin Store allows you to easily discover, install, and manage display plugins for your LED matrix. You can install curated plugins from the official registry or add custom plugins directly from any GitHub repository.
-
-## Two Ways to Install Plugins
-
-### Method 1: From Official Plugin Store (Recommended)
-
-The official plugin store contains curated, verified plugins that have been reviewed by maintainers.
-
-**Via Web UI:**
-1. Open the web interface (http://your-pi-ip:5050)
-2. Navigate to "Plugin Store" tab
-3. Browse or search for plugins
-4. Click "Install" on the plugin you want
-5. Wait for installation to complete
-6. Restart the display to activate the plugin
-
-**Via API:**
-```bash
-curl -X POST http://your-pi-ip:5050/api/plugins/install \
-  -H "Content-Type: application/json" \
-  -d '{"plugin_id": "clock-simple"}'
-```
-
-**Via Python:**
-```python
-from src.plugin_system.store_manager import PluginStoreManager
-
-store = PluginStoreManager()
-success = store.install_plugin('clock-simple')
-if success:
-    print("Plugin installed!")
-```
-
-### Method 2: From Custom GitHub URL
-
-Install any plugin directly from a GitHub repository, even if it's not in the official store. This is perfect for:
-- Testing your own plugins during development
-- Installing community plugins before they're in the official store
-- Using private plugins
-- Sharing plugins with specific users
-
-**Via Web UI:**
-1. Open the web interface
-2. Navigate to "Plugin Store" tab
-3. Find the "Install from URL" section at the bottom
-4. Paste the GitHub repository URL (e.g., `https://github.com/user/ledmatrix-my-plugin`)
-5. Click "Install from URL"
-6. Review the warning about unverified plugins
-7. Confirm installation
-8. Wait for installation to complete
-9. Restart the display
-
-**Via API:**
-```bash
-curl -X POST http://your-pi-ip:5050/api/plugins/install-from-url \
-  -H "Content-Type: application/json" \
-  -d '{"repo_url": "https://github.com/user/ledmatrix-my-plugin"}'
-```
-
-**Via Python:**
-```python
-from src.plugin_system.store_manager import PluginStoreManager
-
-store = PluginStoreManager()
-result = store.install_from_url('https://github.com/user/ledmatrix-my-plugin')
-
-if result['success']:
-    print(f"Installed: {result['plugin_id']}")
-else:
-    print(f"Error: {result['error']}")
-```
-
-## Searching for Plugins
-
-**Via Web UI:**
-- Use the search bar to search by name, description, or author
-- Filter by category (sports, weather, time, finance, etc.)
-- Click on tags to filter by specific tags
-
-**Via API:**
-```bash
-# Search by query
-curl "http://your-pi-ip:5050/api/plugins/store/search?q=hockey"
-
-# Filter by category
-curl "http://your-pi-ip:5050/api/plugins/store/search?category=sports"
-
-# Filter by tags
-curl "http://your-pi-ip:5050/api/plugins/store/search?tags=nhl&tags=hockey"
-```
-
-**Via Python:**
-```python
-from src.plugin_system.store_manager import PluginStoreManager
-
-store = PluginStoreManager()
-
-# Search by query
-results = store.search_plugins(query="hockey")
-
-# Filter by category
-results = store.search_plugins(category="sports")
-
-# Filter by tags
-results = store.search_plugins(tags=["nhl", "hockey"])
-```
-
-## Managing Installed Plugins
-
-### List Installed Plugins
-
-**Via Web UI:**
-- Navigate to "Plugin Manager" tab
-- See all installed plugins with their status
-
-**Via API:**
-```bash
-curl "http://your-pi-ip:5050/api/plugins/installed"
-```
-
-**Via Python:**
-```python
-from src.plugin_system.store_manager import PluginStoreManager
-
-store = PluginStoreManager()
-installed = store.list_installed_plugins()
-
-for plugin_id in installed:
-    info = store.get_installed_plugin_info(plugin_id)
-    print(f"{info['name']} (Last updated: {info.get('last_updated', 'unknown')})")
-```
-
-### Enable/Disable Plugins
-
-**Via Web UI:**
-1. Go to "Plugin Manager" tab
-2. Use the toggle switch next to each plugin
-3. Restart display to apply changes
-
-**Via API:**
-```bash
-curl -X POST http://your-pi-ip:5050/api/plugins/toggle \
-  -H "Content-Type: application/json" \
-  -d '{"plugin_id": "clock-simple", "enabled": true}'
-```
-
-### Update Plugins
-
-**Via Web UI:**
-1. Go to "Plugin Manager" tab
-2. Click "Update" button next to the plugin
-3. Wait for update to complete
-4. Restart display
-
-**Via API:**
-```bash
-curl -X POST http://your-pi-ip:5050/api/plugins/update \
-  -H "Content-Type: application/json" \
-  -d '{"plugin_id": "clock-simple"}'
-```
-
-**Via Python:**
-```python
-from src.plugin_system.store_manager import PluginStoreManager
-
-store = PluginStoreManager()
-success = store.update_plugin('clock-simple')
-```
-
-### Uninstall Plugins
-
-**Via Web UI:**
-1. Go to "Plugin Manager" tab
-2. Click "Uninstall" button next to the plugin
-3. Confirm removal
-4. Restart display
-
-**Via API:**
-```bash
-curl -X POST http://your-pi-ip:5050/api/plugins/uninstall \
-  -H "Content-Type: application/json" \
-  -d '{"plugin_id": "clock-simple"}'
-```
-
-**Via Python:**
-```python
-from src.plugin_system.store_manager import PluginStoreManager
-
-store = PluginStoreManager()
-success = store.uninstall_plugin('clock-simple')
-```
-
-## Configuring Plugins
-
-Each plugin can have its own configuration in `config/config.json`:
-
-```json
-{
-  "clock-simple": {
-    "enabled": true,
-    "display_duration": 15,
-    "color": [255, 255, 255],
-    "time_format": "12h"
-  },
-  "nhl-scores": {
-    "enabled": true,
-    "favorite_teams": ["TBL", "FLA"],
-    "show_favorite_teams_only": true
-  }
-}
-```
-
-**Via Web UI:**
-1. Go to "Plugin Manager" tab
-2. Click the ⚙️ Configure button next to the plugin
-3. Edit configuration in the form
-4. Save changes
-5. Restart display to apply
-
-## Safety and Security
-
-### Verified vs Unverified Plugins
-
-- **✓ Verified Plugins**: Reviewed by maintainers, follow best practices, no known security issues
-- **⚠ Unverified Plugins**: User-contributed, not reviewed, install at your own risk
-
-When installing from a custom GitHub URL, you'll see a warning:
-
-```
-⚠️ WARNING: Installing Unverified Plugin
-
-You are about to install a plugin from a custom GitHub URL that has not been 
-verified by the LEDMatrix maintainers. Only install plugins from sources you trust.
-
-Plugin will have access to:
-- Your display manager
-- Your cache manager
-- Configuration files
-- Network access (if plugin makes API calls)
-
-Repo: https://github.com/unknown-user/plugin-name
-```
-
-### Best Practices
-
-1. **Only install plugins from trusted sources**
-2. **Review plugin code before installing** (click "View on GitHub")
-3. **Check plugin ratings and reviews** (when available)
-4. **Keep plugins updated** for security patches
-5. **Report suspicious plugins** to maintainers
-
-## Troubleshooting
-
-### Plugin Won't Install
-
-**Problem:** Installation fails with "Failed to clone or download repository"
-
-**Solutions:**
-- Check that git is installed: `which git`
-- Verify the GitHub URL is correct
-- Check your internet connection
-- Try installing via download if git fails
-
-### Plugin Won't Load
-
-**Problem:** Plugin installed but doesn't appear in rotation
-
-**Solutions:**
-1. Check that plugin is enabled in config: `"enabled": true`
-2. Verify manifest.json exists and is valid
-3. Check logs for errors: `sudo journalctl -u ledmatrix -f`
-4. Restart the display service: `sudo systemctl restart ledmatrix`
-
-### Dependencies Failed
-
-**Problem:** "Error installing dependencies" message
-
-**Solutions:**
-- Check that pip3 is installed
-- Manually install: `pip3 install --break-system-packages -r plugins/plugin-id/requirements.txt`
-- Check for conflicting package versions
-
-### Plugin Shows Errors
-
-**Problem:** Plugin loads but shows error message on display
-
-**Solutions:**
-1. Check plugin configuration is correct
-2. Verify API keys are set (if plugin needs them)
-3. Check plugin logs: `sudo journalctl -u ledmatrix -f | grep plugin-id`
-4. Report issue to plugin developer on GitHub
-
-## Command-Line Usage
-
-For advanced users, you can manage plugins via command line:
-
-```bash
-# Install from registry
-python3 -c "
-from src.plugin_system.store_manager import PluginStoreManager
-store = PluginStoreManager()
-store.install_plugin('clock-simple')
-"
-
-# Install from URL
-python3 -c "
-from src.plugin_system.store_manager import PluginStoreManager
-store = PluginStoreManager()
-result = store.install_from_url('https://github.com/user/plugin')
-print(result)
-"
-
-# List installed
-python3 -c "
-from src.plugin_system.store_manager import PluginStoreManager
-store = PluginStoreManager()
-for plugin_id in store.list_installed_plugins():
-    info = store.get_installed_plugin_info(plugin_id)
-    print(f"{plugin_id}: {info['name']} (Last updated: {info.get('last_updated', 'unknown')})")
-"
-
-# Uninstall
-python3 -c "
-from src.plugin_system.store_manager import PluginStoreManager
-store = PluginStoreManager()
-store.uninstall_plugin('clock-simple')
-"
-```
-
-## API Reference
-
-All API endpoints return JSON with this structure:
-
-```json
-{
-  "status": "success" | "error",
-  "message": "Human-readable message",
-  "data": { ... }  // Varies by endpoint
-}
-```
-
-### Endpoints
-
-| Method | Endpoint | Description |
-|--------|----------|-------------|
-| GET | `/api/plugins/store/list` | List all plugins in store |
-| GET | `/api/plugins/store/search` | Search for plugins |
-| GET | `/api/plugins/installed` | List installed plugins |
-| POST | `/api/plugins/install` | Install from registry |
-| POST | `/api/plugins/install-from-url` | Install from GitHub URL |
-| POST | `/api/plugins/uninstall` | Uninstall plugin |
-| POST | `/api/plugins/update` | Update plugin |
-| POST | `/api/plugins/toggle` | Enable/disable plugin |
-| POST | `/api/plugins/config` | Update plugin config |
-
-## Examples
-
-### Example 1: Install Clock Plugin
-
-```bash
-# Install
-curl -X POST http://192.168.1.100:5050/api/plugins/install \
-  -H "Content-Type: application/json" \
-  -d '{"plugin_id": "clock-simple"}'
-
-# Configure
-cat >> config/config.json << EOF
-{
-  "clock-simple": {
-    "enabled": true,
-    "display_duration": 20,
-    "time_format": "24h"
-  }
-}
-EOF
-
-# Restart display
-sudo systemctl restart ledmatrix
-```
-
-### Example 2: Install Custom Plugin from GitHub
-
-```bash
-# Install your own plugin during development
-curl -X POST http://192.168.1.100:5050/api/plugins/install-from-url \
-  -H "Content-Type: application/json" \
-  -d '{"repo_url": "https://github.com/myusername/ledmatrix-my-custom-plugin"}'
-
-# Enable it
-curl -X POST http://192.168.1.100:5050/api/plugins/toggle \
-  -H "Content-Type: application/json" \
-  -d '{"plugin_id": "my-custom-plugin", "enabled": true}'
-
-# Restart
-sudo systemctl restart ledmatrix
-```
-
-### Example 3: Share Plugin with Others
-
-As a plugin developer, you can share your plugin with others even before it's in the official store:
-
-```markdown
-# Share this URL with users:
-https://github.com/yourusername/ledmatrix-awesome-plugin
-
-# Users install with:
-1. Go to LEDMatrix web interface
-2. Click "Plugin Store" tab
-3. Scroll to "Install from URL"
-4. Paste: https://github.com/yourusername/ledmatrix-awesome-plugin
-5. Click "Install from URL"
-```
-
-## FAQ
-
-**Q: Do I need to restart the display after installing a plugin?**  
-A: Yes, plugins are loaded when the display controller starts.
-
-**Q: Can I install plugins while the display is running?**  
-A: Yes, you can install anytime, but you must restart to load them.
-
-**Q: What happens if I install a plugin with the same ID as an existing one?**  
-A: The existing copy will be replaced with the latest code from the repository.
-
-**Q: Can I install multiple versions of the same plugin?**  
-A: No, each plugin ID maps to a single checkout of the repository's default branch.
-
-**Q: How do I update all plugins at once?**  
-A: Currently, you need to update each plugin individually. Bulk update is planned for a future release.
-
-**Q: Can plugins access my API keys from config_secrets.json?**  
-A: Yes, if a plugin needs API keys, it can access them like core managers do.
-
-**Q: How much disk space do plugins use?**  
-A: Most plugins are small (1-5MB). Check individual plugin documentation.
-
-**Q: Can I create my own plugin?**  
-A: Yes! See PLUGIN_DEVELOPER_GUIDE.md for instructions.
-
-## Support
-
-- **Documentation**: See PLUGIN_ARCHITECTURE_SPEC.md
-- **Issues**: Report bugs on GitHub
-- **Community**: Join discussions in Issues
-- **Developer Guide**: See PLUGIN_DEVELOPER_GUIDE.md for creating plugins
-

docs/archive/RECONNECT_AFTER_CAPTIVE_PORTAL_TESTING.md

@@ -1,361 +0,0 @@
-# Reconnecting to Internet After Captive Portal Testing
-
-If captive portal testing fails or you need to reconnect to your normal network, here are several methods to get back online.
-
-## Quick Reference
-
-**Before testing:** Always run `sudo ./scripts/verify_wifi_before_testing.sh` first!
-
-**If stuck:** Run `sudo ./scripts/emergency_reconnect.sh` for automated recovery.
-
-## Quick Recovery Methods
-
-### Method 1: Via Web Interface (If Accessible)
-
-If you can still access the web interface at `http://192.168.4.1:5000`:
-
-1. **Navigate to WiFi tab**
-2. **Click "Scan"** to find available networks
-3. **Select your network** from the dropdown
-4. **Enter your WiFi password**
-5. **Click "Connect"**
-6. **Wait for connection** - AP mode should automatically disable
-
-### Method 2: Via SSH (If You Have Direct Access)
-
-If you have SSH access to the Pi (via Ethernet, direct connection, or still connected to AP):
-
-```bash
-# Connect via SSH
-ssh user@192.168.4.1  # If connected to AP
-# OR
-ssh user@<pi-ip>      # If on same network
-
-# Disable AP mode first
-sudo systemctl stop hostapd
-sudo systemctl stop dnsmasq
-
-# Connect to WiFi using nmcli
-sudo nmcli device wifi connect "YourNetworkName" password "YourPassword"
-
-# Or if you have a saved connection
-sudo nmcli connection up "YourNetworkName"
-```
-
-### Method 3: Via API Endpoints (If Web Interface Works)
-
-If the web interface is accessible but you can't use the UI:
-
-```bash
-# Connect to WiFi via API
-curl -X POST http://192.168.4.1:5000/api/v3/wifi/connect \
-  -H "Content-Type: application/json" \
-  -d '{"ssid": "YourNetworkName", "password": "YourPassword"}'
-
-# Disable AP mode
-curl -X POST http://192.168.4.1:5000/api/v3/wifi/ap/disable
-```
-
-### Method 4: Direct Command Line (Physical Access)
-
-If you have physical access to the Pi or a keyboard/monitor:
-
-```bash
-# Disable AP mode services
-sudo systemctl stop hostapd
-sudo systemctl stop dnsmasq
-
-# Check available networks
-nmcli device wifi list
-
-# Connect to your network
-sudo nmcli device wifi connect "YourNetworkName" password "YourPassword"
-
-# Verify connection
-nmcli device status
-ip addr show wlan0
-```
-
-### Method 5: Using Saved Network Configuration
-
-If you've previously connected to a network, it may be saved:
-
-```bash
-# List saved connections
-nmcli connection show
-
-# Activate a saved connection
-sudo nmcli connection up "YourSavedConnectionName"
-
-# Or by UUID
-sudo nmcli connection up <uuid>
-```
-
-## Step-by-Step Recovery Procedure
-
-### Scenario 1: Still Connected to AP Network
-
-If you're still connected to "LEDMatrix-Setup":
-
-1. **Access web interface:**
-   ```
-   http://192.168.4.1:5000
-   ```
-
-2. **Go to WiFi tab**
-
-3. **Connect to your network** using the interface
-
-4. **Wait for connection** - you'll be disconnected from AP
-
-5. **Reconnect to your new network** and access Pi at its new IP
-
-### Scenario 2: Can't Access Web Interface
-
-If web interface is not accessible:
-
-1. **SSH into Pi** (if possible):
-   ```bash
-   ssh user@192.168.4.1  # Via AP
-   # OR via Ethernet if connected
-   ```
-
-2. **Disable AP mode:**
-   ```bash
-   sudo systemctl stop hostapd dnsmasq
-   ```
-
-3. **Connect to WiFi:**
-   ```bash
-   sudo nmcli device wifi connect "YourNetwork" password "YourPassword"
-   ```
-
-4. **Verify connection:**
-   ```bash
-   nmcli device status
-   ping -c 3 8.8.8.8  # Test internet connectivity
-   ```
-
-### Scenario 3: No Network Access at All
-
-If you have no network access (AP not working, no Ethernet):
-
-1. **Physical access required:**
-   - Connect keyboard and monitor to Pi
-   - Or use serial console if available
-
-2. **Disable AP services:**
-   ```bash
-   sudo systemctl stop hostapd
-   sudo systemctl stop dnsmasq
-   sudo systemctl disable hostapd  # Prevent auto-start
-   sudo systemctl disable dnsmasq
-   ```
-
-3. **Connect to WiFi manually:**
-   ```bash
-   sudo nmcli device wifi list
-   sudo nmcli device wifi connect "YourNetwork" password "YourPassword"
-   ```
-
-4. **Restart network services if needed:**
-   ```bash
-   sudo systemctl restart NetworkManager
-   ```
-
-## Emergency Recovery Script
-
-Create this script for quick recovery:
-
-```bash
-#!/bin/bash
-# emergency_reconnect.sh - Emergency WiFi reconnection script
-
-echo "Emergency WiFi Reconnection"
-echo "=========================="
-
-# Stop AP mode
-echo "Stopping AP mode..."
-sudo systemctl stop hostapd 2>/dev/null
-sudo systemctl stop dnsmasq 2>/dev/null
-
-# List available networks
-echo ""
-echo "Available networks:"
-nmcli device wifi list
-
-# Prompt for network
-echo ""
-read -p "Enter network SSID: " SSID
-read -sp "Enter password: " PASSWORD
-echo ""
-
-# Connect
-echo "Connecting to $SSID..."
-sudo nmcli device wifi connect "$SSID" password "$PASSWORD"
-
-# Wait a moment
-sleep 3
-
-# Check status
-if nmcli device status | grep -q "connected"; then
-    echo "✓ Connected successfully!"
-    IP=$(ip addr show wlan0 | grep "inet " | awk '{print $2}' | cut -d/ -f1)
-    echo "IP Address: $IP"
-else
-    echo "✗ Connection failed. Check credentials and try again."
-fi
-```
-
-Save as `scripts/emergency_reconnect.sh` and make executable:
-```bash
-chmod +x scripts/emergency_reconnect.sh
-sudo ./scripts/emergency_reconnect.sh
-```
-
-## Preventing Issues
-
-### Before Testing
-
-1. **Save your current network connection:**
-   ```bash
-   # Your network should already be saved if you've connected before
-   nmcli connection show
-   ```
-
-2. **Note your Pi's IP address** on your normal network:
-   ```bash
-   hostname -I
-   ```
-
-3. **Ensure you have alternative access:**
-   - Ethernet cable (if available)
-   - SSH access via another method
-   - Physical access to Pi
-
-### During Testing
-
-1. **Keep a terminal/SSH session open** to the Pi
-2. **Test from a secondary device** (not your main computer)
-3. **Have the recovery commands ready**
-
-### After Testing
-
-1. **Verify internet connectivity:**
-   ```bash
-   ping -c 3 8.8.8.8
-   curl -I https://www.google.com
-   ```
-
-2. **Check Pi's new IP address:**
-   ```bash
-   hostname -I
-   ip addr show wlan0
-   ```
-
-3. **Update your SSH/config** if IP changed
-
-## Troubleshooting Reconnection
-
-### Issue: Can't Connect to Saved Network
-
-**Solution:**
-```bash
-# Remove old connection and reconnect
-nmcli connection delete "NetworkName"
-sudo nmcli device wifi connect "NetworkName" password "Password"
-```
-
-### Issue: AP Mode Won't Disable
-
-**Solution:**
-```bash
-# Force stop services
-sudo systemctl stop hostapd dnsmasq
-sudo systemctl disable hostapd dnsmasq
-
-# Kill processes if needed
-sudo pkill hostapd
-sudo pkill dnsmasq
-
-# Restart NetworkManager
-sudo systemctl restart NetworkManager
-```
-
-### Issue: WiFi Interface Stuck
-
-**Solution:**
-```bash
-# Reset WiFi interface
-sudo nmcli radio wifi off
-sleep 2
-sudo nmcli radio wifi on
-sleep 3
-
-# Try connecting again
-sudo nmcli device wifi connect "NetworkName" password "Password"
-```
-
-### Issue: No Networks Found
-
-**Solution:**
-```bash
-# Check WiFi is enabled
-nmcli radio wifi
-
-# Enable if off
-sudo nmcli radio wifi on
-
-# Check interface status
-ip link show wlan0
-
-# Restart NetworkManager
-sudo systemctl restart NetworkManager
-```
-
-## Quick Reference Commands
-
-```bash
-# Disable AP mode
-sudo systemctl stop hostapd dnsmasq
-
-# List WiFi networks
-nmcli device wifi list
-
-# Connect to network
-sudo nmcli device wifi connect "SSID" password "Password"
-
-# Check connection status
-nmcli device status
-
-# Get IP address
-hostname -I
-ip addr show wlan0
-
-# Test internet
-ping -c 3 8.8.8.8
-
-# Restart network services
-sudo systemctl restart NetworkManager
-```
-
-## Best Practices
-
-1. **Always test from a secondary device** - Keep your main computer on your normal network
-2. **Have Ethernet backup** - If available, keep Ethernet connected as fallback
-3. **Save network credentials** - Ensure your network is saved before testing
-4. **Document your Pi's IP** - Note the IP on your normal network before testing
-5. **Keep SSH session open** - Maintain an active SSH connection during testing
-6. **Test during safe times** - Don't test when you need immediate internet access
-
-## Recovery Checklist
-
-- [ ] Stop AP mode services (hostapd, dnsmasq)
-- [ ] Verify WiFi interface is available
-- [ ] Scan for available networks
-- [ ] Connect to your network
-- [ ] Verify connection status
-- [ ] Test internet connectivity
-- [ ] Note new IP address
-- [ ] Update any configurations that reference old IP
-

docs/archive/STARTUP_OPTIMIZATION_SUMMARY.md

@@ -1,299 +0,0 @@
-# LED Matrix Startup Optimization Summary
-
-## Overview
-This document summarizes the startup performance optimizations implemented to reduce the LED matrix display startup time from **102 seconds to under 10 seconds** (90%+ improvement).
-
-## Implemented Optimizations
-
-### Phase 1: High-Impact Changes (90+ seconds savings)
-
-#### 1. Smart Dependency Checking with Marker Files ✅
-**Impact: ~90 seconds savings**
-
-**Problem**: Running `pip install -r requirements.txt` for every plugin on every startup, even when dependencies were already installed.
-
-**Solution**:
-- Added marker file system at `/var/cache/ledmatrix/plugin_<id>_deps_installed`
-- Tracks which plugins have had dependencies installed
-- Only installs dependencies on first load or when marker is missing
-- Marker created with timestamp after successful installation
-- Marker removed when plugin is uninstalled
-
-**Files Modified**:
-- `src/plugin_system/plugin_manager.py`:
-  - Added `_get_dependency_marker_path()`
-  - Added `_check_dependencies_installed()`
-  - Added `_mark_dependencies_installed()`
-  - Added `_remove_dependency_marker()`
-  - Modified `load_plugin()` to check marker before installing
-  - Modified `unload_plugin()` to remove marker
-
-**Utility Script**: `scripts/clear_dependency_markers.sh` - Clears all markers to force fresh check
-
-#### 2. Removed Cache Clear at Startup ✅
-**Impact: ~5-30 seconds savings**
-
-**Problem**: Clearing entire cache on startup forced fresh API calls for all plugins, defeating the purpose of caching.
-
-**Solution**:
-- Removed `cache_manager.clear_cache()` call from startup
-- Removed 5-second sleep waiting for data
-- Trust cache TTL mechanisms for staleness
-- Let plugins use cached data immediately at startup
-- Background updates will refresh naturally
-
-**Files Modified**:
-- `src/display_controller.py` (lines 447-452):
-  - Removed cache clear and sleep
-  - Added comment explaining fast startup approach
-
-### Phase 2: Quick Wins (8-10 seconds savings)
-
-#### 3. Enhanced Startup Progress Logging ✅
-**Impact: Visibility improvement (no performance change)**
-
-**Features**:
-- Shows plugin count and progress (1/9, 2/9, etc.)
-- Displays individual plugin load times
-- Shows cumulative progress percentage
-- Reports elapsed time
-- Uses ✓ and ✗ symbols for success/failure
-
-**Files Modified**:
-- `src/display_controller.py` (lines 109-192):
-  - Added enabled plugin counting
-  - Added per-plugin timing
-  - Added progress percentage calculation
-  - Enhanced logging with symbols
-
-#### 4. Lazy-Load Flight Tracker Aircraft Database ✅
-**Impact: ~8-10 seconds savings at startup**
-
-**Problem**: Loading 70MB aircraft database during plugin initialization, even if not immediately needed.
-
-**Solution**:
-- Defer database loading until first use
-- Added `_ensure_database_loaded()` method
-- Called automatically when database is first accessed
-- Tracks load state to avoid repeated attempts
-- Logs load time when it happens (during first display, not startup)
-
-**Files Modified**:
-- `plugins/ledmatrix-flights/manager.py`:
-  - Modified `__init__()` to defer database loading
-  - Added `_ensure_database_loaded()` method
-  - Modified `_get_aircraft_info_from_database()` to lazy-load
-
-### Phase 3: Advanced Optimization (2-3 seconds savings)
-
-#### 5. Parallel Plugin Loading ✅
-**Impact: ~2-3 seconds savings**
-
-**Solution**:
-- Use `ThreadPoolExecutor` with 4 concurrent workers
-- Load plugins in parallel instead of serially
-- Process results as they complete
-- Thread-safe plugin registration
-
-**Files Modified**:
-- `src/display_controller.py` (lines 1-7, 109-192):
-  - Added ThreadPoolExecutor import
-  - Created `load_single_plugin()` helper function
-  - Parallel execution with progress tracking
-  - Error handling per plugin
-
-## Expected Performance Results
-
-### Baseline (Before Optimizations)
-- **Total startup time**: 102.27 seconds
-- Core initialization: 1.65 seconds (fast)
-- Plugin loading: 100.6 seconds (bottleneck)
-  - Dependency checks: ~90 seconds
-  - Flight tracker DB: ~8 seconds
-  - Other init: ~2 seconds
-
-### After Phase 1
-- **Expected**: ~12 seconds (90% improvement)
-- Dependency checks: 0 seconds (after first run)
-- Cache clear removed: 5+ seconds saved
-- **Savings**: 90 seconds
-
-### After Phase 2
-- **Expected**: ~3-4 seconds (96% improvement)
-- Flight tracker DB lazy-loaded: 8-10 seconds saved
-- **Savings**: 98 seconds total
-
-### After Phase 3
-- **Expected**: ~2 seconds (98% improvement)
-- Parallel loading: 2-3 seconds saved
-- **Savings**: 100+ seconds total
-
-## Testing and Validation
-
-### On Development Machine
-```bash
-# Test with emulator
-./scripts/dev/run_emulator.sh
-
-# Check logs for timing information
-# Look for:
-# - "Loading X enabled plugin(s) in parallel"
-# - Individual plugin load times
-# - "Plugin system initialized in X.XXX seconds"
-# - "DisplayController initialization completed in X.XXX seconds"
-```
-
-### On Raspberry Pi
-
-```bash
-# Deploy changes
-cd /home/ledpi/LEDMatrix
-git pull origin plugins  # or your branch
-
-# Restart service
-sudo systemctl restart ledmatrix
-
-# Check startup time
-journalctl -u ledmatrix -b | grep -E "(Starting DisplayController|DisplayController initialization completed|Plugin system initialized)"
-
-# Check for dependency installations (should only happen on first run)
-journalctl -u ledmatrix -b | grep "Installing dependencies"
-
-# Check marker files
-ls -la /var/cache/ledmatrix/plugin_*_deps_installed
-
-# Monitor live
-journalctl -u ledmatrix -f
-```
-
-### Benchmarking Commands
-
-```bash
-# Get startup time from latest boot
-journalctl -u ledmatrix -b | grep "DisplayController initialization completed"
-
-# Compare with previous boots
-journalctl -u ledmatrix --since "1 day ago" | grep "DisplayController initialization completed"
-
-# Check dependency marker status
-ls -lh /var/cache/ledmatrix/plugin_*_deps_installed
-```
-
-## Troubleshooting
-
-### Plugins Fail Due to Missing Dependencies
-
-**Symptoms**: Plugin fails to import with ModuleNotFoundError
-
-**Solution**:
-```bash
-# Clear markers to force fresh dependency install
-sudo /home/ledpi/LEDMatrix/scripts/clear_dependency_markers.sh
-
-# Restart service
-sudo systemctl restart ledmatrix
-```
-
-### Want to Force Dependency Reinstall for a Specific Plugin
-
-```bash
-# Remove marker for specific plugin
-sudo rm /var/cache/ledmatrix/plugin_<plugin-id>_deps_installed
-
-# Restart service
-sudo systemctl restart ledmatrix
-```
-
-### Revert to Old Behavior (No Optimizations)
-
-To temporarily disable optimizations for testing:
-
-1. **Re-enable dependency checks every time**:
-   - Edit `src/plugin_system/plugin_manager.py`
-   - Comment out the marker check in `load_plugin()`
-
-2. **Re-enable cache clear**:
-   - Edit `src/display_controller.py`
-   - Add back cache clear and sleep in `run()` method
-
-## Performance Metrics to Monitor
-
-### Startup Metrics
-- Total initialization time
-- Plugin loading time
-- Individual plugin load times
-- First display ready time
-
-### Runtime Metrics
-- Memory usage (should be similar)
-- CPU usage (should be similar)
-- Display performance (should be identical)
-- Plugin functionality (should be identical)
-
-### Regression Indicators
-- Plugins failing to load
-- Missing dependencies errors
-- Stale data at startup (acceptable - will refresh)
-- Crashes during parallel loading
-
-## Rollback Plan
-
-If issues are encountered:
-
-1. **Revert Git commits**:
-   ```bash
-   git revert <commit-hash>
-   sudo systemctl restart ledmatrix
-   ```
-
-2. **Cherry-pick safe changes**:
-   - Keep progress logging (safe)
-   - Keep lazy-load flight tracker (safe)
-   - Revert parallel loading if issues
-   - Revert dependency markers if issues
-
-3. **Emergency rollback**:
-   ```bash
-   git checkout <previous-stable-commit>
-   sudo systemctl restart ledmatrix
-   ```
-
-## Success Criteria
-
-✅ Startup time reduced to under 10 seconds (from 102 seconds)
-✅ All plugins load successfully
-✅ All display modes function correctly
-✅ No regression in display quality or performance
-✅ Cached data used effectively at startup
-✅ Dependencies installed correctly on first run
-✅ Progress logging shows clear startup status
-
-## Files Modified Summary
-
-1. `src/plugin_system/plugin_manager.py` - Dependency marker system
-2. `src/display_controller.py` - Cache removal, progress logging, parallel loading
-3. `plugins/ledmatrix-flights/manager.py` - Lazy-load aircraft database
-4. `scripts/clear_dependency_markers.sh` - Utility script (new)
-
-## Maintenance Notes
-
-- **Dependency markers persist** across restarts - this is intentional
-- **Clear markers** when updating plugin dependencies
-- **Cache remains** across restarts - data refreshes via TTL
-- **Parallel loading** is safe due to plugin independence
-- **Progress logs** help diagnose slow plugins
-
-## Future Optimization Opportunities
-
-1. **Lazy-load other heavy resources** (e.g., stock logos, team logos)
-2. **Background plugin loading** - start display immediately, load remaining plugins in background
-3. **Plugin load prioritization** - load frequently-used plugins first
-4. **Cached manifest reading** - avoid re-parsing JSON on every startup
-5. **Optimized font loading** - lazy-load fonts per plugin
-
----
-
-**Implementation Date**: November 9, 2025
-**Version**: 1.0
-**Status**: ✅ Ready for Pi Deployment
-

docs/archive/STATIC_IMAGE_MULTI_UPLOAD_PLAN.md

@@ -1,378 +0,0 @@
-# Static Image Plugin - Multi-Image Upload & Rotation Implementation Plan
-
-## Overview
-
-Enhance the static-image plugin to support:
-1. **Multiple image uploads** via web UI
-2. **Image rotation** (sequential, random, time-based, date-based)
-3. **Robust asset management** (storage, validation, cleanup)
-4. **Future-proof architecture** for advanced rotation logic
-
-## Architecture Design
-
-### 1. Configuration Schema Enhancement
-
-#### Current Schema
-```json
-{
-  "image_path": "assets/static_images/default.png"
-}
-```
-
-#### Enhanced Schema (Backward Compatible)
-```json
-{
-  "image_config": {
-    "mode": "single" | "multiple",
-    "rotation_mode": "sequential" | "random" | "time_based" | "date_based",
-    "images": [
-      {
-        "id": "uuid-or-hash",
-        "path": "assets/plugins/static-image/uploads/image_1234567890.png",
-        "uploaded_at": "2025-01-15T10:30:00Z",
-        "display_order": 0,
-        "schedule": null  // Future: {"start_time": "08:00", "end_time": "18:00", "days": [1,2,3,4,5]}
-      }
-    ]
-  },
-  
-  // Legacy support - maps to single image mode
-  "image_path": "assets/static_images/default.png",
-  
-  // Rotation settings
-  "rotation_settings": {
-    "sequential_loop": true,
-    "random_seed": null,  // null = use time, or fixed seed for reproducible rotation
-    "time_intervals": {
-      "enabled": false,
-      "interval_seconds": 3600  // Change image every hour
-    },
-    "date_ranges": []  // Future: [{"start": "2025-12-01", "end": "2025-12-25", "image_id": "..."}]
-  }
-}
-```
-
-### 2. Asset Storage Structure
-
-```text
-assets/
-├── plugins/
-│   └── static-image/
-│       └── uploads/
-│           ├── image_1705312200_abc123.png
-│           ├── image_1705312400_def456.jpg
-│           └── .metadata.json  // Maps IDs to filenames
-```
-
-**Storage Strategy:**
-- Files stored in `assets/plugins/static-image/uploads/`
-- Filenames: `image_{timestamp}_{hash}.{ext}` (prevents collisions)
-- Metadata JSON tracks: ID → filename mapping, upload dates, file sizes
-- Cleanup: Remove files not referenced in config
-
-### 3. Backend API Endpoints
-
-#### POST `/api/v3/plugins/assets/upload`
-**Purpose:** Upload image files for a specific plugin
-
-**Request:**
-- `multipart/form-data`
-- `plugin_id`: string (required)
-- `files`: File[] (multiple files supported)
-- `rotation_mode`: string (optional, default: "sequential")
-
-**Response:**
-```json
-{
-  "status": "success",
-  "uploaded_files": [
-    {
-      "id": "uuid-here",
-      "filename": "image_1705312200_abc123.png",
-      "path": "assets/plugins/static-image/uploads/image_1705312200_abc123.png",
-      "size": 45678,
-      "uploaded_at": "2025-01-15T10:30:00Z"
-    }
-  ]
-}
-```
-
-**Validation:**
-- File type: PNG, JPG, JPEG, BMP, GIF
-- Max file size: 5MB per file
-- Max files per upload: 10
-- Total storage limit: 50MB per plugin
-
-#### DELETE `/api/v3/plugins/assets/delete`
-**Purpose:** Delete uploaded image
-
-**Request:**
-- `plugin_id`: string
-- `image_id`: string (from upload response)
-
-**Response:**
-```json
-{
-  "status": "success",
-  "deleted_file": "image_1705312200_abc123.png"
-}
-```
-
-#### GET `/api/v3/plugins/assets/list`
-**Purpose:** List all uploaded images for a plugin
-
-**Response:**
-```json
-{
-  "status": "success",
-  "images": [
-    {
-      "id": "uuid-here",
-      "filename": "image_1705312200_abc123.png",
-      "path": "assets/plugins/static-image/uploads/image_1705312200_abc123.png",
-      "size": 45678,
-      "uploaded_at": "2025-01-15T10:30:00Z"
-    }
-  ]
-}
-```
-
-### 4. Frontend Form Generator Enhancement
-
-#### Schema Format for File Upload
-```json
-{
-  "type": "object",
-  "properties": {
-    "images": {
-      "type": "array",
-      "x-widget": "file-upload",
-      "x-upload-config": {
-        "endpoint": "/api/v3/plugins/assets/upload",
-        "plugin_id_field": "plugin_id",
-        "max_files": 10,
-        "allowed_types": ["image/png", "image/jpeg", "image/bmp", "image/gif"],
-        "max_size_mb": 5
-      },
-      "items": {
-        "type": "object",
-        "properties": {
-          "id": {"type": "string"},
-          "path": {"type": "string"},
-          "uploaded_at": {"type": "string", "format": "date-time"}
-        }
-      },
-      "description": "Upload images to display. Multiple images will rotate based on rotation mode."
-    },
-    "rotation_mode": {
-      "type": "string",
-      "enum": ["sequential", "random", "time_based", "date_based"],
-      "default": "sequential",
-      "description": "How to rotate through images"
-    }
-  }
-}
-```
-
-#### UI Components
-1. **File Upload Widget:**
-   - Drag-and-drop zone
-   - File list with thumbnails
-   - Remove button per file
-   - Upload progress indicator
-   - Image preview before upload
-
-2. **Rotation Mode Selector:**
-   - Dropdown with rotation options
-   - Settings panel per mode:
-     - Sequential: Loop option
-     - Random: Seed option
-     - Time-based: Interval input
-     - Date-based: Calendar picker (future)
-
-### 5. Plugin Manager Updates
-
-#### Rotation Logic in `manager.py`
-
-```python
-class StaticImagePlugin(BasePlugin):
-    def __init__(self, ...):
-        # ... existing code ...
-        
-        # Enhanced image handling
-        self.image_config = config.get('image_config', {})
-        self.rotation_mode = self.image_config.get('rotation_mode', 'sequential')
-        self.rotation_settings = config.get('rotation_settings', {})
-        self.images_list = self.image_config.get('images', [])
-        self.current_image_index = 0
-        self.last_rotation_time = time.time()
-        
-        # Initialize rotation
-        self._setup_rotation()
-    
-    def _setup_rotation(self):
-        """Initialize rotation based on mode"""
-        if self.rotation_mode == 'random':
-            import random
-            seed = self.rotation_settings.get('random_seed')
-            if seed:
-                random.seed(seed)
-        
-        if not self.images_list:
-            # Fallback to legacy image_path
-            if self.image_path:
-                self.images_list = [{'path': self.image_path}]
-    
-    def _get_next_image(self) -> Optional[str]:
-        """Get next image path based on rotation mode"""
-        if not self.images_list:
-            return None
-        
-        if self.rotation_mode == 'sequential':
-            path = self.images_list[self.current_image_index]['path']
-            self.current_image_index = (self.current_image_index + 1) % len(self.images_list)
-            return path
-        
-        elif self.rotation_mode == 'random':
-            import random
-            return random.choice(self.images_list)['path']
-        
-        elif self.rotation_mode == 'time_based':
-            interval = self.rotation_settings.get('time_intervals', {}).get('interval_seconds', 3600)
-            now = time.time()
-            if now - self.last_rotation_time >= interval:
-                self.current_image_index = (self.current_image_index + 1) % len(self.images_list)
-                self.last_rotation_time = now
-            return self.images_list[self.current_image_index]['path']
-        
-        elif self.rotation_mode == 'date_based':
-            # Future implementation
-            return self._get_date_based_image()
-        
-        return self.images_list[0]['path']
-    
-    def display(self, force_clear: bool = False):
-        """Display current image based on rotation"""
-        image_path = self._get_next_image()
-        if not image_path or not os.path.exists(image_path):
-            self._display_error()
-            return
-        
-        self.image_path = image_path  # For compatibility
-        self._load_image()
-        
-        # ... rest of display logic ...
-```
-
-### 6. Asset Management System
-
-#### File Operations
-- **Upload:** Save to `assets/plugins/{plugin_id}/uploads/`
-- **Validation:** Check file type, size, dimensions
-- **Metadata:** Track in `.metadata.json`
-- **Cleanup:** Remove orphaned files on config save
-- **Permissions:** Ensure writable by web service
-
-#### Security
-- Validate file extensions (whitelist)
-- Check file content (magic bytes, not just extension)
-- Limit file sizes
-- Sanitize filenames
-- Prevent path traversal
-
-### 7. Migration Strategy
-
-#### Backward Compatibility
-1. **Legacy Support:**
-   - If `image_path` exists but no `image_config`, auto-convert
-   - Create `image_config` with single image from `image_path`
-
-2. **Config Migration:**
-```python
-def _migrate_legacy_config(self, config):
-    """Migrate legacy image_path to new image_config format"""
-    if 'image_path' in config and 'image_config' not in config:
-        config['image_config'] = {
-            'mode': 'single',
-            'rotation_mode': 'sequential',
-            'images': [{
-                'id': str(uuid.uuid4()),
-                'path': config['image_path'],
-                'uploaded_at': datetime.now().isoformat(),
-                'display_order': 0
-            }]
-        }
-    return config
-```
-
-## Implementation Phases
-
-### Phase 1: Core Upload System
-1. ✅ Enhanced config schema
-2. ✅ Backend upload endpoint
-3. ✅ Asset storage structure
-4. ✅ File validation
-
-### Phase 2: Frontend Integration
-5. ✅ File upload widget in form generator
-6. ✅ Image preview/management UI
-7. ✅ Rotation mode selector
-
-### Phase 3: Plugin Rotation Logic
-8. ✅ Update plugin manager with rotation
-9. ✅ Sequential rotation
-10. ✅ Random rotation
-
-### Phase 4: Advanced Features
-11. ✅ Time-based rotation
-12. ✅ Date-based rotation (future)
-13. ✅ Cleanup/orphan removal
-
-## File Structure Changes
-
-```text
-plugins/static-image/
-├── manager.py              # Enhanced with rotation logic
-├── config_schema.json      # Updated with upload/rotation fields
-├── manifest.json           # No changes
-└── README.md               # Update documentation
-
-web_interface/
-├── blueprints/
-│   └── api_v3.py           # Add upload/delete/list endpoints
-└── templates/v3/
-    └── partials/
-        └── plugins.html     # File upload widget
-
-assets/
-└── plugins/
-    └── static-image/
-        └── uploads/        # NEW - user uploaded images
-            └── .metadata.json
-```
-
-## Testing Checklist
-
-- [ ] Single image upload works
-- [ ] Multiple image upload works
-- [ ] File validation (type, size)
-- [ ] Sequential rotation cycles correctly
-- [ ] Random rotation works
-- [ ] Time-based rotation changes at intervals
-- [ ] Legacy config migration preserves existing images
-- [ ] Orphaned file cleanup on config save
-- [ ] Web UI displays upload widget correctly
-- [ ] Image preview shows before upload
-- [ ] Delete removes file and updates config
-- [ ] Error handling for missing/invalid files
-
-## Future Enhancements
-
-1. **Date-based rotation:** Display different images on specific dates
-2. **Time-of-day rotation:** Show images based on time ranges
-3. **Transition effects:** Fade between images
-4. **Image filters:** Apply effects (brightness, contrast)
-5. **Bulk operations:** Select multiple images for deletion
-6. **Image organization:** Folders/tags for images
-7. **Remote images:** Support URLs (with caching)
-

docs/archive/TROUBLESHOOTING_QUICK_START.md

@@ -1,92 +0,0 @@
-# Web Interface Troubleshooting - Quick Start
-
-## The Problem
-After reorganizing the web interface, it doesn't seem to run and shows no logging.
-
-## Why You're Not Seeing Logs
-
-**The web service logs to syslog, NOT stdout!** 
-
-The systemd service is configured with:
-```
-StandardOutput=syslog
-StandardError=syslog
-SyslogIdentifier=ledmatrix-web
-```
-
-## Immediate Actions (Run on Raspberry Pi)
-
-### 1. Run the Diagnostic Script
-```bash
-ssh ledpi@<your-pi-ip>
-cd ~/LEDMatrix
-bash scripts/diagnose_web_interface.sh
-```
-
-This automated script will check everything and tell you what's wrong.
-
-### 2. View the Actual Logs
-```bash
-# View recent logs
-sudo journalctl -u ledmatrix-web -n 50 --no-pager
-
-# Follow logs in real-time
-sudo journalctl -u ledmatrix-web -f
-```
-
-### 3. Check Service Status
-```bash
-sudo systemctl status ledmatrix-web
-```
-
-### 4. Try Manual Start (Best for Debugging)
-```bash
-cd ~/LEDMatrix
-python3 web_interface/start.py
-```
-
-This will show errors directly in your terminal.
-
-## Most Likely Issues
-
-### Issue 1: web_display_autostart is False
-The web interface is designed NOT to start if this config is false.
-
-**Fix:**
-```bash
-nano ~/LEDMatrix/config/config.json
-# Change: "web_display_autostart": true
-sudo systemctl restart ledmatrix-web
-```
-
-### Issue 2: Service Not Started
-**Fix:**
-```bash
-sudo systemctl start ledmatrix-web
-sudo systemctl enable ledmatrix-web
-```
-
-### Issue 3: Import Errors
-**Fix:**
-```bash
-cd ~/LEDMatrix
-pip3 install --break-system-packages -r web_interface/requirements.txt
-sudo systemctl restart ledmatrix-web
-```
-
-## Full Documentation
-
-- **Comprehensive Guide:** `docs/WEB_INTERFACE_TROUBLESHOOTING.md`
-- **Reorganization Info:** `WEB_INTERFACE_REORGANIZATION.md`
-
-## After Fixing
-
-Once it's working, you should see:
-- Service status: "active (running)" in green
-- Accessible at: `http://<your-pi-ip>:5000`
-- Logs showing: "Starting LED Matrix Web Interface V3..."
-
-## Need Help?
-
-Run the diagnostic script and share its output - it will show exactly what's wrong!
-

docs/archive/V3_INTERFACE_README.md

@@ -1,231 +0,0 @@
-# LED Matrix Web Interface v3
-
-## Overview
-
-The v3 web interface is a complete rewrite of the LED Matrix control panel using modern web technologies for better performance, maintainability, and user experience. It uses Flask + HTMX + Alpine.js for a lightweight, server-side rendered interface with progressive enhancement.
-
-## 🚀 Key Features
-
-### Architecture
-- **HTMX** for dynamic content loading without full page reloads
-- **Alpine.js** for reactive components and state management
-- **SSE (Server-Sent Events)** for real-time updates
-- **Modular design** with blueprints for better code organization
-- **Progressive enhancement** - works without JavaScript
-
-### User Interface
-- **Modern, responsive design** with Tailwind CSS utility classes
-- **Tab-based navigation** for easy access to different features
-- **Real-time updates** for system stats, logs, and display preview
-- **Modal dialogs** for configuration and plugin management
-- **Drag-and-drop** font upload with progress indicators
-
-## 📋 Implemented Features
-
-### ✅ Complete Modules
-1. **Overview** - System stats, quick actions, display preview
-2. **General Settings** - Timezone, location, autostart configuration
-3. **Display Settings** - Hardware configuration, brightness, options
-4. **Durations** - Display rotation timing configuration
-5. **Sports Configuration** - Per-league settings with on-demand modes
-6. **Plugin Management** - Install, configure, enable/disable plugins
-7. **Font Management** - Upload fonts, manage overrides, preview
-8. **Logs Viewer** - Real-time log streaming with filtering and search
-
-### 🎯 Key Improvements Over v1/v2
-
-- **Modular Architecture**: Each tab loads independently via HTMX
-- **Real-time Updates**: SSE streams for live stats and logs
-- **Better Error Handling**: Consistent API responses and user feedback
-- **Enhanced UX**: Loading states, progress indicators, notifications
-- **Schema-driven Forms**: Dynamic form generation from JSON schemas
-- **Responsive Design**: Works well on different screen sizes
-- **Performance**: Server-side rendering with minimal JavaScript
-
-## 🛠️ Technical Stack
-
-### Backend
-- **Flask** with Blueprints for modular organization
-- **Jinja2** templates for server-side rendering
-- **SSE** for real-time data streaming
-- **Consistent API** with JSON envelope responses
-
-### Frontend
-- **HTMX** for AJAX interactions without writing JavaScript
-- **Alpine.js** for reactive state management
-- **Tailwind CSS** utility classes for styling
-- **Font Awesome** for icons
-
-## 🚦 Getting Started
-
-### Prerequisites
-- Python 3.7+
-- Flask
-- LED Matrix project setup
-
-### Running the Interface
-
-1. **Start the v3 interface**:
-   ```bash
-   python3 web_interface/start.py
-   # Or use the shell script:
-   ./web_interface/run.sh
-   ```
-
-2. **Access the interface**:
-   - Open `http://localhost:5000` in your browser
-   - The interface will load with real-time system stats
-
-3. **Test functionality**:
-   ```bash
-   python test_v3_interface.py
-   ```
-
-### Navigation
-
-- **Overview**: System stats, quick actions, display preview
-- **General**: Basic settings (timezone, location, autostart)
-- **Display**: Hardware configuration (rows, columns, brightness)
-- **Sports**: Per-league configuration with on-demand modes
-- **Plugins**: Plugin management and store
-- **Fonts**: Font upload, overrides, and preview
-- **Logs**: Real-time log viewer with filtering
-
-## 🔧 API Endpoints
-
-### Core Endpoints
-- `GET /` - Main interface (serves v3)
-- `GET /v3` - v3 interface (backwards compatibility)
-
-### API v3 Endpoints
-- `GET /api/v3/config/main` - Get main configuration
-- `POST /api/v3/config/main` - Save main configuration
-- `GET /api/v3/system/status` - Get system status
-- `POST /api/v3/system/action` - Execute system actions
-- `GET /api/v3/plugins/installed` - Get installed plugins
-- `GET /api/v3/fonts/catalog` - Get font catalog
-
-### SSE Streams
-- `/api/v3/stream/stats` - Real-time system stats
-- `/api/v3/stream/display` - Display preview updates
-- `/api/v3/stream/logs` - Real-time log streaming
-
-## 📁 File Structure
-
-```
-LEDMatrix/
-├── web_interface/               # Web interface package
-│   ├── __init__.py
-│   ├── app.py                  # Main Flask app with blueprints
-│   ├── start.py                # Startup script
-│   ├── run.sh                  # Shell runner
-│   ├── requirements.txt        # Dependencies
-│   ├── README.md               # Web interface documentation
-│   ├── blueprints/
-│   │   ├── __init__.py
-│   │   ├── pages_v3.py        # HTML pages and partials
-│   │   └── api_v3.py          # API endpoints
-│   ├── templates/v3/
-│   │   ├── base.html          # Main layout template
-│   │   ├── index.html         # Overview page
-│   │   └── partials/          # HTMX partials
-│   │       ├── overview.html
-│   │       ├── general.html
-│   │       ├── display.html
-│   │       ├── sports.html
-│   │       ├── plugins.html
-│   │       ├── fonts.html
-│   │       └── logs.html
-│   └── static/v3/
-│       ├── app.css            # Custom styles
-│       └── app.js             # JavaScript helpers
-├── old_web_interface/          # Legacy v1/v2 (for reference)
-├── start_web_conditionally.py  # Service starter
-└── test_v3_interface.py        # Test script
-```
-
-## 🔄 Migration from v1/v2
-
-### What Changed
-- **Default Route**: `/` now serves v3 interface (was v1)
-- **API Prefix**: All v3 APIs use `/api/v3/` prefix
-- **SSE Streams**: New real-time update mechanism
-- **Modular Design**: Tabs load independently via HTMX
-
-### Backwards Compatibility
-- Old `/` route redirects to `/v3`
-- Original v1 interface still accessible via other routes
-- All existing functionality preserved in new structure
-
-### Migration Path
-1. **Phase 1-7**: Implement all v3 features ✅
-2. **Phase 8**: Update default route to v3 ✅
-3. **Testing**: Run comprehensive tests ✅
-4. **Cutover**: v3 becomes default interface ✅
-
-## 🧪 Testing
-
-### Automated Tests
-```bash
-python test_v3_interface.py
-```
-
-Tests cover:
-- Basic connectivity and routing
-- API endpoint accessibility
-- SSE stream functionality
-- HTMX partial loading
-- Form submissions
-- Configuration saving
-
-### Manual Testing Checklist
-
-- [ ] Navigate between all tabs
-- [ ] Test form submissions (General, Display, Sports)
-- [ ] Verify real-time updates (stats, logs)
-- [ ] Test plugin management (enable/disable)
-- [ ] Upload a font file
-- [ ] Test responsive design on mobile
-- [ ] Verify error handling for invalid inputs
-
-## 🚨 Known Limitations
-
-### Current Implementation
-- **Sample Data**: Many endpoints return sample data for testing
-- **No Real Integration**: Backend doesn't fully integrate with actual services yet
-- **Basic Error Handling**: Could be more comprehensive
-- **No Authentication**: Assumes local/trusted network
-
-### Production Readiness
-- **Security**: Add authentication and CSRF protection
-- **Performance**: Optimize for high traffic
-- **Monitoring**: Add proper logging and metrics
-- **Integration**: Connect to real LED matrix hardware/services
-
-## 🔮 Future Enhancements
-
-### Planned Features
-- **Advanced Editor**: Visual layout editor for display elements
-- **Plugin Store Integration**: Real plugin discovery and installation
-- **Advanced Analytics**: Usage metrics and performance monitoring
-- **Mobile App**: Companion mobile app for remote control
-
-### Technical Improvements
-- **WebSockets**: Replace SSE for bidirectional communication
-- **Caching**: Add Redis or similar for better performance
-- **API Rate Limiting**: Protect against abuse
-- **Database Integration**: Move from file-based config
-
-## 📞 Support
-
-For issues or questions:
-1. Run the test script: `python test_v3_interface.py`
-2. Check the logs tab for real-time debugging
-3. Review the browser console for JavaScript errors
-4. File issues in the project repository
-
----
-
-**Status**: ⚠️ **UI framework complete; integration and production hardening required (not production-ready)**
-
-The v3 interface UI and layout are finished, providing a modern, maintainable foundation for LED Matrix control. However, real service integration, authentication, security hardening, and monitoring remain to be implemented before production use.

docs/archive/VEGAS_SCROLL_MODE.md

@@ -1,388 +0,0 @@
-# Vegas Scroll Mode - Plugin Developer Guide
-
-Vegas scroll mode displays content from multiple plugins in a continuous horizontal scroll, similar to the news tickers seen in Las Vegas casinos. This guide explains how to integrate your plugin with Vegas mode.
-
-## Overview
-
-When Vegas mode is enabled, the display controller composes content from all enabled plugins into a single continuous scroll. Each plugin can control how its content appears in the scroll using one of three **display modes**:
-
-| Mode | Behavior | Best For |
-|------|----------|----------|
-| **SCROLL** | Content scrolls continuously within the stream | Multi-item plugins (sports scores, odds, news) |
-| **FIXED_SEGMENT** | Fixed-width block that scrolls by | Static info (clock, weather, current temp) |
-| **STATIC** | Scroll pauses, plugin displays for duration, then resumes | Important alerts, detailed views |
-
-## Quick Start
-
-### Minimal Integration (Zero Code Changes)
-
-If you do nothing, your plugin will work with Vegas mode using these defaults:
-
-- Plugins with `get_vegas_content_type() == 'multi'` use **SCROLL** mode
-- Plugins with `get_vegas_content_type() == 'static'` use **FIXED_SEGMENT** mode
-- Content is captured by calling your plugin's `display()` method
-
-### Basic Integration
-
-To provide optimized Vegas content, implement `get_vegas_content()`:
-
-```python
-from PIL import Image
-
-class MyPlugin(BasePlugin):
-    def get_vegas_content(self):
-        """Return content for Vegas scroll mode."""
-        # Return a single image for fixed content
-        return self._render_current_view()
-
-        # OR return multiple images for multi-item content
-        # return [self._render_item(item) for item in self.items]
-```
-
-### Full Integration
-
-For complete control over Vegas behavior, implement these methods:
-
-```python
-from src.plugin_system.base_plugin import BasePlugin, VegasDisplayMode
-
-class MyPlugin(BasePlugin):
-    def get_vegas_content_type(self) -> str:
-        """Legacy method - determines default mode mapping."""
-        return 'multi'  # or 'static' or 'none'
-
-    def get_vegas_display_mode(self) -> VegasDisplayMode:
-        """Specify how this plugin behaves in Vegas scroll."""
-        return VegasDisplayMode.SCROLL
-
-    def get_supported_vegas_modes(self) -> list:
-        """Return list of modes users can configure."""
-        return [VegasDisplayMode.SCROLL, VegasDisplayMode.FIXED_SEGMENT]
-
-    def get_vegas_content(self):
-        """Return PIL Image(s) for the scroll."""
-        return [self._render_game(g) for g in self.games]
-
-    def get_vegas_segment_width(self) -> int:
-        """For FIXED_SEGMENT: width in panels (optional)."""
-        return 2  # Use 2 panels width
-```
-
-## Display Modes Explained
-
-### SCROLL Mode
-
-Content scrolls continuously within the Vegas stream. Best for plugins with multiple items.
-
-```python
-def get_vegas_display_mode(self):
-    return VegasDisplayMode.SCROLL
-
-def get_vegas_content(self):
-    # Return list of images - each scrolls individually
-    images = []
-    for game in self.games:
-        img = Image.new('RGB', (200, 32))
-        # ... render game info ...
-        images.append(img)
-    return images
-```
-
-**When to use:**
-- Sports scores with multiple games
-- Stock/odds tickers with multiple items
-- News feeds with multiple headlines
-
-### FIXED_SEGMENT Mode
-
-Content is rendered as a fixed-width block that scrolls by with other content.
-
-```python
-def get_vegas_display_mode(self):
-    return VegasDisplayMode.FIXED_SEGMENT
-
-def get_vegas_content(self):
-    # Return single image at your preferred width
-    img = Image.new('RGB', (128, 32))  # 2 panels wide
-    # ... render clock/weather/etc ...
-    return img
-
-def get_vegas_segment_width(self):
-    # Optional: specify width in panels
-    return 2
-```
-
-**When to use:**
-- Clock display
-- Current weather/temperature
-- System status indicators
-- Any "at a glance" information
-
-### STATIC Mode
-
-Scroll pauses completely, your plugin displays using its normal `display()` method for its configured duration, then scroll resumes.
-
-```python
-def get_vegas_display_mode(self):
-    return VegasDisplayMode.STATIC
-
-def get_display_duration(self):
-    # How long to pause and show this plugin
-    return 10.0  # 10 seconds
-```
-
-**When to use:**
-- Important alerts that need attention
-- Detailed information that's hard to read while scrolling
-- Interactive or animated content
-- Content that requires the full display
-
-## User Configuration
-
-Users can override the default display mode per-plugin in their config:
-
-```json
-{
-  "my_plugin": {
-    "enabled": true,
-    "vegas_mode": "static",       // Override: "scroll", "fixed", or "static"
-    "vegas_panel_count": 2,       // Width in panels for fixed mode
-    "display_duration": 10        // Duration for static mode
-  }
-}
-```
-
-The `get_vegas_display_mode()` method checks config first, then falls back to your implementation.
-
-## Content Rendering Guidelines
-
-### Image Dimensions
-
-- **Height**: Must match display height (typically 32 pixels)
-- **Width**:
-  - SCROLL: Any width, content will scroll
-  - FIXED_SEGMENT: `panels × single_panel_width` (e.g., 2 × 64 = 128px)
-
-### Color Mode
-
-Always use RGB mode for images:
-
-```python
-img = Image.new('RGB', (width, 32), color=(0, 0, 0))
-```
-
-### Performance Tips
-
-1. **Cache rendered images** - Don't re-render on every call
-2. **Pre-render on update()** - Render images when data changes, not when Vegas requests them
-3. **Keep images small** - Memory adds up with multiple plugins
-
-```python
-class MyPlugin(BasePlugin):
-    def __init__(self, ...):
-        super().__init__(...)
-        self._cached_vegas_images = None
-        self._cache_valid = False
-
-    def update(self):
-        # Fetch new data
-        self.data = self._fetch_data()
-        # Invalidate cache so next Vegas request re-renders
-        self._cache_valid = False
-
-    def get_vegas_content(self):
-        if not self._cache_valid:
-            self._cached_vegas_images = self._render_all_items()
-            self._cache_valid = True
-        return self._cached_vegas_images
-```
-
-## Fallback Behavior
-
-If your plugin doesn't implement `get_vegas_content()`, Vegas mode will:
-
-1. Create a temporary canvas matching display dimensions
-2. Call your `display()` method
-3. Capture the resulting image
-4. Use that image in the scroll
-
-This works but is less efficient than providing native Vegas content.
-
-## Excluding from Vegas Mode
-
-To exclude your plugin from Vegas scroll entirely:
-
-```python
-def get_vegas_content_type(self):
-    return 'none'
-```
-
-Or users can exclude via config:
-
-```json
-{
-  "display": {
-    "vegas_scroll": {
-      "excluded_plugins": ["my_plugin"]
-    }
-  }
-}
-```
-
-## Complete Example
-
-Here's a complete example of a weather plugin with full Vegas integration:
-
-```python
-from PIL import Image, ImageDraw
-from src.plugin_system.base_plugin import BasePlugin, VegasDisplayMode
-
-class WeatherPlugin(BasePlugin):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.temperature = None
-        self.conditions = None
-        self._vegas_image = None
-
-    def update(self):
-        """Fetch weather data."""
-        data = self._fetch_weather_api()
-        self.temperature = data['temp']
-        self.conditions = data['conditions']
-        self._vegas_image = None  # Invalidate cache
-
-    def display(self, force_clear=False):
-        """Standard display for normal rotation."""
-        if force_clear:
-            self.display_manager.clear()
-
-        # Full weather display with details
-        self.display_manager.draw_text(
-            f"{self.temperature}°F",
-            x=10, y=8, color=(255, 255, 255)
-        )
-        self.display_manager.draw_text(
-            self.conditions,
-            x=10, y=20, color=(200, 200, 200)
-        )
-        self.display_manager.update_display()
-
-    # --- Vegas Mode Integration ---
-
-    def get_vegas_content_type(self):
-        """Legacy compatibility."""
-        return 'static'
-
-    def get_vegas_display_mode(self):
-        """Use FIXED_SEGMENT for compact weather display."""
-        # Allow user override via config
-        return super().get_vegas_display_mode()
-
-    def get_supported_vegas_modes(self):
-        """Weather can work as fixed or static."""
-        return [VegasDisplayMode.FIXED_SEGMENT, VegasDisplayMode.STATIC]
-
-    def get_vegas_segment_width(self):
-        """Weather needs 2 panels to show clearly."""
-        return self.config.get('vegas_panel_count', 2)
-
-    def get_vegas_content(self):
-        """Render compact weather for Vegas scroll."""
-        if self._vegas_image is not None:
-            return self._vegas_image
-
-        # Create compact display (2 panels = 128px typical)
-        panel_width = 64  # From display.hardware.cols
-        panels = self.get_vegas_segment_width() or 2
-        width = panel_width * panels
-        height = 32
-
-        img = Image.new('RGB', (width, height), color=(0, 0, 40))
-        draw = ImageDraw.Draw(img)
-
-        # Draw compact weather
-        temp_text = f"{self.temperature}°"
-        draw.text((10, 8), temp_text, fill=(255, 255, 255))
-        draw.text((60, 8), self.conditions[:10], fill=(200, 200, 200))
-
-        self._vegas_image = img
-        return img
-```
-
-## API Reference
-
-### VegasDisplayMode Enum
-
-```python
-from src.plugin_system.base_plugin import VegasDisplayMode
-
-VegasDisplayMode.SCROLL        # "scroll" - continuous scrolling
-VegasDisplayMode.FIXED_SEGMENT # "fixed" - fixed block in scroll
-VegasDisplayMode.STATIC        # "static" - pause scroll to display
-```
-
-### BasePlugin Vegas Methods
-
-| Method | Returns | Description |
-|--------|---------|-------------|
-| `get_vegas_content()` | `Image` or `List[Image]` or `None` | Content for Vegas scroll |
-| `get_vegas_content_type()` | `str` | Legacy: 'multi', 'static', or 'none' |
-| `get_vegas_display_mode()` | `VegasDisplayMode` | How plugin behaves in Vegas |
-| `get_supported_vegas_modes()` | `List[VegasDisplayMode]` | Modes available for user config |
-| `get_vegas_segment_width()` | `int` or `None` | Width in panels for FIXED_SEGMENT |
-
-### Configuration Options
-
-**Per-plugin config:**
-```json
-{
-  "plugin_id": {
-    "vegas_mode": "scroll|fixed|static",
-    "vegas_panel_count": 2,
-    "display_duration": 15
-  }
-}
-```
-
-**Global Vegas config:**
-```json
-{
-  "display": {
-    "vegas_scroll": {
-      "enabled": true,
-      "scroll_speed": 50,
-      "separator_width": 32,
-      "plugin_order": ["clock", "weather", "sports"],
-      "excluded_plugins": ["debug_plugin"],
-      "target_fps": 125,
-      "buffer_ahead": 2
-    }
-  }
-}
-```
-
-## Troubleshooting
-
-### Plugin not appearing in Vegas scroll
-
-1. Check `get_vegas_content_type()` doesn't return `'none'`
-2. Verify plugin is not in `excluded_plugins` list
-3. Ensure plugin is enabled
-
-### Content looks wrong in scroll
-
-1. Verify image height matches display height (32px typical)
-2. Check image mode is 'RGB'
-3. Test with `get_vegas_content()` returning a simple test image
-
-### STATIC mode not pausing
-
-1. Verify `get_vegas_display_mode()` returns `VegasDisplayMode.STATIC`
-2. Check user hasn't overridden with `vegas_mode` in config
-3. Ensure `display()` method works correctly
-
-### Performance issues
-
-1. Implement image caching in `get_vegas_content()`
-2. Pre-render images in `update()` instead of on-demand
-3. Reduce image dimensions if possible

docs/archive/WEATHER_TROUBLESHOOTING.md

@@ -1,298 +0,0 @@
-# Weather Plugin Troubleshooting Guide
-
-## Quick Diagnosis
-
-Run the troubleshooting script on your Pi:
-
-```bash
-./troubleshoot_weather.sh
-```
-
-This will check:
-- Plugin installation
-- Configuration files
-- API key setup
-- Network connectivity
-- Cache status
-
-## Common Issues
-
-### 1. "No Weather Data" Message
-
-This appears when the weather plugin cannot fetch or access weather data.
-
-### 2. Missing or Invalid API Key
-
-**Symptoms:**
-- Plugin shows "No Weather Data"
-- Logs show "No valid OpenWeatherMap API key configured"
-- Plugin initialized but no data updates
-
-**Solution:**
-
-1. Get an API key from [OpenWeatherMap](https://openweathermap.org/api)
-   - Sign up for a free account
-   - Navigate to API Keys section
-   - Generate a new API key
-
-2. Add API key to `config/config_secrets.json` (recommended):
-   ```json
-   {
-     "ledmatrix-weather": {
-       "api_key": "your_actual_api_key_here"
-     }
-   }
-   ```
-
-   OR add directly to `config/config.json`:
-   ```json
-   {
-     "ledmatrix-weather": {
-       "enabled": true,
-       "api_key": "your_actual_api_key_here",
-       "location_city": "Dallas",
-       "location_state": "Texas",
-       "location_country": "US"
-     }
-   }
-   ```
-
-3. Restart the LEDMatrix service:
-   ```bash
-   sudo systemctl restart ledmatrix
-   ```
-
-### 3. Plugin Not Enabled
-
-**Symptoms:**
-- Plugin doesn't appear in display rotation
-- No weather data displayed
-
-**Solution:**
-
-Check `config/config.json` and ensure the plugin is enabled:
-
-```json
-{
-  "ledmatrix-weather": {
-    "enabled": true,
-    "display_duration": 30,
-    ...
-  }
-}
-```
-
-### 4. Network/API Connectivity Issues
-
-**Symptoms:**
-- Plugin shows "No Weather Data"
-- Logs show connection errors or timeouts
-
-**Solution:**
-
-1. Check internet connectivity:
-   ```bash
-   ping -c 4 api.openweathermap.org
-   ```
-
-2. Check firewall settings (if applicable)
-
-3. Verify DNS resolution:
-   ```bash
-   nslookup api.openweathermap.org
-   ```
-
-4. Test API directly:
-   ```bash
-   curl "https://api.openweathermap.org/data/2.5/weather?q=Dallas,TX,US&appid=YOUR_API_KEY&units=imperial"
-   ```
-
-### 5. API Rate Limits Exceeded
-
-**Symptoms:**
-- Plugin worked before but now shows "No Weather Data"
-- Logs show HTTP 429 errors
-
-**Solution:**
-
-OpenWeatherMap free tier limits:
-- 1,000 API calls per day
-- 60 calls per minute
-
-Default plugin settings use ~48 calls/day (1800s = 30 min intervals).
-
-If exceeded:
-- Wait for quota reset (daily)
-- Increase `update_interval` in config (minimum 300s = 5 minutes)
-- Upgrade OpenWeatherMap plan
-
-### 6. Invalid Location Configuration
-
-**Symptoms:**
-- Plugin shows "No Weather Data"
-- Logs show geocoding errors
-
-**Solution:**
-
-Ensure location is correctly configured in `config/config.json`:
-
-```json
-{
-  "ledmatrix-weather": {
-    "location_city": "Dallas",
-    "location_state": "Texas",
-    "location_country": "US"
-  }
-}
-```
-
-- Use proper city names
-- Include state for US cities to avoid ambiguity
-- Use ISO 3166-1 alpha-2 country codes (US, GB, CA, etc.)
-
-### 7. Stale Cache Data
-
-**Symptoms:**
-- Weather data not updating
-- Old data displayed
-
-**Solution:**
-
-Clear the cache:
-
-```bash
-# Find cache files
-find cache/ -name "*weather*" -type f
-
-# Remove cache files (plugin will fetch fresh data)
-rm cache/*weather*
-```
-
-### 8. Plugin Not Loading
-
-**Symptoms:**
-- Weather modes don't appear in available modes
-- Logs show plugin loading errors
-
-**Solution:**
-
-1. Check plugin directory exists:
-   ```bash
-   ls -la plugins/ledmatrix-weather/
-   ```
-
-2. Verify manifest.json is valid:
-   ```bash
-   python3 -m json.tool plugins/ledmatrix-weather/manifest.json
-   ```
-
-3. Check logs for specific errors:
-   ```bash
-   sudo journalctl -u ledmatrix -f | grep -i weather
-   ```
-
-4. Verify plugin dependencies are installed:
-   ```bash
-   pip3 install -r plugins/ledmatrix-weather/requirements.txt
-   ```
-
-## Checking Logs
-
-View real-time logs:
-
-```bash
-sudo journalctl -u ledmatrix -f
-```
-
-Filter for weather-related messages:
-
-```bash
-sudo journalctl -u ledmatrix -f | grep -i weather
-```
-
-View last 100 lines:
-
-```bash
-sudo journalctl -u ledmatrix -n 100 | grep -i weather
-```
-
-## Configuration Example
-
-Complete configuration in `config/config.json`:
-
-```json
-{
-  "ledmatrix-weather": {
-    "enabled": true,
-    "display_duration": 30,
-    "location_city": "Dallas",
-    "location_state": "Texas",
-    "location_country": "US",
-    "units": "imperial",
-    "update_interval": 1800,
-    "show_current_weather": true,
-    "show_hourly_forecast": true,
-    "show_daily_forecast": true,
-    "transition": {
-      "type": "redraw",
-      "speed": 2,
-      "enabled": true
-    }
-  }
-}
-```
-
-And in `config/config_secrets.json`:
-
-```json
-{
-  "ledmatrix-weather": {
-    "api_key": "your_openweathermap_api_key_here"
-  }
-}
-```
-
-## Plugin Configuration Schema
-
-The plugin expects configuration under either:
-- `ledmatrix-weather` (plugin ID from manifest)
-- `weather` (legacy/deprecated)
-
-The system checks both when loading configuration.
-
-## Testing the Plugin
-
-1. Enable the plugin in config
-2. Restart the service: `sudo systemctl restart ledmatrix`
-3. Check logs: `sudo journalctl -u ledmatrix -f`
-4. Wait for update interval (default 30 minutes) or force update
-5. Check if weather modes appear in display rotation
-
-## Still Having Issues?
-
-1. Run the troubleshooting script: `./troubleshoot_weather.sh`
-2. Check service status: `sudo systemctl status ledmatrix`
-3. Review logs for specific error messages
-4. Verify all configuration files are valid JSON
-5. Ensure file permissions are correct:
-   ```bash
-   ls -la config/config.json config/config_secrets.json
-   ```
-
-## API Key Security
-
-**Recommended:** Store API key in `config/config_secrets.json` with restricted permissions:
-
-```bash
-chmod 640 config/config_secrets.json
-```
-
-This file is not tracked by git (should be in .gitignore).
-
-## Plugin ID Note
-
-The weather plugin ID is `ledmatrix-weather` (from manifest.json). Configuration should use this ID, though the system also checks for `weather` for backward compatibility.
-
-
-
-

docs/archive/WEB_INTERFACE_TROUBLESHOOTING.md

@@ -1,314 +0,0 @@
-# Web Interface Troubleshooting Guide
-
-## Quick Diagnosis Steps
-
-Since the web interface doesn't seem to run and shows no logging after reorganization, follow these steps **on your Raspberry Pi** to diagnose the issue:
-
-### 1. Check Service Status
-
-```bash
-# Check if the web service is running
-sudo systemctl status ledmatrix-web
-
-# Check if it's enabled to start on boot
-sudo systemctl is-enabled ledmatrix-web
-```
-
-### 2. View Service Logs
-
-The service logs to **syslog**, not stdout. Use these commands to view logs:
-
-```bash
-# View recent web interface logs
-sudo journalctl -u ledmatrix-web -n 50 --no-pager
-
-# Follow logs in real-time
-sudo journalctl -u ledmatrix-web -f
-
-# View logs since last boot
-sudo journalctl -u ledmatrix-web -b
-```
-
-### 3. Check Configuration
-
-```bash
-# Check if web_display_autostart is enabled in config
-cat ~/LEDMatrix/config/config.json | grep web_display_autostart
-
-# Should show: "web_display_autostart": true
-```
-
-If it shows `false` or is missing, the web interface won't start (by design).
-
-### 4. Test Manual Startup
-
-Try starting the web interface manually to see error messages:
-
-```bash
-cd ~/LEDMatrix
-python3 web_interface/start.py
-```
-
-This will show any import errors or startup issues directly in the terminal.
-
-## Common Issues and Solutions
-
-### Issue 1: Service Not Running
-
-**Symptom:** `systemctl status ledmatrix-web` shows "inactive (dead)"
-
-**Solutions:**
-```bash
-# Start the service
-sudo systemctl start ledmatrix-web
-
-# Enable it to start on boot
-sudo systemctl enable ledmatrix-web
-
-# Check status again
-sudo systemctl status ledmatrix-web
-```
-
-### Issue 2: web_display_autostart is False
-
-**Symptom:** Service starts but immediately exits gracefully
-
-**Solution:**
-```bash
-# Edit config.json
-nano ~/LEDMatrix/config/config.json
-
-# Set web_display_autostart to true:
-"web_display_autostart": true
-
-# Restart the service
-sudo systemctl restart ledmatrix-web
-```
-
-### Issue 3: Import Errors
-
-**Symptom:** Service fails immediately with import errors in logs
-
-**Possible causes:**
-- Missing dependencies
-- Python path issues
-- Circular import problems
-
-**Solutions:**
-
-```bash
-# Install/reinstall web dependencies
-cd ~/LEDMatrix
-pip3 install --break-system-packages -r web_interface/requirements.txt
-
-# Check for Python errors
-python3 -c "from web_interface.app import app; print('OK')"
-```
-
-### Issue 4: Port Already in Use
-
-**Symptom:** Error message about port 5000 being in use
-
-**Solution:**
-```bash
-# Check what's using port 5000
-sudo lsof -i :5000
-
-# Kill the process if needed
-sudo kill -9 <PID>
-
-# Or change the port in web_interface/start.py
-```
-
-### Issue 5: Permission Issues
-
-**Symptom:** Permission denied errors in logs
-
-**Solution:**
-```bash
-# Ensure proper ownership
-cd ~/LEDMatrix
-sudo chown -R ledpi:ledpi .
-
-# Restart service
-sudo systemctl restart ledmatrix-web
-```
-
-### Issue 6: Flask/Blueprint Import Errors
-
-**Symptom:** ImportError or ModuleNotFoundError in logs
-
-**Check these files exist:**
-```bash
-ls -la ~/LEDMatrix/web_interface/app.py
-ls -la ~/LEDMatrix/web_interface/start.py
-ls -la ~/LEDMatrix/web_interface/blueprints/api_v3.py
-ls -la ~/LEDMatrix/web_interface/blueprints/pages_v3.py
-```
-
-If any are missing, you may need to restore from git or the reorganization.
-
-## Detailed Logging Commands
-
-### View All Web Service Logs
-```bash
-# Show all logs with timestamps
-sudo journalctl -u ledmatrix-web --no-pager
-
-# Show logs from the last hour
-sudo journalctl -u ledmatrix-web --since "1 hour ago"
-
-# Show logs between specific times
-sudo journalctl -u ledmatrix-web --since "2024-10-14 10:00:00" --until "2024-10-14 11:00:00"
-
-# Show only errors
-sudo journalctl -u ledmatrix-web -p err
-```
-
-### Check Python Import Issues
-```bash
-cd ~/LEDMatrix
-
-# Test imports step by step
-python3 -c "import sys; sys.path.insert(0, '.'); from src.config_manager import ConfigManager; print('ConfigManager OK')"
-
-python3 -c "import sys; sys.path.insert(0, '.'); from src.plugin_system.plugin_manager import PluginManager; print('PluginManager OK')"
-
-python3 -c "import sys; sys.path.insert(0, '.'); from web_interface.app import app; print('Flask App OK')"
-```
-
-## Service File Check
-
-Verify the service file is correct:
-
-```bash
-cat /etc/systemd/system/ledmatrix-web.service
-```
-
-Should contain:
-```
-[Unit]
-Description=LED Matrix Web Interface Service
-After=network.target
-
-[Service]
-Type=simple
-User=root
-WorkingDirectory=/home/ledpi/LEDMatrix
-Environment=USE_THREADING=1
-ExecStart=/usr/bin/python3 /home/ledpi/LEDMatrix/start_web_conditionally.py
-Restart=on-failure
-RestartSec=10
-StandardOutput=syslog
-StandardError=syslog
-SyslogIdentifier=ledmatrix-web
-
-[Install]
-WantedBy=multi-user.target
-```
-
-If it's different or points to old paths, reinstall it:
-
-```bash
-cd ~/LEDMatrix
-sudo bash install_web_service.sh
-sudo systemctl daemon-reload
-sudo systemctl restart ledmatrix-web
-```
-
-## Post-Reorganization Checklist
-
-Verify the reorganization completed correctly:
-
-```bash
-cd ~/LEDMatrix
-
-# These files should exist in new locations:
-ls web_interface/app.py
-ls web_interface/start.py
-ls web_interface/requirements.txt
-ls web_interface/blueprints/api_v3.py
-ls web_interface/blueprints/pages_v3.py
-
-# start_web_conditionally.py should point to new location
-grep "web_interface/start.py" start_web_conditionally.py
-```
-
-## Emergency Recovery
-
-If nothing works, you can rollback to the old structure:
-
-```bash
-cd ~/LEDMatrix
-
-# Check git status
-git status
-
-# If changes aren't committed, revert
-git checkout .
-
-# Or restore specific files from old_web_interface
-# (if that directory exists)
-```
-
-## Recommended Diagnostic Sequence
-
-Run these commands in order to get a complete picture:
-
-```bash
-#!/bin/bash
-echo "=== Web Interface Diagnostic Report ==="
-echo ""
-echo "1. Service Status:"
-sudo systemctl status ledmatrix-web
-echo ""
-echo "2. Config Autostart Setting:"
-cat ~/LEDMatrix/config/config.json | grep web_display_autostart
-echo ""
-echo "3. Recent Logs (last 20 lines):"
-sudo journalctl -u ledmatrix-web -n 20 --no-pager
-echo ""
-echo "4. File Structure Check:"
-ls -la ~/LEDMatrix/web_interface/
-echo ""
-echo "5. Python Import Test:"
-cd ~/LEDMatrix
-python3 -c "from web_interface.app import app; print('✓ Flask app imports successfully')" 2>&1
-echo ""
-echo "=== End of Diagnostic Report ==="
-```
-
-Save this as `diagnose_web.sh`, make it executable, and run it:
-
-```bash
-chmod +x diagnose_web.sh
-./diagnose_web.sh
-```
-
-## Success Indicators
-
-When the web interface is running correctly, you should see:
-
-1. **Service Status:** "active (running)" in green
-2. **Logs:** "Starting LED Matrix Web Interface V3..." 
-3. **Network:** Accessible at `http://<pi-ip>:5000`
-4. **Process:** Python process listening on port 5000
-
-```bash
-# Check if it's listening
-sudo netstat -tlnp | grep :5000
-# or
-sudo ss -tlnp | grep :5000
-```
-
-## Contact/Help
-
-If you've tried all these steps and it still doesn't work, collect the following information:
-
-1. Output from the diagnostic script above
-2. Full service logs: `sudo journalctl -u ledmatrix-web -n 100 --no-pager`
-3. Output from manual startup attempt
-4. Git status and recent commits
-
-This will help identify the exact issue.
-

docs/archive/WEB_UI_RELIABILITY_IMPROVEMENTS.md

@@ -1,405 +0,0 @@
-# Web UI Reliability Improvements - Implementation Summary
-
-This document summarizes the comprehensive reliability and maintainability improvements implemented for the web UI's plugin and configuration management.
-
-## Overview
-
-The implementation follows a four-phase approach, building foundational reliability infrastructure first, then adding state management, frontend improvements, and finally testing/monitoring capabilities.
-
-## Phase 1: Foundation & Reliability Layer ✅
-
-### 1.1 Atomic Configuration Saves
-
-**Files Created:**
-- `src/config_manager_atomic.py` - Atomic config save manager with backup/rollback
-- Enhanced `src/config_manager.py` - Added atomic save methods
-
-**Features:**
-- Atomic file writes (write to temp → validate → atomic move)
-- Automatic backups before saves (keeps last 5 backups)
-- Rollback functionality to restore from backups
-- Post-write validation with automatic rollback on failure
-- Handles both main config and secrets files atomically
-
-**Usage:**
-```python
-from src.config_manager import ConfigManager
-
-config_manager = ConfigManager()
-
-# Atomic save with backup
-result = config_manager.save_config_atomic(new_config, create_backup=True)
-
-# Rollback to previous version
-config_manager.rollback_config()
-
-# List available backups
-backups = config_manager.list_backups()
-```
-
-### 1.2 Plugin Operation Queue
-
-**Files Created:**
-- `src/plugin_system/operation_types.py` - Operation type definitions
-- `src/plugin_system/operation_queue.py` - Operation queue manager
-
-**Features:**
-- Serializes plugin operations (install, update, uninstall, enable, disable)
-- Prevents concurrent operations on same plugin
-- Operation status/progress tracking
-- Operation cancellation support
-- Operation history persistence
-
-**Usage:**
-```python
-from src.plugin_system.operation_queue import PluginOperationQueue
-from src.plugin_system.operation_types import OperationType
-
-queue = PluginOperationQueue()
-
-# Enqueue operation
-operation_id = queue.enqueue_operation(
-    OperationType.INSTALL,
-    "plugin-id",
-    operation_callback=lambda op: install_plugin(op.plugin_id)
-)
-
-# Check status
-status = queue.get_operation_status(operation_id)
-
-# Cancel operation
-queue.cancel_operation(operation_id)
-```
-
-### 1.3 Structured Error Handling
-
-**Files Created:**
-- `src/web_interface/errors.py` - Error codes and structured error classes
-- `src/web_interface/error_handler.py` - Centralized error handling
-
-**Features:**
-- Error codes and categories (ConfigError, PluginError, ValidationError, etc.)
-- Consistent error response format
-- Error context (operation, plugin_id, config_key, etc.)
-- Suggested fixes in error responses
-- Structured error logging
-
-**Usage:**
-```python
-from src.web_interface.error_handler import handle_errors, create_error_response
-from src.web_interface.errors import ErrorCode
-
-@handle_errors()
-def my_endpoint():
-    # Errors automatically converted to structured format
-    pass
-
-# Manual error response
-return create_error_response(
-    ErrorCode.PLUGIN_NOT_FOUND,
-    "Plugin not found",
-    context={"plugin_id": "test-plugin"}
-)
-```
-
-### 1.4 Health Monitoring
-
-**Files Created:**
-- `src/plugin_system/health_monitor.py` - Enhanced health monitoring
-
-**Features:**
-- Background health checks
-- Health status determination (healthy/degraded/unhealthy)
-- Health metrics aggregation
-- Auto-recovery suggestions based on health status
-
-**Usage:**
-```python
-from src.plugin_system.health_monitor import PluginHealthMonitor
-
-monitor = PluginHealthMonitor(health_tracker)
-monitor.start_monitoring()
-
-# Get health status
-status = monitor.get_plugin_health_status("plugin-id")
-
-# Get comprehensive metrics
-metrics = monitor.get_plugin_health_metrics("plugin-id")
-```
-
-## Phase 2: State Management & Synchronization ✅
-
-### 2.1 Centralized Plugin State Management
-
-**Files Created:**
-- `src/plugin_system/state_manager.py` - Centralized state manager
-
-**Features:**
-- Single source of truth for plugin state
-- State change events/notifications
-- State persistence to disk
-- State versioning for corruption detection
-
-**Usage:**
-```python
-from src.plugin_system.state_manager import PluginStateManager
-
-state_manager = PluginStateManager(state_file="plugin_state.json")
-
-# Update state
-state_manager.update_plugin_state("plugin-id", {
-    "enabled": True,
-    "version": "1.0.0"
-})
-
-# Subscribe to changes
-state_manager.subscribe_to_state_changes(
-    callback=lambda plugin_id, old_state, new_state: print(f"{plugin_id} changed")
-)
-```
-
-### 2.2 State Reconciliation
-
-**Files Created:**
-- `src/plugin_system/state_reconciliation.py` - State reconciliation system
-
-**Features:**
-- Detects inconsistencies between config, manager, disk, and state manager
-- Auto-fixes safe inconsistencies
-- Flags dangerous inconsistencies for manual review
-- Comprehensive reconciliation reports
-
-**Usage:**
-```python
-from src.plugin_system.state_reconciliation import StateReconciliation
-
-reconciler = StateReconciliation(
-    state_manager, config_manager, plugin_manager, plugins_dir
-)
-
-# Run reconciliation
-result = reconciler.reconcile_state()
-
-print(f"Found {len(result.inconsistencies_found)} inconsistencies")
-print(f"Fixed {len(result.inconsistencies_fixed)} automatically")
-```
-
-### 2.3 API Response Standardization
-
-**Files Created:**
-- `src/web_interface/api_helpers.py` - Standardized API response helpers
-
-**Features:**
-- Consistent success/error response format
-- Request validation helpers
-- Response metadata (timing, version, etc.)
-
-**Usage:**
-```python
-from src.web_interface.api_helpers import success_response, error_response, validate_request_json
-
-# Success response
-return success_response(
-    data={"plugins": [...]},
-    message="Plugins loaded successfully"
-)
-
-# Error response
-return error_response(
-    ErrorCode.PLUGIN_NOT_FOUND,
-    "Plugin not found",
-    status_code=404
-)
-
-# Request validation
-data, error = validate_request_json(['plugin_id'])
-if error:
-    return error
-```
-
-## Phase 3: Frontend Refactoring & UX ✅
-
-### 3.1 Modularized JavaScript
-
-**Files Created:**
-- `web_interface/static/v3/js/plugins/api_client.js` - API communication
-- `web_interface/static/v3/js/plugins/store_manager.js` - Plugin store logic
-- `web_interface/static/v3/js/plugins/config_manager.js` - Config form management
-- `web_interface/static/v3/js/plugins/install_manager.js` - Install/update logic
-- `web_interface/static/v3/js/plugins/state_manager.js` - Frontend state management
-- `web_interface/static/v3/js/utils/error_handler.js` - Frontend error handling
-
-**Structure:**
-- Split 4400+ line file into logical modules
-- ES6 module pattern with proper exports
-- Clear module boundaries and responsibilities
-- Shared utilities for common operations
-
-**Usage:**
-```javascript
-// API calls
-const plugins = await PluginAPI.getInstalledPlugins();
-await PluginAPI.togglePlugin("plugin-id", true);
-
-// Store management
-const storePlugins = await PluginStoreManager.loadStore();
-await PluginStoreManager.installPlugin("plugin-id");
-
-// State management
-await PluginStateManager.loadInstalledPlugins();
-PluginStateManager.setPluginEnabled("plugin-id", true);
-
-// Error handling
-errorHandler.displayError(error, "Failed to install plugin");
-```
-
-### 3.2 Improved Error Messages
-
-**Features:**
-- User-friendly error formatting
-- Contextual help and suggestions
-- Copy error details functionality
-- Links to troubleshooting docs
-
-### 3.3 Configuration UI Enhancements
-
-**Features:**
-- Real-time validation feedback
-- Config diff viewer (structure in place)
-- Config export/import (structure in place)
-- Config templates/presets (structure in place)
-
-## Phase 4: Testing & Monitoring ✅
-
-### 4.1 Testing Infrastructure
-
-**Files Created:**
-- `test/web_interface/test_config_manager_atomic.py` - Tests for atomic config saves
-- `test/web_interface/test_plugin_operation_queue.py` - Tests for operation queue
-- `test/web_interface/integration/` - Directory for integration tests
-
-**Coverage:**
-- Unit tests for atomic config saves
-- Unit tests for operation queue
-- Integration test structure
-
-### 4.2 Structured Logging
-
-**Files Created:**
-- `src/web_interface/logging_config.py` - Structured logging configuration
-
-**Features:**
-- JSON-formatted structured logging
-- Plugin operation logging with context
-- Config change logging with before/after values
-- Error context logging
-
-**Usage:**
-```python
-from src.web_interface.logging_config import (
-    setup_structured_logging,
-    log_plugin_operation,
-    log_config_change
-)
-
-# Setup logging
-setup_structured_logging(use_json=True)
-
-# Log operations
-log_plugin_operation(
-    logger,
-    "install",
-    "plugin-id",
-    "success",
-    context={"version": "1.0.0"}
-)
-
-# Log config changes
-log_config_change(
-    logger,
-    "plugin-id",
-    "save",
-    before=old_config,
-    after=new_config
-)
-```
-
-### 4.3 Operation History & Audit Log
-
-**Files Created:**
-- `src/plugin_system/operation_history.py` - Operation history tracker
-
-**Features:**
-- Tracks all plugin operations
-- Tracks all config changes
-- Persistent storage
-- Filtering and querying
-
-**Usage:**
-```python
-from src.plugin_system.operation_history import OperationHistory
-
-history = OperationHistory(history_file="operation_history.json")
-
-# Record operation
-history.record_operation(
-    "install",
-    plugin_id="plugin-id",
-    status="success",
-    user="admin"
-)
-
-# Get history
-records = history.get_history(
-    limit=50,
-    plugin_id="plugin-id"
-)
-```
-
-## Integration Notes
-
-### Backward Compatibility
-
-All changes maintain backward compatibility:
-- Existing API endpoints continue to work
-- Old code can gradually migrate to new infrastructure
-- Feature flags can be added for gradual rollout
-
-### Migration Path
-
-1. **Phase 1** infrastructure is ready to use but not yet integrated into all endpoints
-2. **Phase 2** state management can be integrated incrementally
-3. **Phase 3** frontend modules are available but original file still works
-4. **Phase 4** testing and logging can be enabled gradually
-
-### Next Steps
-
-1. Integrate atomic config saves into existing save endpoints
-2. Integrate operation queue into plugin install/update/uninstall endpoints
-3. Use structured errors in all API endpoints
-4. Integrate state manager with plugin manager
-5. Migrate frontend code to use new modules
-6. Add integration tests for critical flows
-7. Enable structured logging in production
-
-## Benefits
-
-1. **Reliability**: Atomic saves prevent config corruption, operation queue prevents conflicts
-2. **Debuggability**: Structured errors and logging provide clear context
-3. **Maintainability**: Modular code is easier to understand and modify
-4. **Consistency**: Standardized APIs and error handling
-5. **Observability**: Health monitoring and operation history provide visibility
-
-## Testing
-
-Run tests with:
-```bash
-python -m pytest test/web_interface/
-```
-
-## Documentation
-
-- See individual module docstrings for detailed API documentation
-- Error codes are documented in `src/web_interface/errors.py`
-- Operation types are documented in `src/plugin_system/operation_types.py`
-

docs/archive/WIFI_ETHERNET_AP_MODE_FIX.md

@@ -1,194 +0,0 @@
-# WiFi Monitor Ethernet Check Fix
-
-## Problem
-
-The WiFi monitor service was enabling Access Point (AP) mode whenever WiFi was disconnected, even when the Raspberry Pi was connected via Ethernet. This caused:
-
-- AP mode to activate unnecessarily when Ethernet was available
-- Potential network conflicts
-- Confusion for users with hardwired connections
-
-## Solution
-
-Updated the WiFi manager to check for Ethernet connectivity before enabling AP mode. AP mode will now only be enabled when:
-
-- **WiFi is NOT connected** AND
-- **Ethernet is NOT connected**
-
-## Changes Made
-
-### 1. Added Ethernet Detection Method
-
-Added `_is_ethernet_connected()` method to `src/wifi_manager.py` that:
-- Checks for active Ethernet interfaces (eth0, enp*, etc.)
-- Verifies the interface has an IP address
-- Uses `nmcli` if available, falls back to `ip` command
-- Returns `True` if Ethernet is connected and has an IP
-
-### 2. Updated AP Mode Enable Logic
-
-Modified `enable_ap_mode()` to:
-- Check for Ethernet connection before enabling AP mode
-- Return an error message if Ethernet is connected: "Cannot enable AP mode while Ethernet is connected"
-
-### 3. Updated AP Mode Management Logic
-
-Modified `check_and_manage_ap_mode()` to:
-- Check both WiFi and Ethernet status
-- Only enable AP mode if both are disconnected
-- Disable AP mode if either WiFi or Ethernet connects
-- Log appropriate messages for each scenario
-
-### 4. Enhanced Logging
-
-Updated `wifi_monitor_daemon.py` to:
-- Log Ethernet connection status
-- Include Ethernet status in state change detection
-- Log when AP mode is disabled due to Ethernet connection
-
-## Testing
-
-### Verify Ethernet Detection
-
-```bash
-# Check if Ethernet is detected
-python3 -c "
-from src.wifi_manager import WiFiManager
-wm = WiFiManager()
-print('Ethernet connected:', wm._is_ethernet_connected())
-"
-```
-
-### Test AP Mode Behavior
-
-1. **With Ethernet connected**:
-   ```bash
-   # AP mode should NOT enable
-   sudo systemctl restart ledmatrix-wifi-monitor
-   sudo journalctl -u ledmatrix-wifi-monitor -f
-   # Should see: "Cannot enable AP mode while Ethernet is connected"
-   ```
-
-2. **With Ethernet disconnected and WiFi disconnected**:
-   ```bash
-   # Disconnect Ethernet cable
-   # AP mode SHOULD enable
-   sudo journalctl -u ledmatrix-wifi-monitor -f
-   # Should see: "Auto-enabled AP mode (no WiFi or Ethernet connection)"
-   ```
-
-3. **With Ethernet connected and WiFi connects**:
-   ```bash
-   # Connect WiFi
-   # AP mode should disable if it was active
-   sudo journalctl -u ledmatrix-wifi-monitor -f
-   # Should see: "Auto-disabled AP mode (WiFi connected)"
-   ```
-
-4. **With Ethernet connects while AP is active**:
-   ```bash
-   # Connect Ethernet cable while AP mode is active
-   # AP mode should disable
-   sudo journalctl -u ledmatrix-wifi-monitor -f
-   # Should see: "Auto-disabled AP mode (Ethernet connected)"
-   ```
-
-## Deployment
-
-### On Existing Installations
-
-1. **Restart the WiFi monitor service**:
-   ```bash
-   sudo systemctl restart ledmatrix-wifi-monitor
-   ```
-
-2. **If AP mode is currently active and Ethernet is connected**, it will automatically disable:
-   ```bash
-   # Check current status
-   sudo systemctl status hostapd
-   
-   # The service should automatically disable AP mode within 30 seconds
-   # Or manually disable:
-   sudo systemctl stop hostapd dnsmasq
-   ```
-
-3. **Verify the fix**:
-   ```bash
-   # Check logs
-   sudo journalctl -u ledmatrix-wifi-monitor -n 20
-   
-   # Should see messages about Ethernet connection status
-   ```
-
-### On New Installations
-
-The fix is included automatically - no additional steps needed.
-
-## Behavior Summary
-
-| WiFi Status | Ethernet Status | AP Mode | Reason |
-|------------|----------------|---------|--------|
-| Connected | Connected | ❌ Disabled | Both connections available |
-| Connected | Disconnected | ❌ Disabled | WiFi available |
-| Disconnected | Connected | ❌ Disabled | Ethernet available |
-| Disconnected | Disconnected | ✅ Enabled | No network connection |
-
-## Troubleshooting
-
-### AP Mode Still Enables with Ethernet Connected
-
-1. **Check Ethernet detection**:
-   ```bash
-   python3 -c "
-   from src.wifi_manager import WiFiManager
-   wm = WiFiManager()
-   print('Ethernet connected:', wm._is_ethernet_connected())
-   "
-   ```
-
-2. **Check network interface status**:
-   ```bash
-   nmcli device status
-   # OR
-   ip addr show
-   ```
-
-3. **Verify Ethernet has IP address**:
-   ```bash
-   ip addr show eth0
-   # Should show an "inet" address (not just 127.0.0.1)
-   ```
-
-### Ethernet Not Detected
-
-If Ethernet is connected but not detected:
-
-1. **Check interface name**:
-   ```bash
-   ip link show
-   # Look for Ethernet interfaces (may be eth0, enp*, etc.)
-   ```
-
-2. **Check NetworkManager status**:
-   ```bash
-   sudo systemctl status NetworkManager
-   ```
-
-3. **Manually check interface**:
-   ```bash
-   nmcli device status | grep ethernet
-   ```
-
-## Related Files
-
-- `src/wifi_manager.py` - Main WiFi management logic
-- `scripts/utils/wifi_monitor_daemon.py` - Background daemon that monitors WiFi/Ethernet
-- `scripts/install/install_wifi_monitor.sh` - Installation script for WiFi monitor service
-
-## Notes
-
-- The Ethernet check uses `nmcli` if available (preferred), otherwise falls back to `ip` command
-- The check verifies that the interface has an actual IP address (not just link up)
-- AP mode will automatically disable within 30 seconds (check interval) when Ethernet connects
-- Manual AP mode enable via web interface will also respect Ethernet connection status
-

docs/archive/WIFI_SETUP.md

@@ -1,368 +0,0 @@
-# WiFi Setup Feature
-
-The LED Matrix project includes a WiFi setup feature that allows you to configure WiFi connections through a web interface. When the Raspberry Pi is not connected to WiFi, it automatically broadcasts an access point (AP) that you can connect to for initial setup.
-
-## Features
-
-- **Automatic AP Mode**: When no WiFi connection is detected, the Raspberry Pi automatically creates a WiFi access point named "LEDMatrix-Setup"
-- **Web Interface**: Access the WiFi setup interface through your web browser
-- **Network Scanning**: Scan for available WiFi networks from the web interface
-- **Secure Connection**: Save WiFi credentials securely
-- **Automatic Management**: The WiFi monitor daemon automatically enables/disables AP mode based on connection status
-
-## Requirements
-
-The following packages are required for WiFi setup functionality:
-
-- **hostapd**: Access point software
-- **dnsmasq**: DHCP server for AP mode
-- **NetworkManager** (or **iwlist**): WiFi management tools
-
-These packages are automatically checked and can be installed during the WiFi monitor service installation.
-
-## Installation
-
-### 1. Install WiFi Monitor Service
-
-Run the installation script to set up the WiFi monitor daemon:
-
-```bash
-cd /home/ledpi/LEDMatrix
-sudo ./scripts/install/install_wifi_monitor.sh
-```
-
-This script will:
-- Check for required packages and offer to install them
-- Create the systemd service file
-- Enable and start the WiFi monitor service
-- Configure the service to start on boot
-
-### 2. Verify Service Status
-
-Check that the WiFi monitor service is running:
-
-```bash
-sudo systemctl status ledmatrix-wifi-monitor
-```
-
-You should see output indicating the service is active and running.
-
-## Usage
-
-### Accessing the WiFi Setup Interface
-
-1. **If WiFi is NOT connected**: The Raspberry Pi will automatically create an access point (after a 90-second grace period)
-   - Connect to the WiFi network: **LEDMatrix-Setup** (open network, no password required)
-   - Open a web browser and navigate to: `http://192.168.4.1:5000` or `http://192.168.4.1` (captive portal may redirect)
-   - Or use the IP address shown in the web interface
-
-2. **If WiFi IS connected**: Access the web interface normally
-   - Navigate to: `http://<raspberry-pi-ip>:5000`
-   - Click on the **WiFi** tab in the navigation
-
-### Connecting to a WiFi Network
-
-1. Navigate to the **WiFi** tab in the web interface
-2. Click **Scan** to search for available networks
-3. Select a network from the dropdown menu, or enter the SSID manually
-4. Enter the WiFi password (leave empty for open networks)
-5. Click **Connect**
-6. The system will attempt to connect to the selected network
-7. Once connected, AP mode will automatically disable
-
-### Manual AP Mode Control
-
-You can manually enable or disable AP mode from the web interface:
-
-- **Enable AP Mode**: Click "Enable AP Mode" button (only available when WiFi is not connected)
-- **Disable AP Mode**: Click "Disable AP Mode" button (only available when AP mode is active)
-
-## How It Works
-
-### WiFi Monitor Daemon
-
-The WiFi monitor daemon (`wifi_monitor_daemon.py`) runs as a background service that:
-
-1. Checks WiFi connection status every 30 seconds (configurable)
-2. Automatically enables AP mode only if:
-   - `auto_enable_ap_mode` is enabled in config AND
-   - No WiFi connection is detected AND
-   - No Ethernet connection is detected
-3. Automatically disables AP mode when WiFi or Ethernet connection is established
-4. Logs all state changes for troubleshooting
-
-**Note**: By default, `auto_enable_ap_mode` is `true`, meaning AP mode will automatically activate when both WiFi and Ethernet are disconnected. However, there's a 90-second grace period (3 consecutive checks at 30-second intervals) to prevent AP mode from enabling on transient network hiccups. This ensures you can always configure the device even when it has no network connection.
-
-### WiFi Manager Module
-
-The WiFi manager (`src/wifi_manager.py`) provides:
-
-- **Connection Status**: Checks current WiFi connection state
-- **Network Scanning**: Scans for available WiFi networks
-- **Connection Management**: Connects to WiFi networks and saves credentials
-- **AP Mode Control**: Manages access point mode (hostapd/dnsmasq)
-
-### Configuration
-
-WiFi settings are stored in `config/wifi_config.json`:
-
-```json
-{
-  "ap_ssid": "LEDMatrix-Setup",
-  "ap_password": "ledmatrix123",
-  "ap_channel": 7,
-  "auto_enable_ap_mode": true,
-  "saved_networks": [
-    {
-      "ssid": "MyNetwork",
-      "password": "mypassword",
-      "saved_at": 1234567890.0
-    }
-  ]
-}
-```
-
-**Configuration Options:**
-- `ap_ssid`: SSID for the access point (default: "LEDMatrix-Setup")
-- `ap_channel`: WiFi channel for AP mode (default: 7)
-- `auto_enable_ap_mode`: Automatically enable AP mode when WiFi/Ethernet disconnect (default: `true`)
-  - When `true`: AP mode automatically enables after a 90-second grace period when both WiFi and Ethernet are disconnected
-  - When `false`: AP mode must be manually enabled through the web interface
-- `saved_networks`: List of saved WiFi network credentials
-
-**Note**: The access point is configured as an open network (no password required) for ease of initial setup. This allows any device to connect without credentials.
-
-### Access Point Configuration
-
-The AP mode uses `hostapd` and `dnsmasq` for access point functionality:
-
-- **SSID**: LEDMatrix-Setup (configurable)
-- **IP Range**: 192.168.4.2 - 192.168.4.20
-- **Gateway**: 192.168.4.1
-- **Channel**: 7 (configurable)
-
-## Verification
-
-### Running the WiFi Verification Script
-
-Use the comprehensive verification script to check your WiFi setup:
-
-```bash
-cd /home/ledpi/LEDMatrix
-./scripts/verify_wifi_setup.sh
-```
-
-This script checks:
-- Required packages are installed
-- WiFi monitor service is running
-- Configuration files are valid
-- WiFi permissions are configured
-- WiFi interface is available
-- WiFi radio status
-- Current connection status
-- AP mode status
-- WiFi Manager module availability
-- Web interface API accessibility
-
-The script provides a summary with passed/warning/failed checks to help diagnose issues.
-
-## Troubleshooting
-
-### WiFi Monitor Service Not Starting
-
-Check the service logs:
-
-```bash
-sudo journalctl -u ledmatrix-wifi-monitor -n 50
-```
-
-Common issues:
-- Missing packages (hostapd, dnsmasq)
-- Permission issues
-- Network interface not available
-
-### Cannot Access AP Mode
-
-1. Check if AP mode is active:
-   ```bash
-   sudo systemctl status hostapd
-   ```
-
-2. Check if dnsmasq is running:
-   ```bash
-   sudo systemctl status dnsmasq
-   ```
-
-3. Verify WiFi interface exists:
-   ```bash
-   ip link show wlan0
-   ```
-
-### Cannot Connect to WiFi Network
-
-1. Verify the SSID and password are correct
-2. Check if the network requires a password (some networks may appear open but require a password)
-3. Check WiFi monitor logs for connection errors:
-   ```bash
-   sudo journalctl -u ledmatrix-wifi-monitor -f
-   ```
-
-4. Check NetworkManager logs:
-   ```bash
-   sudo journalctl -u NetworkManager -n 50
-   ```
-
-### AP Mode Not Disabling
-
-If AP mode doesn't disable after connecting to WiFi:
-
-1. Check WiFi connection status:
-   ```bash
-   nmcli device status
-   ```
-
-2. Manually disable AP mode from the web interface
-3. Restart the WiFi monitor service:
-   ```bash
-   sudo systemctl restart ledmatrix-wifi-monitor
-   ```
-
-## Service Management
-
-### Useful Commands
-
-```bash
-# Check service status
-sudo systemctl status ledmatrix-wifi-monitor
-
-# Start the service
-sudo systemctl start ledmatrix-wifi-monitor
-
-# Stop the service
-sudo systemctl stop ledmatrix-wifi-monitor
-
-# Restart the service
-sudo systemctl restart ledmatrix-wifi-monitor
-
-# View logs
-sudo journalctl -u ledmatrix-wifi-monitor -f
-
-# Disable service from starting on boot
-sudo systemctl disable ledmatrix-wifi-monitor
-
-# Enable service to start on boot
-sudo systemctl enable ledmatrix-wifi-monitor
-```
-
-### Configuration Options
-
-You can modify the check interval by editing the service file:
-
-```bash
-sudo systemctl edit ledmatrix-wifi-monitor
-```
-
-Or modify the service file directly:
-
-```bash
-sudo nano /etc/systemd/system/ledmatrix-wifi-monitor.service
-```
-
-Change the `--interval` parameter in the `ExecStart` line (default is 30 seconds).
-
-After modifying, reload and restart:
-
-```bash
-sudo systemctl daemon-reload
-sudo systemctl restart ledmatrix-wifi-monitor
-```
-
-## Security Considerations
-
-- **Open AP Network**: The access point is configured as an open network (no password) for ease of initial setup. This allows any device within range to connect to the setup network. Consider your deployment environment when using this feature.
-- **WiFi Credentials**: Saved WiFi credentials are stored in `config/wifi_config.json`. Ensure proper file permissions:
-  ```bash
-  sudo chmod 600 config/wifi_config.json
-  ```
-- **Network Access**: When in AP mode, anyone within range can connect to the setup network. This is by design to allow easy initial configuration. For production deployments in secure environments, consider using the web interface when connected to WiFi instead.
-
-## API Endpoints
-
-The WiFi setup feature exposes the following API endpoints:
-
-- `GET /api/v3/wifi/status` - Get current WiFi connection status
-- `GET /api/v3/wifi/scan` - Scan for available WiFi networks
-- `POST /api/v3/wifi/connect` - Connect to a WiFi network
-- `POST /api/v3/wifi/ap/enable` - Enable access point mode
-- `POST /api/v3/wifi/ap/disable` - Disable access point mode
-
-## Technical Details
-
-### WiFi Detection Methods
-
-The WiFi manager tries multiple methods to detect WiFi status:
-
-1. **NetworkManager (nmcli)** - Preferred method if available
-2. **iwconfig** - Fallback method for systems without NetworkManager
-
-### Network Scanning
-
-The system supports multiple scanning methods:
-
-1. **nmcli** - Fast, preferred method
-2. **iwlist** - Fallback method for older systems
-
-### Access Point Setup
-
-AP mode configuration:
-
-- Uses `hostapd` (preferred) or `nmcli hotspot` (fallback) for WiFi access point functionality
-- Uses `dnsmasq` for DHCP and DNS services (hostapd mode only)
-- Configures wlan0 interface in AP mode
-- Provides DHCP range: 192.168.4.2-20
-- Gateway IP: 192.168.4.1
-- **Open network**: No password required (configures as open network for easy setup)
-- Captive portal: DNS redirection for automatic browser redirects (hostapd mode only)
-
-## Development
-
-### Testing WiFi Manager
-
-You can test the WiFi manager directly:
-
-```python
-from src.wifi_manager import WiFiManager
-
-# Create WiFi manager instance
-wifi_manager = WiFiManager()
-
-# Get status
-status = wifi_manager.get_wifi_status()
-print(f"Connected: {status.connected}, SSID: {status.ssid}")
-
-# Scan networks
-networks = wifi_manager.scan_networks()
-for net in networks:
-    print(f"{net.ssid}: {net.signal}% ({net.security})")
-
-# Connect to network
-success, message = wifi_manager.connect_to_network("MyNetwork", "password")
-print(f"Connection: {success}, Message: {message}")
-```
-
-### Running Monitor Daemon Manually
-
-For testing, you can run the daemon in foreground mode:
-
-```bash
-sudo python3 wifi_monitor_daemon.py --interval 10 --foreground
-```
-
-## Support
-
-For issues or questions:
-1. Check the logs: `sudo journalctl -u ledmatrix-wifi-monitor -f`
-2. Review this documentation
-3. Check the main project README for general troubleshooting
-4. Open an issue on GitHub if needed
-

docs/audits/WEB_UI_AUDIT_2026-09.md

@@ -0,0 +1,164 @@
+# Web UI Technical Audit — September 2026
+
+Scope: `web_interface/` (Flask + HTMX + Alpine, `templates/v3/`, `static/v3/`).
+Method: Impeccable design detector, code review (accessibility; performance,
+theming, responsive), and a live pass on the running app at desktop and
+375px mobile widths in light and dark themes. Severe claims were verified
+against the live page; one was rejected (see below). No code was changed.
+
+Product context: see [`PRODUCT.md`](../../PRODUCT.md).
+
+## Health score: 8/20 (Poor)
+
+| # | Dimension | Score | Key finding |
+|---|-----------|-------|-------------|
+| 1 | Accessibility | 2 | Focus rings never render; modals have no dialog semantics or focus management |
+| 2 | Performance | 2 | ~1.2 MB JS (≈250 KB gzip) on every page; SSE streams and polling never pause |
+| 3 | Responsive | 2 | Mobile drawer works; header title wraps to 3 lines; many ~24px touch targets |
+| 4 | Theming | 1 | Tokens exist but hex dominates; dark mode is a class-by-class patch with leaks |
+| 5 | Implementation integrity | 1 | Templates use Tailwind classes that don't exist in the stylesheet |
+
+## Implementation integrity verdict: fail
+
+There is no Tailwind build. `static/v3/app.css` is a hand-written subset of
+Tailwind, while templates and JS are authored as if full Tailwind were loaded.
+
+- **333 of 516 utility class names used have no CSS rule** (2,582 uses),
+  confirmed against the live stylesheets. Top offenders: `border` (250),
+  `text-gray-700` (183), `block` (148), `mr-1` (127), `hidden` (79),
+  `py-1`, `text-blue-600`, `px-2`, `text-center`, `hover:bg-blue-700`,
+  `divide-y`, `uppercase`, `font-mono`.
+- **`.hidden` has never existed in `app.css`**, so the 145
+  `classList.add/remove/toggle('hidden')` calls across 26 files do nothing.
+  Visible proof: the header shows both the moon and sun theme icons.
+- **15 classes are defined only under `[data-theme="dark"]`** (e.g.
+  `bg-blue-50`, `bg-red-50`, `bg-yellow-50`, `border-blue-200`,
+  `text-red-700`), so tinted notice boxes are unstyled in light mode.
+- Visible damage: the Getting Started checklist (`partials/overview.html:96-117`)
+  renders native gray outset buttons in both themes; 32 visible buttons on
+  the Plugin Manager page render with default browser chrome; search icons
+  overlap inputs; error/diff modal backdrops are transparent
+  (`bg-gray-500 bg-opacity-75` undefined).
+
+Other drift:
+- Four competing `showNotification` definitions (`app.js:6`,
+  `app-shell.js:2464`, `widgets/notification.js:298`, `partials/fonts.html:249`)
+  — the winner depends on load order — plus 53 `alert()`/`confirm()` calls.
+- At least four modal implementations (on-demand modal in `base.html:1032`,
+  Tailwind-UI style in `error_handler.js`/`diff_viewer.js`, `.jfm-*`/`.pfm-*`
+  with injected CSS, ad-hoc modals in `plugins_manager.js`).
+- `.btn` mixed with ~90 hand-assembled color-utility button combos.
+- SSE wiring duplicated in `app-shell.js:5-60` and `app.js:186-205`.
+
+## Findings by severity
+
+### P0
+
+**Undefined utility layer** (above). Every show/hide toggle and every layout
+built from missing classes silently fails; root cause of most visual bugs.
+Fix: replace the hand-rolled subset with a real, purged Tailwind build
+(with dark-mode variants), or at minimum define the high-use missing classes
+(`hidden`, `border`, `block`, spacing/text utilities) and a button reset.
+→ `/impeccable harden`
+
+### P1
+
+- **Focus rings never render.** `focus:ring-2` (`app.css:289-291`) references
+  `--tw-ring-inset` and `--tw-ring-offset-width`, which are never defined, so
+  the `box-shadow` is invalid. `focus:outline-none` (18 uses) does remove the
+  outline. `peer-focus:ring-4` has no rule, so the plugin enable toggle
+  (`plugins_manager.js:1586-1593`, `sr-only` checkbox) shows no focus.
+  WCAG 2.4.7.
+- **Modals lack dialog semantics.** Only `json-file-manager.js` has
+  `role="dialog"`/`aria-modal`/Escape/initial focus; none trap focus or
+  return it. On-demand (`base.html:1032`), error (`error_handler.js:164-205`),
+  diff (`diff_viewer.js:211-214`), plugin file manager
+  (`plugin-file-manager.js:372-392, 576-599`), array-table editor
+  (`array-table.js:460-467`) have none of it. WCAG 2.1.2 / 4.1.2.
+- **Unnamed controls.** ~16 icon-only buttons with no accessible name, e.g.
+  `base.html:1036`, `plugins.html:173,210`, `plugin_config.html:485,656`,
+  `number-input.js:102,129`, `text-input.js:120`, `date-picker.js:95`,
+  `time-picker.js:100`, `password-input.js:141`. ~115 of 245 form fields have
+  no label (hotspots: `plugin_config.html` 19, `starlark_config.html` 14,
+  `plugins.html` 11); confirmed live on the 11 store search/sort/filter inputs.
+- **Captive WiFi setup page** (first-run surface): `#msg` status has no live
+  region, and `outline:none` is replaced by a 15%-alpha shadow
+  (`captive_setup.html:16,48`).
+- **Background traffic never stops.** `/stream/stats` and `/stream/display`
+  SSE stay open on every tab (display frames push with no preview visible).
+  Tab timers keep running after leaving the tab (`display.html:1046` 5s,
+  `logs.html:222` 5s, `tools.html:987` 15s, `plugins_manager.js:1882` 15s,
+  update check `base.html:1196` 30min). Only `tools.html:999` checks
+  `visibilitychange`. Costly on a Pi Zero 2 W.
+- **Page weight.** 47 script tags on every page, including all 33 widgets
+  (`base.html:984-1018`). `app-shell.js` (177 KB) is render-blocking
+  (`base.html:956`); `plugins_manager.js` is 277 KB.
+- **Dark mode leaks.** `plugin-file-manager.js` (53 hex) and
+  `json-file-manager.js` (63 hex, e.g. `.jfm-modal-box{background:#fff}`)
+  inject CSS that ignores `data-theme`; `.form-control` hard-codes
+  `#fff`/`#111827` (`app.css:668-671`). `app.css` has 186 hex + 46 rgb
+  literals vs 94 `var(--…)` uses.
+
+### P2
+
+- Toasts: `role="alert"` inside an `aria-live="polite"` container
+  (`notification.js:78,156`) → double/assertive announcements; auto-dismiss 4s.
+- `prefers-reduced-motion` covers 3 animations; ~106 `animate-pulse`/`fa-spin`
+  uses, `modalSlideIn`, and toast slides ignore it.
+- Mobile: header title wraps to three lines and spills out of the header;
+  ~33 plugin-card buttons are `text-xs px-2 py-1` (~24px); `#logs-container`
+  forced to 400/350px with `!important` (`app.css:399-411`).
+- Logs panel contrast: `text-gray-400` on `bg-gray-900` ≈ 3.9:1
+  (`logs.html:75,86`).
+- Three unnamed nested `<nav>` landmarks (`base.html:474,477,548`); no skip link.
+- Plugin lists fully rebuilt via `innerHTML` on every filter change
+  (`plugins_manager.js:1554, 3784, 3993, 4389, 5905`); `logs.html:225` adds a
+  reflow-forcing resize listener on every partial load.
+
+### P3
+
+- No `loading="lazy"` on images; Font Awesome `font-display:block`.
+- Unpinned `alpinejs@3.x.x` unpkg fallback (`base.html:241`).
+- `widgets/example-color-picker.js` is not loaded anywhere.
+- Detector: 3px accent stripe on `.plugin-card::before` (`app.css:721`).
+
+## Verified and rejected
+
+- **"Static assets are never cache-busted" (raised as P0): false.**
+  `app.py:491` (`@app.url_defaults add_static_version`) appends file mtime as
+  `?v=` to every static URL; the live HTML confirms it. The manual
+  `?v=20260307` on two script tags is merely redundant.
+- Light-mode gray text contrast is mostly fine: `app.css` remaps grays darker
+  (4.8–10:1).
+- Detector `gray-on-color` hits at `app.css:84,285` and `broken-image` hits
+  (JS-populated `src`) are not real rendered issues.
+
+## What works
+
+- Theme set before first paint, follows OS preference, `data-theme` + tokens.
+- Mobile drawer: Escape closes it, focus returns to the hamburger, 44px rows.
+- `aria-current="page"` on nav tabs; real `<header>` and `<main>`.
+- Status colors always paired with text; nearly all images have alt text.
+- `toggle-switch.js` uses `role="switch"`; vendor assets self-hosted.
+
+## Open decisions (block the P0 fix approach)
+
+Recorded as undecided in `PRODUCT.md`:
+- Must the UI work fully offline (no CDN fallbacks)?
+- Is a Node/CSS build step acceptable for contributors?
+- Is WCAG 2.2 AA a formal requirement?
+
+## Recommended order
+
+1. **[P0] `/impeccable harden`** — fix the utility layer (real Tailwind build
+   or define missing classes + button reset).
+2. **[P1] `/impeccable harden`** — focus-ring variables and `peer-focus`;
+   one shared accessible modal helper; name icon buttons and label fields;
+   live region on the captive page.
+3. **[P1] `/impeccable optimize`** — pause SSE/timers on hidden tab or page;
+   load widget scripts on demand.
+4. **[P1] `/impeccable colorize`** — move file-manager CSS and `.form-control`
+   onto theme tokens.
+5. **[P2] `/impeccable adapt`** — header wrap, touch targets, log height.
+6. **[P2] `/impeccable animate`** — reduced-motion alternatives.
+7. **`/impeccable polish`** — final pass.

docs/plugin-safety-harness.md

@@ -10,7 +10,8 @@ plugin without breaking a size or screen you didn't think to test.
 There is **no fixed set of supported panel sizes** — an RGB matrix build can be
 any width/height and configuration (square, rectangle, 2×2, 4×4, 8×2, long
 strips, tall stacks). Plugins are expected to read dimensions dynamically
-(`self.display_manager.matrix.width/height`) and lay themselves out
+(`self.display_manager.width/height` — not `matrix.width/height`, since
+`matrix` is `None` when hardware init fails) and lay themselves out
 accordingly, so a hardcoded coordinate or unscaled font shows up as a failure
 here.
 

docs/plugin_registry_template.json

@@ -1,7 +1,6 @@
 {
   "version": "1.0.0",
-  "last_updated": "2025-01-09T12:00:00Z",
-  "description": "Official plugin registry for LEDMatrix",
+  "last_updated": "2026-09-03",
   "plugins": [
     {
       "id": "hello-world",
@@ -10,86 +9,32 @@
       "author": "ChuckBuilds",
       "category": "example",
       "tags": ["example", "tutorial", "beginner"],
-      "repo": "https://github.com/ChuckBuilds/LEDMatrix",
+      "repo": "https://github.com/ChuckBuilds/ledmatrix-plugins",
       "branch": "main",
-      "path": "plugins/hello-world",
-      "versions": [
-        {
-          "version": "1.0.0",
-          "ledmatrix_min_version": "2.0.0",
-          "released": "2025-01-09",
-          "download_url": "https://github.com/ChuckBuilds/LEDMatrix/archive/refs/heads/main.zip",
-          "changelog": "Initial release"
-        }
-      ],
+      "plugin_path": "plugins/hello-world",
       "stars": 0,
       "downloads": 0,
-      "last_updated": "2025-01-09",
+      "last_updated": "2026-09-03",
       "verified": true,
-      "documentation": "https://github.com/ChuckBuilds/LEDMatrix/blob/main/plugins/hello-world/README.md"
+      "screenshot": "",
+      "latest_version": "1.0.0"
     },
     {
-      "id": "clock-simple",
-      "name": "Simple Clock",
-      "description": "A clean, simple clock display with date and time",
-      "author": "ChuckBuilds",
-      "category": "time",
-      "tags": ["clock", "time", "date"],
-      "repo": "https://github.com/ChuckBuilds/LEDMatrix",
+      "id": "my-third-party-plugin",
+      "name": "My Third-Party Plugin",
+      "description": "A plugin kept in its own repository (empty plugin_path)",
+      "author": "YourName",
+      "category": "custom",
+      "tags": ["example"],
+      "repo": "https://github.com/YourName/ledmatrix-my-third-party-plugin",
       "branch": "main",
-      "path": "plugins/clock-simple",
-      "versions": [
-        {
-          "version": "1.0.0",
-          "ledmatrix_min_version": "2.0.0",
-          "released": "2025-01-09",
-          "download_url": "https://github.com/ChuckBuilds/LEDMatrix/archive/refs/heads/main.zip",
-          "changelog": "Initial release"
-        }
-      ],
+      "plugin_path": "",
       "stars": 0,
       "downloads": 0,
-      "last_updated": "2025-01-09",
-      "verified": true,
-      "documentation": "https://github.com/ChuckBuilds/LEDMatrix/blob/main/plugins/clock-simple/README.md"
-    }
-  ],
-  "categories": [
-    {
-      "id": "time",
-      "name": "Time & Clocks",
-      "description": "Clock displays, timers, and time-related plugins"
-    },
-    {
-      "id": "sports",
-      "name": "Sports",
-      "description": "Scoreboards, schedules, and sports statistics"
-    },
-    {
-      "id": "weather",
-      "name": "Weather",
-      "description": "Weather forecasts and conditions"
-    },
-    {
-      "id": "finance",
-      "name": "Finance",
-      "description": "Stock tickers, crypto, and market data"
-    },
-    {
-      "id": "entertainment",
-      "name": "Entertainment",
-      "description": "Games, animations, and media displays"
-    },
-    {
-      "id": "example",
-      "name": "Examples & Tutorials",
-      "description": "Example plugins for learning"
-    },
-    {
-      "id": "custom",
-      "name": "Custom",
-      "description": "Unique and miscellaneous displays"
+      "last_updated": "2026-09-03",
+      "verified": false,
+      "screenshot": "",
+      "latest_version": "1.0.0"
     }
   ]
 }
-

docs/widget-guide.md

@@ -281,11 +281,49 @@ Guidelines:
   their own collapsible sections) and is safely ignored by older cores, so
   adding it never breaks compatibility.
 
+## Hiding Fields From the Form (`x-display: "hidden"`)
+
+Add `"x-display": "hidden"` to a property that must stay in the schema but
+should not appear as a control: a deprecated key kept so existing configs keep
+validating, or an internal value such as an auto-generated row id.
+
+```json
+{
+  "properties": {
+    "radar_zoom": {
+      "type": "integer",
+      "default": 6,
+      "title": "Radar Zoom Level (deprecated)",
+      "x-display": "hidden"
+    }
+  }
+}
+```
+
+What the core does with it:
+
+- **Not rendered** at any depth: top-level fields, children of an object
+  section, and properties of array-of-object items (never a table column, even
+  if `x-columns` names it, and never in the row editor). A hidden field flagged
+  `x-advanced` is not listed or counted in Advanced Settings, and an object
+  whose children are all hidden draws no empty section. Hidden fields don't
+  show up in the settings search either, since it indexes the rendered form.
+- **Stored value preserved on save.** Saving the form never changes a hidden
+  value. The unchecked-checkbox rule ignores a hidden boolean. Array rows carry
+  a hidden property's stored value through the form, so the value survives the
+  row being posted back; a new row gets no value (the plugin fills it in).
+- **The API is unaffected.** A JSON save to `POST /api/v3/plugins/config` can
+  still set a hidden field.
+
+Older cores ignore the flag and render the field as a normal control.
+
 ## Creating Custom Widgets
 
 ### Step 1: Create Widget File
 
-Create a JavaScript file in your plugin directory. The recommended location is `widgets/[widget-name].js`:
+Create a JavaScript file in your plugin's `widgets/` directory, named
+`widgets/[widget-name].js`. The directory is not optional: it is the only
+place the core will serve a widget from.
 
 ```javascript
 // Ensure LEDMatrixWidgets registry is available
@@ -366,7 +404,29 @@ window.LEDMatrixWidgets.register('my-custom-widget', {
 });
 ```
 
-### Step 2: Reference Widget in Schema
+### Step 2: Declare the Widget in `manifest.json`
+
+The manifest is the allowlist. A widget is served only if the plugin declares
+it, so shipping a file under `widgets/` does not by itself publish it:
+
+```json
+{
+  "widgets": [
+    {
+      "name": "my-custom-widget",
+      "script": "my-custom-widget.js",
+      "description": "What this widget is for"
+    }
+  ]
+}
+```
+
+`name` is what you use in `x-widget` and in the URL. `script` is optional and
+defaults to `[name].js`; it must be a plain filename directly inside
+`widgets/` (no paths). Both are validated against
+`schema/manifest_schema.json`.
+
+### Step 3: Reference Widget in Schema
 
 In your plugin's `config_schema.json`:
 
@@ -383,15 +443,30 @@ In your plugin's `config_schema.json`:
 }
 ```
 
-### Step 3: Widget Loading
+### Step 4: Widget Loading
 
-The widget will be automatically loaded when the plugin configuration form is rendered. The system will:
+The widget is loaded on demand when the plugin's configuration form renders a
+field that references it. The system will:
 
-1. Check if widget is registered in the core registry
-2. If not found, attempt to load from plugin directory: `/static/plugin-widgets/[plugin-id]/[widget-name].js`
-3. Render the widget using the registered `render` function
+1. Check whether the widget is already registered in the core registry.
+2. If not, fetch it from `/static/plugin-widgets/[plugin-id]/[widget-name].js`.
+   That route serves the declared `script` from your plugin's `widgets/`
+   directory, as `text/javascript`.
+3. Render it by calling the `render` function your script registered.
 
-**Note:** Currently, widgets are server-side rendered via Jinja2 templates. Custom widgets registered via the registry will have their handlers available, but full client-side rendering is a future enhancement.
+The fetch uses a dynamic `import()`, so the file must parse as an ES module.
+A plain IIFE does — modules are strict mode, so avoid sloppy-mode constructs.
+
+**If the widget fails to load** (not declared, file missing, script throws, or
+it never calls `register`), the field falls back to a plain text input holding
+the current value. This is deliberate: a broken widget costs the user an
+editor, not their configured value.
+
+**Limitation:** the on-demand path applies to `string`-typed fields (the
+default branch of the config-form renderer). Fields typed `object`, `array`,
+`boolean`, `integer` or `number`, and fields whose `enum` is set, are
+dispatched by the server-side template to its own built-in renderers, so a
+plugin-supplied `x-widget` on one of those is ignored today.
 
 ## Widget API Reference
 
@@ -497,10 +572,11 @@ See [`web_interface/static/v3/js/widgets/example-color-picker.js`](../web_interf
 - ✅ Plugin widget loading system implemented
 
 **Current Behavior:**
-- Widgets are server-side rendered via Jinja2 templates (existing behavior preserved)
+- Core widgets are server-side rendered via Jinja2 templates (existing behavior preserved)
 - Widget handlers are registered and available globally
-- Custom widgets can be created and registered
-- Full client-side rendering is a future enhancement
+- Custom widgets can be created, declared in `manifest.json`, and are served
+  and rendered on demand for `string`-typed fields
+- Plugin widgets on non-string fields are not dispatched yet (see Step 4)
 
 **Backwards Compatibility:**
 - All existing plugins using widgets continue to work without changes

first_time_install.sh

@@ -125,6 +125,72 @@ fi
 # Get the home directory of the actual user
 USER_HOME=$(eval echo ~$ACTUAL_USER)
 
+# --- rpi-rgb-led-matrix checkout helpers -------------------------------------
+# Run git as whoever owns the project directory. Run as root against a
+# user-owned repo, git refuses it ("dubious ownership"), and anything it does
+# create — such as .git/modules/<submodule> — ends up root-owned, locking the
+# user out of their own checkout. A root-owned install keeps running as root.
+_rgb_repo_owner() {
+    stat -c %U "$PROJECT_ROOT_DIR" 2>/dev/null || echo root
+}
+
+_git_as_repo_owner() {
+    local owner
+    owner=$(_rgb_repo_owner)
+    if [ "$(id -u)" = "0" ] && [ "$owner" != "root" ] && command -v sudo >/dev/null 2>&1; then
+        sudo -u "$owner" -H git "$@"
+    else
+        git "$@"
+    fi
+}
+
+# Earlier installer versions ran the submodule git commands as root, leaving
+# root-owned files the repo owner (and so _git_as_repo_owner) cannot write.
+_reclaim_rgb_checkout() {
+    local owner path
+    owner=$(_rgb_repo_owner)
+    if [ "$(id -u)" != "0" ] || [ "$owner" = "root" ]; then
+        return 0
+    fi
+    for path in "$PROJECT_ROOT_DIR/rpi-rgb-led-matrix-master" "$PROJECT_ROOT_DIR/.git/modules/rpi-rgb-led-matrix-master"; do
+        if [ -e "$path" ]; then
+            chown -R "$owner:" "$path" 2>/dev/null || true
+        fi
+    done
+}
+
+# `git pull` on the main repo never moves an existing submodule checkout, so a
+# submodule bump (e.g. the ARMv6 build fix for Pi Zero/1) would never reach a
+# device installed before it. Move the checkout forward to the pinned commit —
+# but never backward or sideways: a user who ran `git submodule update --remote`
+# is newer than the pin and is left alone. Never fatal.
+_sync_rgb_submodule() {
+    local sub="$PROJECT_ROOT_DIR/rpi-rgb-led-matrix-master" pinned current
+    if [ ! -f "$PROJECT_ROOT_DIR/.gitmodules" ] || ! grep -q "rpi-rgb-led-matrix" "$PROJECT_ROOT_DIR/.gitmodules" \
+        || [ ! -e "$sub/.git" ]; then
+        return 0
+    fi
+    if ! pinned=$(_git_as_repo_owner -C "$PROJECT_ROOT_DIR" rev-parse "HEAD:rpi-rgb-led-matrix-master" 2>/dev/null) \
+        || [ -z "$pinned" ]; then
+        return 0
+    fi
+    current=$(_git_as_repo_owner -C "$sub" rev-parse HEAD 2>/dev/null) || current=""
+    if [ "$current" = "$pinned" ]; then
+        return 0
+    fi
+    if [ -n "$current" ] && _git_as_repo_owner -C "$sub" cat-file -e "${pinned}^{commit}" 2>/dev/null \
+        && ! _git_as_repo_owner -C "$sub" merge-base --is-ancestor "$current" "$pinned" 2>/dev/null; then
+        echo "rpi-rgb-led-matrix-master is at ${current:0:7}, not behind the pinned ${pinned:0:7}; leaving it as is"
+        return 0
+    fi
+    echo "Updating rpi-rgb-led-matrix-master to the pinned commit ${pinned:0:7}..."
+    if ! _git_as_repo_owner -C "$PROJECT_ROOT_DIR" submodule update --init --recursive rpi-rgb-led-matrix-master; then
+        echo "⚠ Could not update rpi-rgb-led-matrix-master to the pinned commit; building the existing checkout"
+    fi
+    return 0
+}
+# --- end rpi-rgb-led-matrix checkout helpers ---------------------------------
+
 # Determine the Project Root Directory (where this script is located)
 PROJECT_ROOT_DIR=$(cd "$(dirname "$0")" && pwd)
 
@@ -154,6 +220,8 @@ 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:-}
+# Weekly automatic updates: 1 on, 0 off, empty = ask (interactive) or leave as is.
+AUTO_UPDATE=${LEDMATRIX_AUTO_UPDATE:-}
 
 usage() {
     cat <<USAGE
@@ -168,12 +236,15 @@ Options:
       --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)
+      --enable-auto-update  Turn on weekly automatic updates (with health
+                            check and automatic rollback)
+      --no-auto-update      Leave weekly automatic updates off
   -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
+  LEDMATRIX_SKIP_SWAP=1, LEDMATRIX_BUILD_JOBS=N, LEDMATRIX_AUTO_UPDATE=1|0
 
 Low-memory devices:
   On a Pi with under 2GB of RAM the C++ build is limited to fewer parallel
@@ -191,6 +262,8 @@ while [ $# -gt 0 ]; do
         --skip-perf) SKIP_PERF=1 ;;
         --no-reboot-prompt) SKIP_REBOOT_PROMPT=1 ;;
         --skip-swap) SKIP_SWAP=1 ;;
+        --enable-auto-update) AUTO_UPDATE=1 ;;
+        --no-auto-update) AUTO_UPDATE=0 ;;
         --build-jobs)
             shift
             if [ $# -eq 0 ]; then echo "--build-jobs requires a number"; usage; exit 1; fi
@@ -429,6 +502,41 @@ print_rgbmatrix_build_failure() {
     fi
 }
 
+# Set WEB_SERVICE_USER to the account ledmatrix-web.service runs as, or "root"
+# when it cannot tell. Steps 3.1 and 11 choose plugin-directory ownership from
+# it. The logic was pasted three times, identically, and is kept verbatim here.
+# Note: install_web_service.sh and install_service.sh no longer contain the
+# "User=root" / "User=${ACTUAL_USER}" strings grepped for below (the units come
+# from systemd/*.service templates with User=__USER__), so until Step 8 has
+# installed the unit this yields "root".
+detect_web_service_user() {
+    WEB_SERVICE_USER="root"
+    if [ -f "/etc/systemd/system/ledmatrix-web.service" ]; then
+        # Check actual installed service file (most accurate)
+        WEB_SERVICE_USER=$(grep "^User=" /etc/systemd/system/ledmatrix-web.service | cut -d'=' -f2 || echo "root")
+    elif [ -f "$PROJECT_ROOT_DIR/scripts/install/install_web_service.sh" ]; then
+        # Check install_web_service.sh (used by first_time_install.sh)
+        if grep -q "User=root" "$PROJECT_ROOT_DIR/scripts/install/install_web_service.sh"; then
+            WEB_SERVICE_USER="root"
+        elif grep -q "User=\${ACTUAL_USER}" "$PROJECT_ROOT_DIR/scripts/install/install_web_service.sh"; then
+            WEB_SERVICE_USER="$ACTUAL_USER"
+        fi
+    elif [ -f "$PROJECT_ROOT_DIR/systemd/ledmatrix-web.service" ]; then
+        # Check template file (may have placeholder)
+        WEB_SERVICE_USER=$(grep "^User=" "$PROJECT_ROOT_DIR/systemd/ledmatrix-web.service" | cut -d'=' -f2 || echo "root")
+        # If template has placeholder, check install script
+        if [ "$WEB_SERVICE_USER" = "__USER__" ] || [ -z "$WEB_SERVICE_USER" ]; then
+            # Check install_service.sh to see what user it uses
+            if [ -f "$PROJECT_ROOT_DIR/scripts/install/install_service.sh" ] && grep -q "User=\${ACTUAL_USER}" "$PROJECT_ROOT_DIR/scripts/install/install_service.sh"; then
+                WEB_SERVICE_USER="$ACTUAL_USER"
+            fi
+        fi
+    elif [ -f "$PROJECT_ROOT_DIR/scripts/install/install_service.sh" ] && grep -q "User=\${ACTUAL_USER}" "$PROJECT_ROOT_DIR/scripts/install/install_service.sh"; then
+        # Web service will be installed by install_service.sh as ACTUAL_USER
+        WEB_SERVICE_USER="$ACTUAL_USER"
+    fi
+}
+
 echo ""
 echo "This script will perform the following steps:"
 echo "1. Check prerequisites (network, disk, memory) and install system dependencies"
@@ -626,32 +734,7 @@ else
     fi
     
     # Determine ownership based on web service user
-    # Check if web service file exists and what user it runs as
-    WEB_SERVICE_USER="root"
-    if [ -f "/etc/systemd/system/ledmatrix-web.service" ]; then
-        # Check actual installed service file (most accurate)
-        WEB_SERVICE_USER=$(grep "^User=" /etc/systemd/system/ledmatrix-web.service | cut -d'=' -f2 || echo "root")
-    elif [ -f "$PROJECT_ROOT_DIR/scripts/install/install_web_service.sh" ]; then
-        # Check install_web_service.sh (used by first_time_install.sh)
-        if grep -q "User=root" "$PROJECT_ROOT_DIR/scripts/install/install_web_service.sh"; then
-            WEB_SERVICE_USER="root"
-        elif grep -q "User=\${ACTUAL_USER}" "$PROJECT_ROOT_DIR/scripts/install/install_web_service.sh"; then
-            WEB_SERVICE_USER="$ACTUAL_USER"
-        fi
-    elif [ -f "$PROJECT_ROOT_DIR/systemd/ledmatrix-web.service" ]; then
-        # Check template file (may have placeholder)
-        WEB_SERVICE_USER=$(grep "^User=" "$PROJECT_ROOT_DIR/systemd/ledmatrix-web.service" | cut -d'=' -f2 || echo "root")
-        # If template has placeholder, check install script
-        if [ "$WEB_SERVICE_USER" = "__USER__" ] || [ -z "$WEB_SERVICE_USER" ]; then
-            # Check install_service.sh to see what user it uses
-            if [ -f "$PROJECT_ROOT_DIR/scripts/install/install_service.sh" ] && grep -q "User=\${ACTUAL_USER}" "$PROJECT_ROOT_DIR/scripts/install/install_service.sh"; then
-                WEB_SERVICE_USER="$ACTUAL_USER"
-            fi
-        fi
-    elif [ -f "$PROJECT_ROOT_DIR/scripts/install/install_service.sh" ] && grep -q "User=\${ACTUAL_USER}" "$PROJECT_ROOT_DIR/scripts/install/install_service.sh"; then
-        # Web service will be installed by install_service.sh as ACTUAL_USER
-        WEB_SERVICE_USER="$ACTUAL_USER"
-    fi
+    detect_web_service_user
     
     # If web service runs as ACTUAL_USER (not root), set ownership to ACTUAL_USER
     # so the web service can change permissions. Root service can still access via group (775).
@@ -685,32 +768,7 @@ if [ ! -d "$PLUGIN_REPOS_DIR" ]; then
 fi
 
 # Determine ownership based on web service user
-# Check if web service file exists and what user it runs as
-WEB_SERVICE_USER="root"
-if [ -f "/etc/systemd/system/ledmatrix-web.service" ]; then
-    # Check actual installed service file (most accurate)
-    WEB_SERVICE_USER=$(grep "^User=" /etc/systemd/system/ledmatrix-web.service | cut -d'=' -f2 || echo "root")
-elif [ -f "$PROJECT_ROOT_DIR/scripts/install/install_web_service.sh" ]; then
-    # Check install_web_service.sh (used by first_time_install.sh)
-    if grep -q "User=root" "$PROJECT_ROOT_DIR/scripts/install/install_web_service.sh"; then
-        WEB_SERVICE_USER="root"
-    elif grep -q "User=\${ACTUAL_USER}" "$PROJECT_ROOT_DIR/scripts/install/install_web_service.sh"; then
-        WEB_SERVICE_USER="$ACTUAL_USER"
-    fi
-elif [ -f "$PROJECT_ROOT_DIR/systemd/ledmatrix-web.service" ]; then
-    # Check template file (may have placeholder)
-    WEB_SERVICE_USER=$(grep "^User=" "$PROJECT_ROOT_DIR/systemd/ledmatrix-web.service" | cut -d'=' -f2 || echo "root")
-    # If template has placeholder, check install script
-    if [ "$WEB_SERVICE_USER" = "__USER__" ] || [ -z "$WEB_SERVICE_USER" ]; then
-        # Check install_service.sh to see what user it uses
-        if [ -f "$PROJECT_ROOT_DIR/scripts/install/install_service.sh" ] && grep -q "User=\${ACTUAL_USER}" "$PROJECT_ROOT_DIR/scripts/install/install_service.sh"; then
-            WEB_SERVICE_USER="$ACTUAL_USER"
-        fi
-    fi
-elif [ -f "$PROJECT_ROOT_DIR/scripts/install/install_service.sh" ] && grep -q "User=\${ACTUAL_USER}" "$PROJECT_ROOT_DIR/scripts/install/install_service.sh"; then
-    # Web service will be installed by install_service.sh as ACTUAL_USER
-    WEB_SERVICE_USER="$ACTUAL_USER"
-fi
+detect_web_service_user
 
 # If web service runs as ACTUAL_USER (not root), set ownership to ACTUAL_USER
 # so the web service can change permissions. Root service can still access via group (775).
@@ -797,6 +855,50 @@ else
     echo "✓ Main config file already exists"
 fi
 
+# Weekly automatic updates (General tab -> Automatic Updates). Off unless asked
+# for: --enable-auto-update / LEDMATRIX_AUTO_UPDATE=1, or "y" at the prompt when
+# installing interactively. Only an explicit choice changes the setting, so
+# re-running the installer with -y never switches it silently.
+if [ -z "$AUTO_UPDATE" ] && [ "$ASSUME_YES" != "1" ] && [ -t 0 ]; then
+    read -p "Automatically check for and install LEDMatrix updates once a week, with automatic rollback if an update breaks something? (y/N): " -n 1 -r
+    echo
+    if [[ $REPLY =~ ^[Yy]$ ]]; then AUTO_UPDATE=1; else AUTO_UPDATE=0; fi
+fi
+if [ "$AUTO_UPDATE" = "1" ] || [ "$AUTO_UPDATE" = "0" ]; then
+    if python3 - "$PROJECT_ROOT_DIR/config/config.json" "$AUTO_UPDATE" <<'PY'
+import json, os, sys, tempfile
+path, enabled = sys.argv[1], sys.argv[2] == "1"
+with open(path, encoding="utf-8") as f:
+    config = json.load(f)
+if not isinstance(config.get("auto_update"), dict):
+    config["auto_update"] = {}
+config["auto_update"]["enabled"] = enabled
+# Written beside the original and swapped in whole: the display service's
+# config watcher may be running and must never read a half-written file.
+original = os.stat(path)
+fd, tmp = tempfile.mkstemp(dir=os.path.dirname(os.path.abspath(path)), prefix=".config.")
+try:
+    with os.fdopen(fd, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=4)
+        f.write("\n")
+        f.flush()
+        os.fsync(f.fileno())
+    os.chmod(tmp, original.st_mode & 0o777)
+    if hasattr(os, "chown"):
+        os.chown(tmp, original.st_uid, original.st_gid)
+    os.replace(tmp, path)
+except BaseException:
+    if os.path.exists(tmp):
+        os.unlink(tmp)
+    raise
+PY
+    then
+        if [ "$AUTO_UPDATE" = "1" ]; then echo "✓ Weekly automatic updates enabled"; else echo "✓ Weekly automatic updates off"; fi
+    else
+        echo "⚠ Could not set auto_update in config/config.json; turn it on from the General tab instead"
+    fi
+fi
+
 # Create config_secrets.json from template if missing
 if [ ! -f "$PROJECT_ROOT_DIR/config/config_secrets.json" ]; then
     if [ -f "$PROJECT_ROOT_DIR/config/config_secrets.template.json" ]; then
@@ -1038,8 +1140,9 @@ else
     # so git clone doesn't fail with "destination path already exists".
     _clone_rpi_rgb() {
         rm -rf "$PROJECT_ROOT_DIR/rpi-rgb-led-matrix-master"
-        git clone https://github.com/hzeller/rpi-rgb-led-matrix.git rpi-rgb-led-matrix-master
+        _git_as_repo_owner clone https://github.com/hzeller/rpi-rgb-led-matrix.git rpi-rgb-led-matrix-master
     }
+    _reclaim_rgb_checkout
     if [ ! -d "$PROJECT_ROOT_DIR/rpi-rgb-led-matrix-master" ]; then
         echo "rpi-rgb-led-matrix-master not found. Initializing git submodule..."
         cd "$PROJECT_ROOT_DIR"
@@ -1047,7 +1150,7 @@ else
         # Try to initialize submodule if .gitmodules exists
         if [ -f "$PROJECT_ROOT_DIR/.gitmodules" ] && grep -q "rpi-rgb-led-matrix" "$PROJECT_ROOT_DIR/.gitmodules"; then
             echo "Initializing rpi-rgb-led-matrix submodule..."
-            if ! retry git submodule update --init --recursive rpi-rgb-led-matrix-master; then
+            if ! retry _git_as_repo_owner submodule update --init --recursive rpi-rgb-led-matrix-master; then
                 echo "⚠ Submodule init failed, cloning directly from GitHub..."
                 retry _clone_rpi_rgb
             fi
@@ -1066,12 +1169,14 @@ else
             cd "$PROJECT_ROOT_DIR"
             rm -rf rpi-rgb-led-matrix-master
             if [ -f "$PROJECT_ROOT_DIR/.gitmodules" ] && grep -q "rpi-rgb-led-matrix" "$PROJECT_ROOT_DIR/.gitmodules"; then
-                retry git submodule update --init --recursive rpi-rgb-led-matrix-master
+                retry _git_as_repo_owner submodule update --init --recursive rpi-rgb-led-matrix-master
             else
                 retry _clone_rpi_rgb
             fi
         fi
 
+        _sync_rgb_submodule
+
         # 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
@@ -1272,7 +1377,7 @@ if [ -f "$PROJECT_ROOT_DIR/scripts/install/install_web_service.sh" ]; then
         fi
     fi
     
-    if [ ! -f "/etc/systemd/system/ledmatrix-web.service" ] || [ "$NEEDS_UPDATE" = true ]; then
+    if [ ! -f "/etc/systemd/system/ledmatrix-web.service" ] || [ ! -f "/etc/systemd/system/ledmatrix-update-verify.path" ] || [ "$NEEDS_UPDATE" = true ]; then
         bash "$PROJECT_ROOT_DIR/scripts/install/install_web_service.sh"
         # Ensure systemd sees any new/changed unit files
         systemctl daemon-reload || true
@@ -1288,7 +1393,7 @@ echo ""
 CURRENT_STEP="Harden systemd unit file permissions"
 echo "Step 8.1: Setting systemd unit file permissions..."
 echo "-----------------------------------------------"
-for unit in "/etc/systemd/system/ledmatrix.service" "/etc/systemd/system/ledmatrix-web.service" "/etc/systemd/system/ledmatrix-wifi-monitor.service"; do
+for unit in "/etc/systemd/system/ledmatrix.service" "/etc/systemd/system/ledmatrix-web.service" "/etc/systemd/system/ledmatrix-wifi-monitor.service" "/etc/systemd/system/ledmatrix-update-verify.service" "/etc/systemd/system/ledmatrix-update-verify.path"; do
     if [ -f "$unit" ]; then
         chown root:root "$unit" || true
         chmod 644 "$unit" || true
@@ -1384,6 +1489,9 @@ echo "------------------------------------------------"
 # Create sudoers configuration for the web interface
 echo "Creating sudoers configuration..."
 SUDOERS_FILE="/etc/sudoers.d/ledmatrix_web"
+# A predictable name in a world-writable directory is a symlink target;
+# root writes the rules here, so let mktemp pick the name.
+SUDOERS_TMP=$(mktemp "${TMPDIR:-/tmp}/ledmatrix_web_sudoers.XXXXXX")
 
 # Get command paths
 PYTHON_PATH=$(which python3)
@@ -1393,56 +1501,57 @@ POWEROFF_PATH=$(which poweroff)
 BASH_PATH=$(which bash)
 JOURNALCTL_PATH=$(which journalctl 2>/dev/null || true)
 
-# Create sudoers content
-cat > /tmp/ledmatrix_web_sudoers << EOF
-# LED Matrix Web Interface passwordless sudo configuration
-# This allows the web interface user to run specific commands without a password
-
-# Allow $ACTUAL_USER to run specific commands without a password for the LED Matrix web interface
-$ACTUAL_USER ALL=(ALL) NOPASSWD: $REBOOT_PATH
-$ACTUAL_USER ALL=(ALL) NOPASSWD: $POWEROFF_PATH
-$ACTUAL_USER ALL=(ALL) NOPASSWD: $SYSTEMCTL_PATH start ledmatrix.service
-$ACTUAL_USER ALL=(ALL) NOPASSWD: $SYSTEMCTL_PATH stop ledmatrix.service
-$ACTUAL_USER ALL=(ALL) NOPASSWD: $SYSTEMCTL_PATH restart ledmatrix.service
-$ACTUAL_USER ALL=(ALL) NOPASSWD: $SYSTEMCTL_PATH enable ledmatrix.service
-$ACTUAL_USER ALL=(ALL) NOPASSWD: $SYSTEMCTL_PATH disable ledmatrix.service
-$ACTUAL_USER ALL=(ALL) NOPASSWD: $SYSTEMCTL_PATH status ledmatrix.service
-$ACTUAL_USER ALL=(ALL) NOPASSWD: $SYSTEMCTL_PATH is-active ledmatrix
-$ACTUAL_USER ALL=(ALL) NOPASSWD: $SYSTEMCTL_PATH is-active ledmatrix.service
-$ACTUAL_USER ALL=(ALL) NOPASSWD: $SYSTEMCTL_PATH start ledmatrix-web.service
-$ACTUAL_USER ALL=(ALL) NOPASSWD: $SYSTEMCTL_PATH stop ledmatrix-web.service
-$ACTUAL_USER ALL=(ALL) NOPASSWD: $SYSTEMCTL_PATH restart ledmatrix-web.service
-$ACTUAL_USER ALL=(ALL) NOPASSWD: $PYTHON_PATH $PROJECT_ROOT_DIR/display_controller.py
-$ACTUAL_USER ALL=(ALL) NOPASSWD: $BASH_PATH $PROJECT_ROOT_DIR/start_display.sh
-$ACTUAL_USER ALL=(ALL) NOPASSWD: $BASH_PATH $PROJECT_ROOT_DIR/stop_display.sh
-$ACTUAL_USER ALL=(ALL) NOPASSWD: $BASH_PATH $PROJECT_ROOT_DIR/scripts/fix_perms/safe_plugin_rm.sh *
-EOF
-if [ -n "$JOURNALCTL_PATH" ]; then
-    cat >> /tmp/ledmatrix_web_sudoers << EOF
-# NOEXEC, because these rules end in a wildcard and journalctl starts a pager
-# when its output is a terminal. From that pager (less) a "!sh" is a root
-# shell -- the standard journalctl escalation. The web interface always passes
-# --no-pager, so nothing here needs it, but the rule cannot require a flag that
-# sits in the middle of the command line. NOEXEC stops the command executing
-# another program at all, which closes the hole without depending on wildcard
-# matching subtleties.
-$ACTUAL_USER ALL=(ALL) NOPASSWD:NOEXEC: $JOURNALCTL_PATH -u ledmatrix.service *
-$ACTUAL_USER ALL=(ALL) NOPASSWD:NOEXEC: $JOURNALCTL_PATH -u ledmatrix *
-$ACTUAL_USER ALL=(ALL) NOPASSWD:NOEXEC: $JOURNALCTL_PATH -t ledmatrix *
-EOF
+# The rules themselves live in scripts/install/lib_sudoers.sh, shared with
+# scripts/install/configure_web_sudo.sh so the two cannot drift apart again.
+# If it is missing (a damaged checkout), keep whatever is already installed
+# rather than failing the whole install; the gate below skips the install.
+SUDOERS_VALID=1
+SUDOERS_LIB="$PROJECT_ROOT_DIR/scripts/install/lib_sudoers.sh"
+if [ -f "$SUDOERS_LIB" ]; then
+    # shellcheck source=scripts/install/lib_sudoers.sh
+    . "$SUDOERS_LIB"
+    web_sudoers_rules "$ACTUAL_USER" "$PROJECT_ROOT_DIR" "$SYSTEMCTL_PATH" "$BASH_PATH" \
+        "$REBOOT_PATH" "$POWEROFF_PATH" "$JOURNALCTL_PATH" > "$SUDOERS_TMP"
+else
+    SUDOERS_VALID=0
+    echo "⚠ $SUDOERS_LIB not found; cannot generate the sudoers rules." >&2
+    echo "⚠ Leaving $SUDOERS_FILE unchanged. The web interface cannot control" >&2
+    echo "  the display service until this is fixed." >&2
 fi
 
-if [ -f "$SUDOERS_FILE" ] && cmp -s /tmp/ledmatrix_web_sudoers "$SUDOERS_FILE"; then
+# Never install rules we have not parsed. A malformed drop-in in
+# /etc/sudoers.d makes sudo refuse every command for every user, which on a
+# headless Pi leaves no way in at all. If the rules do not parse, say so and
+# keep whatever is already installed.
+if [ "$SUDOERS_VALID" = "0" ]; then
+    :  # nothing was generated; already reported above
+elif command -v visudo >/dev/null 2>&1; then
+    if ! visudo -c -f "$SUDOERS_TMP" >/dev/null 2>&1; then
+        SUDOERS_VALID=0
+        echo "⚠ The generated sudoers rules did not parse:" >&2
+        visudo -c -f "$SUDOERS_TMP" >&2 || true
+        echo "⚠ Leaving $SUDOERS_FILE unchanged. The web interface cannot control" >&2
+        echo "  the display service until this is fixed." >&2
+    fi
+else
+    echo "⚠ visudo not found; installing the sudoers rules unvalidated"
+fi
+
+if [ "$SUDOERS_VALID" = "0" ]; then
+    rm -f "$SUDOERS_TMP"
+elif [ -f "$SUDOERS_FILE" ] && cmp -s "$SUDOERS_TMP" "$SUDOERS_FILE"; then
     echo "Sudoers configuration already up to date"
-    rm /tmp/ledmatrix_web_sudoers
+    rm -f "$SUDOERS_TMP"
 else
     echo "Installing/updating sudoers configuration..."
-    cp /tmp/ledmatrix_web_sudoers "$SUDOERS_FILE"
+    cp "$SUDOERS_TMP" "$SUDOERS_FILE"
     chmod 440 "$SUDOERS_FILE"
-    rm /tmp/ledmatrix_web_sudoers
+    rm -f "$SUDOERS_TMP"
 fi
 
-echo "✓ Passwordless sudo access configured"
+if [ "$SUDOERS_VALID" = "1" ]; then
+    echo "✓ Passwordless sudo access configured"
+fi
 echo ""
 
 CURRENT_STEP="Configure WiFi management permissions"
@@ -1546,28 +1655,8 @@ fi
 
 # Re-apply plugin directory permissions based on web service user
 echo "Re-applying plugin directory permissions..."
-# Determine web service user (check installed service, install scripts, or template)
-WEB_SERVICE_USER="root"
-if [ -f "/etc/systemd/system/ledmatrix-web.service" ]; then
-    # Check actual installed service file (most accurate)
-    WEB_SERVICE_USER=$(grep "^User=" /etc/systemd/system/ledmatrix-web.service | cut -d'=' -f2 || echo "root")
-elif [ -f "$PROJECT_ROOT_DIR/scripts/install/install_web_service.sh" ]; then
-    # Check install_web_service.sh (used by first_time_install.sh)
-    if grep -q "User=root" "$PROJECT_ROOT_DIR/scripts/install/install_web_service.sh"; then
-        WEB_SERVICE_USER="root"
-    elif grep -q "User=\${ACTUAL_USER}" "$PROJECT_ROOT_DIR/scripts/install/install_web_service.sh"; then
-        WEB_SERVICE_USER="$ACTUAL_USER"
-    fi
-elif [ -f "$PROJECT_ROOT_DIR/systemd/ledmatrix-web.service" ]; then
-    WEB_SERVICE_USER=$(grep "^User=" "$PROJECT_ROOT_DIR/systemd/ledmatrix-web.service" | cut -d'=' -f2 || echo "root")
-    if [ "$WEB_SERVICE_USER" = "__USER__" ] || [ -z "$WEB_SERVICE_USER" ]; then
-        if [ -f "$PROJECT_ROOT_DIR/scripts/install/install_service.sh" ] && grep -q "User=\${ACTUAL_USER}" "$PROJECT_ROOT_DIR/scripts/install/install_service.sh"; then
-            WEB_SERVICE_USER="$ACTUAL_USER"
-        fi
-    fi
-elif [ -f "$PROJECT_ROOT_DIR/scripts/install/install_service.sh" ] && grep -q "User=\${ACTUAL_USER}" "$PROJECT_ROOT_DIR/scripts/install/install_service.sh"; then
-    WEB_SERVICE_USER="$ACTUAL_USER"
-fi
+# Determine ownership based on web service user
+detect_web_service_user
 
 # Set ownership based on web service user
 if [ "$WEB_SERVICE_USER" = "$ACTUAL_USER" ] || [ "$WEB_SERVICE_USER" != "root" ]; then
@@ -1623,6 +1712,19 @@ chmod 755 "$PROJECT_ROOT_DIR/scripts/install/install_service.sh" "$PROJECT_ROOT_
 # Re-apply special permissions for config directory (lost during normalization)
 chmod 2775 "$PROJECT_ROOT_DIR/config" || true
 
+# Harden the sudo-granted helper scripts: root-owned, not writable by the web
+# user (matches scripts/install/configure_web_sudo.sh). The sudoers rules in
+# Step 10 run these as root, so a user-owned copy is a root shell for whoever
+# can edit it. This must come after Step 11's project-wide chown to
+# $ACTUAL_USER, which would otherwise hand them straight back.
+for helper in safe_plugin_rm.sh safe_pip_install.sh; do
+    HELPER_PATH="$PROJECT_ROOT_DIR/scripts/fix_perms/$helper"
+    if [ -f "$HELPER_PATH" ]; then
+        chown root:root "$HELPER_PATH" || echo "⚠ Could not set ownership on $HELPER_PATH"
+        chmod 755 "$HELPER_PATH" || echo "⚠ Could not set permissions on $HELPER_PATH"
+    fi
+done
+
 echo "✓ Project file permissions normalized"
 echo ""
 

integrations/mqtt_bridge/.gitignore

@@ -0,0 +1 @@
+bridge_config.json

integrations/mqtt_bridge/README.md

@@ -0,0 +1,123 @@
+# Home Assistant MQTT Bridge
+
+Control the matrix from Home Assistant: force any plugin or mode on demand,
+turn the display on and off, and set brightness — as real HA entities, not
+hand-written `mqtt.publish` calls.
+
+The bridge owns no display logic. It subscribes to one command topic and
+turns each message into a call against the same `api_v3` routes the web UI
+uses, so behaviour lives in one place. It talks to the API over HTTP only —
+no filesystem access — so it can run on the Pi or anywhere that can reach
+the web interface.
+
+## What appears in Home Assistant
+
+On connect the bridge publishes [MQTT Discovery](https://www.home-assistant.io/integrations/mqtt/#mqtt-discovery)
+config, so the matrix shows up under **Settings → Devices & Services → MQTT**
+with no YAML:
+
+| Entity | Does |
+|---|---|
+| `select.ledmatrix_display_mode` | Every mode across enabled plugins. Choosing one force-displays it. |
+| `button.ledmatrix_stop_display` | Back to normal rotation. |
+| `switch.ledmatrix_power` | Starts/stops the display service. |
+| `number.ledmatrix_brightness` | 0–100. |
+
+State is read back from the API every 30 seconds, so the entities also track
+changes made from the web UI or an on-demand window expiring on its own.
+All four share an availability topic that is the bridge's MQTT last will:
+if the bridge dies, HA greys the controls out rather than leaving them
+looking live but inert.
+
+## Raw commands
+
+For anything the entities do not cover, publish JSON to the command topic
+(`ledmatrix/command` by default):
+
+```jsonc
+// Force a mode. plugin_id is optional — the bridge fills it in from
+// /api/v3/display/modes.
+{"action": "display", "mode": "nfl_live"}
+
+// duration is seconds; pinned holds this one mode instead of rotating
+// through every mode the plugin owns. Pin Starlark apps, where each mode
+// is an unrelated widget; leave a sports plugin unpinned so live/recent/
+// upcoming still cycle.
+{"action": "display", "plugin_id": "starlark-apps", "mode": "aquarium",
+ "duration": 300, "pinned": true}
+
+{"action": "stop_display"}
+{"action": "power", "state": "on"}
+{"action": "brightness", "value": 75}
+
+// Re-read the mode list and re-publish discovery, after installing a plugin
+{"action": "refresh"}
+```
+
+Every command publishes its outcome to `<command_topic>/status`, and current
+state to `<command_topic>/state`.
+
+## Requirements
+
+- A LEDMatrix install with its web interface reachable (default `http://localhost:5000`)
+- An MQTT broker that Home Assistant is also connected to
+- Python 3 with `paho-mqtt` 2.x and `requests`
+
+## Install
+
+```bash
+sudo ./scripts/install/install_mqtt_bridge.sh
+```
+
+That copies `bridge_config.example.json` to `bridge_config.json` on first
+run, installs the dependencies, and enables `ledmatrix-mqtt-bridge.service`.
+Edit the config with your broker details and re-run it.
+
+```json
+{
+  "mqtt_host": "192.168.1.10",
+  "mqtt_port": 8883,
+  "mqtt_username": "ledmatrix",
+  "mqtt_password": null,
+  "mqtt_topic": "ledmatrix/command",
+  "mqtt_tls": true,
+  "ledmatrix_api_base": "http://localhost:5000"
+}
+```
+
+**TLS is on by default.** Without it the broker password and every display
+command cross the network in cleartext. If your broker only listens on plain
+1883 — which the Mosquitto add-on does out of the box — set `"mqtt_tls": false`
+and `"mqtt_port": 1883`. The bridge logs a warning at startup when a password
+is configured without TLS.
+
+`bridge_config.json` is gitignored. Any key can also be supplied through the
+environment as `LEDMATRIX_MQTT_<KEY>` (`LEDMATRIX_MQTT_MQTT_PASSWORD`, say),
+which keeps a broker password out of a file on disk — put it in a systemd
+drop-in with `Environment=` or `EnvironmentFile=` instead.
+
+Set `mqtt_tls: true` for a broker with TLS. `mqtt_tls_insecure` skips
+certificate verification and exists only for a self-signed broker on a
+trusted LAN; it logs a warning when used.
+
+To run it in the foreground while setting things up:
+
+```bash
+python3 integrations/mqtt_bridge/ledmatrix_mqtt_bridge.py --config integrations/mqtt_bridge/bridge_config.json
+```
+
+## Notes
+
+- Only one thing can be on-demand at a time — the same constraint the web UI has.
+- Forcing a mode restarts the display service, so the panel blanks for a moment.
+- The mode list comes from `/api/v3/display/modes`, which triggers plugin
+  discovery itself. Discovery is lazy and normally happens because somebody
+  opened the dashboard; without that endpoint a bridge that never does would
+  see an empty list.
+- Brightness writes `display.hardware.brightness` by posting
+  `{"brightness": N}` to `/api/v3/config/main`. A JSON save changes only the
+  keys it sends, so the other display settings are left as they were. The
+  display service's config hot reload notices the change within a few seconds
+  and applies it without a restart (unless `LEDMATRIX_HOT_RELOAD=false`; while
+  a dim schedule is dimming the panel, the dim level wins until the dim period
+  ends).

integrations/mqtt_bridge/bridge_config.example.json

@@ -0,0 +1,13 @@
+{
+  "mqtt_host": "192.168.1.10",
+  "mqtt_port": 8883,
+  "mqtt_username": "ledmatrix",
+  "mqtt_password": null,
+  "mqtt_client_id": "ledmatrix-mqtt-bridge",
+  "mqtt_topic": "ledmatrix/command",
+  "mqtt_tls": true,
+  "ledmatrix_api_base": "http://localhost:5000",
+  "request_timeout": 15,
+  "on_demand_duration": null,
+  "log_level": "INFO"
+}

integrations/mqtt_bridge/ledmatrix_mqtt_bridge.py

@@ -0,0 +1,548 @@
+#!/usr/bin/env python3
+"""Control a LEDMatrix display from Home Assistant over MQTT.
+
+The bridge owns no display logic. It subscribes to one command topic and
+turns each message into a call against the same api_v3 routes the web UI
+uses, so behaviour stays in one place and this stays a translation layer.
+
+On connect it publishes Home Assistant MQTT Discovery config, so a matrix
+appears in HA as real entities rather than something you drive with
+`mqtt.publish` by hand:
+
+    select.ledmatrix_display_mode   every mode across enabled plugins;
+                                    choosing one force-displays it
+    button.ledmatrix_stop_display   back to normal rotation
+    switch.ledmatrix_power          the display service, on or off
+    number.ledmatrix_brightness     0-100
+
+Anything the entities do not cover is still reachable by publishing JSON
+to the command topic:
+
+    {"action": "display", "mode": "nfl_live"}
+    {"action": "display", "plugin_id": "starlark-apps", "mode": "aquarium",
+     "duration": 300, "pinned": true}
+    {"action": "stop_display"}
+    {"action": "power", "state": "on" | "off"}
+    {"action": "brightness", "value": 75}
+    {"action": "refresh"}          re-publish discovery after installing a plugin
+
+Every command publishes its result to <command_topic>/status.
+
+Run it with `python3 ledmatrix_mqtt_bridge.py [--config PATH]`, or install
+ledmatrix-mqtt-bridge.service.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import signal
+import sys
+import threading
+from typing import Any, Callable, Dict, List, Optional
+
+import requests
+
+logger = logging.getLogger("ledmatrix-mqtt-bridge")
+
+DISCOVERY_PREFIX = "homeassistant"
+DEVICE_ID = "ledmatrix"
+DEVICE_INFO = {
+    "identifiers": [DEVICE_ID],
+    "name": "LEDMatrix",
+    "manufacturer": "ChuckBuilds",
+    "model": "LEDMatrix Display",
+}
+
+DEFAULTS = {
+    "mqtt_host": "localhost",
+    "mqtt_port": 1883,
+    "mqtt_username": None,
+    "mqtt_password": None,  # nosec B105 - "no password configured", not a credential
+    "mqtt_client_id": "ledmatrix-mqtt-bridge",
+    "mqtt_topic": "ledmatrix/command",
+    "mqtt_tls": False,
+    "mqtt_tls_insecure": False,
+    "ledmatrix_api_base": "http://localhost:5000",
+    "request_timeout": 15,
+    "on_demand_duration": None,
+    "log_level": "INFO",
+}
+
+
+class ConfigError(Exception):
+    """The bridge cannot start with the configuration it was given."""
+
+
+def load_config(path: str) -> Dict[str, Any]:
+    """Read bridge_config.json, overlaid on DEFAULTS.
+
+    Every value may also come from the environment as LEDMATRIX_MQTT_<KEY>,
+    which is how a password stays out of a file that has to be world-readable
+    for the service user.
+    """
+    config = dict(DEFAULTS)
+    if os.path.isfile(path):
+        with open(path, encoding="utf-8") as handle:
+            try:
+                loaded = json.load(handle)
+            except json.JSONDecodeError as err:
+                raise ConfigError(f"{path} is not valid JSON: {err}") from err
+        if not isinstance(loaded, dict):
+            raise ConfigError(f"{path} must contain a JSON object")
+        config.update(loaded)
+    else:
+        logger.warning("No config file at %s - using defaults and environment", path)
+
+    for key in DEFAULTS:
+        env_value = os.environ.get(f"LEDMATRIX_MQTT_{key.upper()}")
+        if env_value is not None:
+            config[key] = env_value
+
+    for key in ("mqtt_port", "request_timeout"):
+        try:
+            config[key] = int(config[key])
+        except (TypeError, ValueError) as err:
+            raise ConfigError(f"{key} must be a whole number, got {config[key]!r}") from err
+    for key in ("mqtt_tls", "mqtt_tls_insecure"):
+        config[key] = str(config[key]).lower() in ("1", "true", "yes", "on")
+
+    if config.get("mqtt_password") == "REPLACE_WITH_YOUR_ACTUAL_MQTT_PASSWORD":
+        raise ConfigError(
+            "mqtt_password is still the example placeholder - set a real password, "
+            "or remove the key if your broker allows anonymous connections")
+    return config
+
+
+class LEDMatrixClient:
+    """The api_v3 calls the bridge needs, and nothing else.
+
+    Everything goes through the HTTP API rather than the filesystem, so the
+    bridge does not have to live on the Pi, does not need read access to
+    config.json, and cannot drift from the web UI's own behaviour.
+    """
+
+    def __init__(self, api_base: str, timeout: int = 15,
+                 session: Optional[requests.Session] = None):
+        self.api_base = api_base.rstrip("/")
+        self.timeout = timeout
+        self.session = session or requests.Session()
+
+    def _call(self, method: str, path: str, **kwargs) -> Dict[str, Any]:
+        url = f"{self.api_base}/api/v3{path}"
+        response = self.session.request(method, url, timeout=self.timeout, **kwargs)
+        try:
+            body = response.json()
+        except ValueError:
+            body = {}
+        if response.status_code >= 400 or body.get("status") == "error":
+            message = body.get("message") or f"HTTP {response.status_code}"
+            raise RuntimeError(f"{method} {path} failed: {message}")
+        return body.get("data", body)
+
+    def list_modes(self) -> List[Dict[str, Any]]:
+        """Every display mode that can be force-displayed, newest discovery.
+
+        /display/modes triggers plugin discovery itself, which matters because
+        discovery is lazy: a bridge that never opens the dashboard would
+        otherwise see nothing at all.
+        """
+        return self._call("GET", "/display/modes").get("modes", [])
+
+    def display_status(self) -> Dict[str, Any]:
+        return self._call("GET", "/display/on-demand/status")
+
+    def start_on_demand(self, mode: str, plugin_id: Optional[str] = None,
+                        duration: Optional[int] = None, pinned: bool = False) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {"mode": mode, "pinned": pinned}
+        if plugin_id:
+            # find_plugin_for_mode only sees modes declared in a static
+            # manifest, so a plugin whose modes are generated -- each installed
+            # Starlark app is one -- 404s when plugin_id is omitted. Sending it
+            # skips that lookup. /display/modes reports it for every mode.
+            payload["plugin_id"] = plugin_id
+        if duration:
+            payload["duration"] = int(duration)
+        return self._call("POST", "/display/on-demand/start", json=payload)
+
+    def stop_on_demand(self) -> Dict[str, Any]:
+        return self._call("POST", "/display/on-demand/stop", json={})
+
+    def set_power(self, on: bool) -> Dict[str, Any]:
+        action = "start_display" if on else "stop_display"
+        return self._call("POST", "/system/action", json={"action": action})
+
+    def get_brightness(self) -> Optional[int]:
+        config = self._call("GET", "/config/main")
+        value = config.get("display", {}).get("hardware", {}).get("brightness")
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            return None
+
+    def set_brightness(self, value: int) -> Dict[str, Any]:
+        return self._call("POST", "/config/main", json={"brightness": int(value)})
+
+
+class CommandHandler:
+    """Turns one decoded MQTT payload into one API call.
+
+    Kept free of MQTT so it can be tested against a fake client: the failure
+    modes worth pinning are all in here (an unknown mode, an out-of-range
+    brightness, a mode name that needs its plugin_id attached).
+    """
+
+    def __init__(self, client: LEDMatrixClient, default_duration: Optional[int] = None):
+        self.client = client
+        self.default_duration = default_duration
+        self._modes_by_name: Dict[str, Dict[str, Any]] = {}
+
+    def refresh_modes(self) -> List[Dict[str, Any]]:
+        modes = self.client.list_modes()
+        self._modes_by_name = {m["mode"]: m for m in modes}
+        # Home Assistant's select shows labels, so accept them back as well --
+        # otherwise picking "Simple Clock" in a dashboard is not a mode name.
+        for entry in modes:
+            self._modes_by_name.setdefault(entry.get("name") or entry["mode"], entry)
+        return modes
+
+    @property
+    def known_modes(self) -> List[Dict[str, Any]]:
+        return list({id(v): v for v in self._modes_by_name.values()}.values())
+
+    def handle(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        action = payload.get("action")
+        handlers: Dict[str, Callable[[Dict[str, Any]], Dict[str, Any]]] = {
+            "display": self._display,
+            "stop_display": lambda _p: self._ok(self.client.stop_on_demand()),
+            "power": self._power,
+            "brightness": self._brightness,
+            "refresh": lambda _p: self._ok({"modes": len(self.refresh_modes())}),
+        }
+        handler = handlers.get(action)
+        if handler is None:
+            return self._error(f"Unknown action {action!r}; expected one of "
+                               f"{', '.join(sorted(handlers))}")
+        try:
+            return handler(payload)
+        except (requests.RequestException, RuntimeError) as err:
+            logger.error("Command %s failed: %s", action, err)
+            return self._error(str(err))
+
+    def _display(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        mode = payload.get("mode")
+        plugin_id = payload.get("plugin_id")
+        if not mode and not plugin_id:
+            return self._error("display requires 'mode' or 'plugin_id'")
+
+        known = self._modes_by_name.get(mode) if mode else None
+        if known is None and mode and not plugin_id:
+            # One retry against a fresh listing: a plugin installed since the
+            # last refresh is the common reason a valid mode looks unknown.
+            self.refresh_modes()
+            known = self._modes_by_name.get(mode)
+        if known is not None:
+            mode = known["mode"]
+            plugin_id = plugin_id or known.get("plugin_id")
+
+        duration = payload.get("duration", self.default_duration)
+        pinned = bool(payload.get("pinned", False))
+        result = self.client.start_on_demand(
+            mode=mode, plugin_id=plugin_id, duration=duration, pinned=pinned)
+        return self._ok(result, mode=mode, plugin_id=plugin_id)
+
+    def _power(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        state = str(payload.get("state", "")).strip().lower()
+        if state not in ("on", "off"):
+            return self._error("power requires 'state' of 'on' or 'off'")
+        return self._ok(self.client.set_power(state == "on"), state=state)
+
+    def _brightness(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        raw = payload.get("value")
+        try:
+            value = int(float(raw))
+        except (TypeError, ValueError):
+            return self._error(f"brightness requires a number, got {raw!r}")
+        if not 0 <= value <= 100:
+            return self._error(f"brightness must be between 0 and 100, got {value}")
+        return self._ok(self.client.set_brightness(value), value=value)
+
+    @staticmethod
+    def _ok(result: Any, **extra) -> Dict[str, Any]:
+        return {"status": "success", "result": result, **extra}
+
+    @staticmethod
+    def _error(message: str) -> Dict[str, Any]:
+        return {"status": "error", "message": message}
+
+
+def discovery_messages(command_topic: str, state_topic: str, availability_topic: str,
+                       mode_labels: List[str]) -> List[Dict[str, Any]]:
+    """The retained MQTT Discovery configs, as {topic, payload} pairs.
+
+    Pure, so the entity shapes can be asserted without a broker. Every entity
+    shares one availability topic, which is also the bridge's last will -- HA
+    then shows the matrix as unavailable when the bridge dies, instead of
+    leaving stale controls that silently do nothing.
+    """
+    common = {
+        "device": DEVICE_INFO,
+        "availability_topic": availability_topic,
+        "payload_available": "online",
+        "payload_not_available": "offline",
+    }
+    return [
+        {
+            "topic": f"{DISCOVERY_PREFIX}/select/{DEVICE_ID}/display_mode/config",
+            "payload": {
+                **common,
+                "name": "Display Mode",
+                "unique_id": f"{DEVICE_ID}_display_mode",
+                "command_topic": command_topic,
+                "command_template": '{"action": "display", "mode": "{{ value }}"}',
+                "state_topic": state_topic,
+                "value_template": "{{ value_json.mode }}",
+                "options": mode_labels,
+                "icon": "mdi:view-dashboard",
+            },
+        },
+        {
+            "topic": f"{DISCOVERY_PREFIX}/button/{DEVICE_ID}/stop_display/config",
+            "payload": {
+                **common,
+                "name": "Stop Display",
+                "unique_id": f"{DEVICE_ID}_stop_display",
+                "command_topic": command_topic,
+                "payload_press": '{"action": "stop_display"}',
+                "icon": "mdi:stop",
+            },
+        },
+        {
+            "topic": f"{DISCOVERY_PREFIX}/switch/{DEVICE_ID}/power/config",
+            "payload": {
+                **common,
+                "name": "Power",
+                "unique_id": f"{DEVICE_ID}_power",
+                "command_topic": command_topic,
+                "payload_on": '{"action": "power", "state": "on"}',
+                "payload_off": '{"action": "power", "state": "off"}',
+                "state_topic": state_topic,
+                "value_template": "{{ 'ON' if value_json.power else 'OFF' }}",
+                "state_on": "ON",
+                "state_off": "OFF",
+                "icon": "mdi:power",
+            },
+        },
+        {
+            "topic": f"{DISCOVERY_PREFIX}/number/{DEVICE_ID}/brightness/config",
+            "payload": {
+                **common,
+                "name": "Brightness",
+                "unique_id": f"{DEVICE_ID}_brightness",
+                "command_topic": command_topic,
+                "command_template": '{"action": "brightness", "value": {{ value }}}',
+                "state_topic": state_topic,
+                "value_template": "{{ value_json.brightness }}",
+                "min": 0,
+                "max": 100,
+                "step": 1,
+                "icon": "mdi:brightness-6",
+            },
+        },
+    ]
+
+
+def warn_if_cleartext(config: Dict[str, Any]) -> bool:
+    """Say so, once, when a broker password is going over an unencrypted link.
+
+    The shipped example has TLS on, so reaching here means somebody turned it
+    off deliberately -- which is legitimate (the Mosquitto add-on is plaintext
+    on 1883) but should not be silent when there is a password to lose. Returns
+    whether it warned, so the decision is testable without a broker.
+    """
+    if config.get("mqtt_tls") or not config.get("mqtt_password"):
+        return False
+    logger.warning(
+        'mqtt_tls is off and a password is set: the broker password and every '
+        'command are sent unencrypted. Set "mqtt_tls": true (port 8883 on most '
+        'brokers) unless this is a trusted, isolated network.')
+    return True
+
+
+def read_state(client: LEDMatrixClient) -> Dict[str, Any]:
+    """The state every entity reads, so HA opens on real values.
+
+    Each field is fetched independently: a matrix with its display service
+    stopped still has a brightness worth showing, and one unreachable field
+    should not blank the rest.
+    """
+    state: Dict[str, Any] = {"power": False, "mode": None, "brightness": None}
+    try:
+        status = client.display_status()
+        state["power"] = bool(status.get("service", {}).get("active"))
+        on_demand = status.get("state", {})
+        if on_demand.get("active"):
+            state["mode"] = on_demand.get("mode")
+    except (requests.RequestException, RuntimeError) as err:
+        logger.debug("Could not read display status: %s", err)
+    try:
+        state["brightness"] = client.get_brightness()
+    except (requests.RequestException, RuntimeError) as err:
+        logger.debug("Could not read brightness: %s", err)
+    return state
+
+
+class Bridge:
+    """MQTT wiring around CommandHandler."""
+
+    def __init__(self, config: Dict[str, Any]):
+        self.config = config
+        self.command_topic = config["mqtt_topic"]
+        self.status_topic = f"{self.command_topic}/status"
+        self.state_topic = f"{self.command_topic}/state"
+        self.availability_topic = f"{self.command_topic}/availability"
+        self.client = LEDMatrixClient(config["ledmatrix_api_base"], config["request_timeout"])
+        self.handler = CommandHandler(self.client, config.get("on_demand_duration"))
+        self._stop = threading.Event()
+        self._mqtt = None
+
+    # -- MQTT callbacks (paho-mqtt 2.x VERSION2 signatures) ------------------
+
+    def _on_connect(self, client, _userdata, _flags, reason_code, _properties=None):
+        if getattr(reason_code, "is_failure", reason_code != 0):
+            logger.error("MQTT connection refused: %s", reason_code)
+            return
+        logger.info("Connected to MQTT broker; subscribing to %s", self.command_topic)
+        client.subscribe(self.command_topic, qos=1)
+        client.publish(self.availability_topic, "online", qos=1, retain=True)
+        # Re-publish on every reconnect, not just the first connect: a broker
+        # restart drops retained discovery configs, and HA would otherwise be
+        # left with entities it can no longer describe.
+        self.publish_discovery()
+        self.publish_state()
+
+    def _on_message(self, _client, _userdata, message):
+        try:
+            payload = json.loads(message.payload.decode("utf-8"))
+        except (UnicodeDecodeError, json.JSONDecodeError) as err:
+            logger.warning("Ignoring unparseable message on %s: %s", message.topic, err)
+            self._publish(self.status_topic, {"status": "error", "message": f"bad payload: {err}"})
+            return
+        if not isinstance(payload, dict):
+            self._publish(self.status_topic,
+                          {"status": "error", "message": "payload must be a JSON object"})
+            return
+
+        logger.info("Command: %s", payload)
+        result = self.handler.handle(payload)
+        self._publish(self.status_topic, result)
+        # The API applies changes asynchronously (the controller polls its
+        # mailbox), so read state back rather than assuming the command took.
+        self.publish_state()
+
+    # -- publishing ---------------------------------------------------------
+
+    def _publish(self, topic: str, payload: Any, retain: bool = False) -> None:
+        if self._mqtt is None:
+            return
+        body = payload if isinstance(payload, str) else json.dumps(payload)
+        self._mqtt.publish(topic, body, qos=1, retain=retain)
+
+    def publish_discovery(self) -> None:
+        try:
+            modes = self.handler.refresh_modes()
+        except (requests.RequestException, RuntimeError) as err:
+            logger.error("Could not list display modes: %s", err)
+            modes = self.handler.known_modes
+        labels = sorted({m.get("name") or m["mode"] for m in modes})
+        for message in discovery_messages(self.command_topic, self.state_topic,
+                                          self.availability_topic, labels):
+            self._publish(message["topic"], message["payload"], retain=True)
+        logger.info("Published discovery for %d display mode(s)", len(labels))
+
+    def publish_state(self) -> None:
+        self._publish(self.state_topic, read_state(self.client), retain=True)
+
+    # -- lifecycle ----------------------------------------------------------
+
+    def run(self) -> int:
+        try:
+            import paho.mqtt.client as mqtt
+        except ImportError:
+            logger.error("paho-mqtt is not installed: pip install -r requirements.txt")
+            return 1
+
+        # VERSION2 is the current callback API. The compatibility note in
+        # CLAUDE.md is about code written against the v1 signatures; this file
+        # is written against v2 and requires paho-mqtt >= 2.0.
+        self._mqtt = mqtt.Client(
+            mqtt.CallbackAPIVersion.VERSION2,
+            client_id=self.config["mqtt_client_id"])
+        if self.config.get("mqtt_username"):
+            self._mqtt.username_pw_set(self.config["mqtt_username"],
+                                       self.config.get("mqtt_password"))
+        if self.config.get("mqtt_tls"):
+            self._mqtt.tls_set()
+            if self.config.get("mqtt_tls_insecure"):
+                logger.warning("TLS certificate verification is disabled (mqtt_tls_insecure)")
+                self._mqtt.tls_insecure_set(True)
+        else:
+            warn_if_cleartext(self.config)
+
+        self._mqtt.will_set(self.availability_topic, "offline", qos=1, retain=True)
+        self._mqtt.on_connect = self._on_connect
+        self._mqtt.on_message = self._on_message
+
+        logger.info("Connecting to %s:%s", self.config["mqtt_host"], self.config["mqtt_port"])
+        try:
+            self._mqtt.connect(self.config["mqtt_host"], self.config["mqtt_port"], keepalive=60)
+        except OSError as err:
+            logger.error("Could not reach the MQTT broker: %s", err)
+            return 1
+
+        self._mqtt.loop_start()
+        try:
+            while not self._stop.wait(30):
+                # HA is told the truth about state that changed outside the
+                # bridge -- somebody using the web UI, or an on-demand window
+                # expiring on its own.
+                self.publish_state()
+        finally:
+            self._publish(self.availability_topic, "offline", retain=True)
+            self._mqtt.loop_stop()
+            self._mqtt.disconnect()
+        return 0
+
+    def stop(self, *_args) -> None:
+        logger.info("Shutting down")
+        self._stop.set()
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument(
+        "--config",
+        default=os.path.join(os.path.dirname(os.path.abspath(__file__)), "bridge_config.json"),
+        help="Path to bridge_config.json (default: alongside this script)")
+    args = parser.parse_args(argv)
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s")
+    try:
+        config = load_config(args.config)
+    except ConfigError as err:
+        logger.error("%s", err)
+        return 1
+    logging.getLogger().setLevel(str(config.get("log_level", "INFO")).upper())
+
+    bridge = Bridge(config)
+    signal.signal(signal.SIGTERM, bridge.stop)
+    signal.signal(signal.SIGINT, bridge.stop)
+    return bridge.run()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

integrations/mqtt_bridge/requirements.txt

@@ -0,0 +1,5 @@
+# Floors are security floors, not API floors. requests < 2.33.0 carries
+# CVE-2024-35195, CVE-2024-47081 and CVE-2026-25645; matches the pin in the
+# project's own requirements.txt.
+paho-mqtt>=2.0.0,<3.0.0
+requests>=2.33.0,<3.0.0