fix(gui): restore live metrics + preview on LED devices (cutover regressions)

Summoned LED/DIGITAL coolers showed M1-M6 = `--` and a dead preview. Three
regressions from the next/ cutover, all restored; LED now uses the SAME paths
as LCD (the device's render IS the preview, off one source):

1. Handler built without `app`. `_add_handler` hand-wired two divergent
   branches; the LED branch forgot `app=`, so `LEDHandler._app` stayed None and
   `update_metrics` early-returned every tick. Collapsed both branches into one
   `_build_handler` chokepoint that injects `app` + panels uniformly, driven by
   the new shared presentation backbone. `LEDHandler` now REQUIRES `app` (raises,
   like LCDHandler) and the dead `set_app` is gone.

2. Sensor tick skipped LED. The render observer only re-rendered devices with a
   theme (LCD); LED has none, so `RenderLed` never fired on a sensor update. Now
   ticks `RenderLed` for connected LED devices — the LED twin of RenderAndSend.

3. Render output never reached the preview. `RenderLed` published only a count.
   Now it publishes its colors on `FrameSent` — the SAME event/slot LCD uses
   (`surface` for LCD, `display_colors` for LED) → one `_on_bus_frame_sent` →
   `handle_frame` → preview. One render → FrameSent → preview, for both kinds.
   No parallel pipe.

New shared backbone: `ui/presentation/device_presentation.py` —
`presentation_for(ProductInfo) -> DevicePresentation` (kind→view+gauges, keyed on
vid/pid+handshake), Qt-free, for both ui/gui and ui/qtgui to join against instead
of re-deriving device→view.

Verified deterministically (real event loop, real widget state, not the
formatter): summoned AX120 → M1-M6 show live CPU/GPU + preview 30/30 segments
lit. Tests: presentation_for over the registry; LEDHandler-rejects-None-app.
Logging filled on the silent hops (handle_frame, update_sensor_metrics). 1498
green, ruff + pyright clean. dev/tools/diagnose_metrics.py: deterministic
single-device probe (force-added; .gitignore `tools/` catches dev/tools).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Lexonight1

dev/audit_present.py

@@ -60,13 +60,12 @@ def ok(self) -> bool:
         return not self.failures
 
 
-def _summon_and_check(window: Any, d: dict, snapshot: Any, unit: str) -> Finding:
+def _summon_and_check(window: Any, d: dict, snapshot: Any) -> Finding:
     """Run the real VariantPanel summon for one variant + assert it shows properly."""
     from trcc.core.commands import ConnectDevice
     from trcc.core.models import Wire
     from trcc.ui.gui.lcd_handler import LCDHandler
     from trcc.ui.gui.led_handler import LEDHandler
-    from trcc.ui.presentation.led_metrics_format import format_sensor_gauges
 
     app = window._app
     vid, pid, pm, sub, fbl = d["vid"], d["pid"], d["pm"], d["sub"], d["fbl"]
@@ -109,23 +108,28 @@ def _summon_and_check(window: Any, d: dict, snapshot: Any, unit: str) -> Finding
             if not (res and res[0] > 0 and res[1] > 0):
                 f.failures.append(f"canvas: invalid resolution {res}")
 
-        # 4. metrics — a real OS snapshot fans out to the active handler without
-        #    error and renders real values (the `--` bug class).
+        # 4. metrics — a real OS snapshot fans out to the active handler and the
+        #    panel WIDGET renders real values.  Read the actual gauge ``_text``
+        #    (what the user sees), NOT format_sensor_gauges — checking the
+        #    recompute was the false-pass that let the `app=None` bug through.
         window._last_metrics = snapshot
         try:
             window._fan_out_metrics(reason=f"audit:{f.model}")
-        except Exception as e:  # the None-crash bug would land here
+        except Exception as e:
             f.failures.append(f"metrics: fan-out raised {type(e).__name__}: {e}")
             return f
-        # _temp_label renders "NC" for a genuinely-absent (0.0) temp — correct —
-        # so assert the always-readable usage/clock fields are numeric (only when
-        # CPU is actually live, else the check is vacuous).
+        # LED segment panels carry the M1-M6 gauges; assert the always-readable
+        # usage/clock fields show a live number (only when CPU is live, else
+        # the check is vacuous — a genuinely-absent temp renders "NC", correct).
         if is_led and snapshot.cpu_percent > 0:
-            g = format_sensor_gauges(snapshot, unit)
+            imgs = getattr(getattr(handler, "_panel", None), "_info_images", {})
+            if not imgs:
+                f.failures.append("metrics: LED panel has no _info_images")
             for gk in ("cpu_usage", "cpu_clock"):
-                if not _NUMERIC.match(g[gk][1]):
+                txt = getattr(imgs.get(gk), "_text", None)
+                if not (txt and _NUMERIC.match(txt)):
                     f.failures.append(
-                        f"metrics: {gk} placeholder {g[gk][1]!r} despite live CPU")
+                        f"metrics: gauge {gk} _text={txt!r} (panel not populated)")
     except Exception as e:
         f.failures.append(f"EXC during summon: {type(e).__name__}: {e}")
         log.exception("audit: %s (%s) raised", f.model, key)
@@ -160,7 +164,6 @@ def _run_audit(window: Any) -> None:
         app.platform.sensors().snapshot(),
         temp_unit=s.temp_unit, hdd_enabled=s.hdd_enabled,
     )
-    unit = "°F" if s.temp_unit == "F" else "°C"
     live = (snapshot.cpu_percent > 0 or snapshot.cpu_temp > 0)
     log.info("audit: live sensors=%s (cpu %.0f%% %.0f°, gpu %.0f° %.0fMHz)",
              "yes" if live else "NO", snapshot.cpu_percent, snapshot.cpu_temp,
@@ -169,7 +172,7 @@ def _run_audit(window: Any) -> None:
     variants = _variant_dicts()
     findings: list[Finding] = []
     for i, d in enumerate(variants):
-        f = _summon_and_check(window, d, snapshot, unit)
+        f = _summon_and_check(window, d, snapshot)
         findings.append(f)
         # Flushed per-variant so progress + any hang is visible even if the run
         # is killed before the summary prints.

dev/tools/diagnose_metrics.py

@@ -1,13 +1,18 @@
 #!/usr/bin/env python3
-"""Diagnose the live metrics path for a summoned mock device.
+"""Diagnose the live metrics + preview path for one summoned mock device.
 
-dev/mock_gui fakes ONLY the handshake; sensors/render/observe are the real app.
-This summons one device deterministically (no flaky offscreen auto-click), then
-drives the REAL observe slot — builds a SensorsUpdated exactly as MetricsLoop
-does and calls ``window._on_bus_sensors_updated(event)`` DIRECTLY so any
-exception propagates here instead of being swallowed by Qt's queued-slot
-wrapper.  Prints, flushed, every hop: connect → handler → active → fan-out →
-the resolved gauge values.  Answers "why do the device's M1-M6 show --".
+dev/mock_gui fakes ONLY the handshake; sensors/render/observe/preview are the
+real app.  This summons ONE device deterministically (no flaky offscreen
+auto-click — it does NOT mount the dev console), then lets the REAL event loop
+run for a few seconds so the genuine chain fires end to end:
+
+    MetricsLoop tick → SensorsUpdated → render observer → RenderAndSend/RenderLed
+        → device send + (LCD) FrameSent / (LED) LedColorsChanged
+        → GUI observes → handler.handle_frame → preview updates + M1-M6 gauges
+
+then reads the ACTUAL widget state (gauge ``_text`` + preview ``_colors``) — what
+the user sees — and prints it.  Answers "do metrics + preview populate for this
+device" with no guessing.
 
     PYTHONPATH=src QT_QPA_PLATFORM=offscreen python3.12 dev/tools/diagnose_metrics.py
     PYTHONPATH=src QT_QPA_PLATFORM=offscreen python3.12 dev/tools/diagnose_metrics.py 0416:8001 3
@@ -22,21 +27,16 @@
 sys.path.insert(0, str(_DEV))
 from _mock_bootstrap import bootstrap
 
+_SETTLE_MS = 5000  # let several real MetricsLoop ticks drive the full chain
+
 
 def _say(msg: str) -> None:
     print(msg, flush=True)
 
 
-def _diagnose(window, vid: int, pid: int, pm: int, sub: int) -> None:
-    from trcc.adapters.repo.http import HttpFetchError, UrllibHttpFetcher
-    UrllibHttpFetcher.fetch = (  # cut net: theme downloads 404-with-retry, slow
-        lambda self, url, *a, **k: (_ for _ in ()).throw(HttpFetchError("net off")))
-
+def _summon(window, vid: int, pid: int, pm: int, sub: int) -> str:
     from trcc.core.commands import ConnectDevice
-    from trcc.core.events import SensorsUpdated
     from trcc.core.protocol import pm_to_fbl
-    from trcc.services.metrics_personalize import (
-        personalize_metrics, personalize_readings)
 
     app = window._app
     key = f"{vid:04x}:{pid:04x}"
@@ -49,39 +49,37 @@ def _diagnose(window, vid: int, pid: int, pm: int, sub: int) -> None:
     device = app.devices.get(key)
     window._add_handler(device)
     window._active_key = ""
-    _say("activating…")
     window._activate_device(key)
     h = window._handlers.get(key)
-    _say(f"handler={type(h).__name__} active={getattr(h, 'active', '?')} "
-         f"active_key={window._active_key!r}")
-
-    s = app.settings.app
-    raw = app.platform.sensors().read_all()
-    readings = personalize_readings(raw, temp_unit=s.temp_unit,
-                                    hdd_enabled=s.hdd_enabled)
-    metrics = personalize_metrics(app.platform.sensors().snapshot(),
-                                  temp_unit=s.temp_unit, hdd_enabled=s.hdd_enabled)
-    _say(f"snapshot cpu_temp={metrics.cpu_temp} cpu%={metrics.cpu_percent:.0f} "
-         f"gpu_temp={metrics.gpu_temp}")
-    ev = SensorsUpdated(reading_count=len(readings), readings=readings,
-                        temp_unit=s.temp_unit, metrics=metrics)
-    _say("calling the live observe slot _on_bus_sensors_updated(event)…")
+    _say(f"handler={type(h).__name__} active={getattr(h, 'active', '?')}")
+    _say(f"letting the real loop run {_SETTLE_MS} ms…")
+    return key
+
+
+def _inspect_and_exit(window, key: str) -> None:
+    import os
     try:
-        window._on_bus_sensors_updated(ev)
-        _say("OK — observe slot returned without raising")
+        h = window._handlers.get(key)
+        panel = getattr(h, "_panel", None)
+        # M1-M6 gauges
+        imgs = getattr(panel, "_info_images", {}) or {}
+        if imgs:
+            _say("M1-M6 gauges: " + ", ".join(
+                f"{k}={getattr(w, '_text', '?')}" for k, w in imgs.items()))
+        # LED preview segment colors (lit = non-black)
+        preview = getattr(panel, "_preview", None)
+        colors = getattr(preview, "_colors", None)
+        if colors is not None:
+            lit = sum(1 for c in colors if tuple(c) != (0, 0, 0))
+            _say(f"PREVIEW _colors: {len(colors)} segments, {lit} lit "
+                 f"({'POPULATED' if lit else 'all black — NOT populated'})")
+        else:
+            _say("PREVIEW: not an LED segment panel (LCD frame preview)")
     except Exception:
-        _say("EXCEPTION in the live observe slot:")
         traceback.print_exc()
-        return
-
-    # Show the values the panel actually renders into the M1-M6 gauges — the
-    # exact text the user sees (or `--`).  This is what `update_sensor_metrics`
-    # pushes via `UCInfoImage.set_value`.
-    from trcc.ui.presentation.led_metrics_format import format_sensor_gauges
-    unit = "°F" if s.temp_unit == "F" else "°C"
-    gauges = format_sensor_gauges(metrics, unit)
-    _say("rendered M1-M6 gauge text: "
-         + ", ".join(f"{k}={t}{u}" for k, (_v, t, u) in gauges.items()))
+    finally:
+        sys.stdout.flush()
+        os._exit(0)
 
 
 def main() -> None:
@@ -94,14 +92,20 @@ def main() -> None:
                          specs=[{"vid": f"{vid:04x}", "pid": f"{pid:04x}", "pm": pm}])
 
     def on_ready(window) -> None:
-        import os
+        from PySide6.QtCore import QTimer
+
+        from trcc.adapters.repo.http import HttpFetchError, UrllibHttpFetcher
+        UrllibHttpFetcher.fetch = lambda self, url, *a, **k: (
+            _ for _ in ()).throw(HttpFetchError("net off"))
         try:
-            _diagnose(window, vid, pid, pm, sub)
-        finally:
-            # Hard exit: the result is printed + flushed; skip the GUI teardown
-            # (native-lib shutdown can hang offscreen) — this is a one-shot probe.
-            sys.stdout.flush()
-            os._exit(0)
+            key = _summon(window, vid, pid, pm, sub)
+        except Exception:
+            traceback.print_exc()
+            import os
+            os._exit(1)
+        # Let the REAL MetricsLoop → observer → RenderLed → preview chain run
+        # (queued signals need the event loop spinning), THEN inspect.
+        QTimer.singleShot(_SETTLE_MS, lambda: _inspect_and_exit(window, key))
 
     from trcc.ui.gui import run_gui
     run_gui(platform, single_instance=False, ipc=False, force_exit=False,

src/trcc/app.py

@@ -462,8 +462,9 @@ def __init__(self, app: App) -> None:
         self._app = app
         # Lazy import — RenderAndSend lives in core.commands, which
         # already imports from app.py via TYPE_CHECKING.
-        from .core.commands import RenderAndSend
+        from .core.commands import RenderAndSend, RenderLed
         self._RenderAndSend = RenderAndSend
+        self._RenderLed = RenderLed
         for event_cls in (
             BrightnessChanged, MaskApplied, MaskPositionChanged,
             MaskVisibilityChanged, OverlayChanged, FitModeChanged,
@@ -507,23 +508,34 @@ def _on_visual_change(self, event: Any) -> None:
         if evt_key:
             keys = [evt_key]
         else:
+            # Device-wide event (SensorsUpdated): re-render every connected
+            # device — LCDs with a theme, AND LED devices (their segment
+            # display IS the live metric, no theme involved).  LED was
+            # dropped from this list at the cutover, which is why LED panels
+            # stopped updating on sensor ticks.
             keys = [
                 k for k, d in self._app.devices.items()
-                if d.is_connected and k in self._app.active_themes
+                if d.is_connected
+                and (d.is_led or k in self._app.active_themes)
             ]
         for key in keys:
             device = self._app.devices.get(key)
+            if device is None or not device.is_connected:
+                continue
+            # LED: segments are computed straight from live sensors — no
+            # theme.  RenderLed sends to the device AND drives the preview.
+            if device.is_led:
+                log.debug(
+                    "DeviceRenderObserver: %s for %s → RenderLed",
+                    type(event).__name__, key,
+                )
+                self._app.dispatch(self._RenderLed(key=key))
+                continue
             theme = self._app.active_themes.get(key)
-            if (
-                device is None or not device.is_connected
-                or theme is None
-            ):
+            if theme is None:
                 log.debug(
-                    "DeviceRenderObserver: skip %s for %s "
-                    "(connected=%s theme=%s)",
+                    "DeviceRenderObserver: skip %s for %s (no theme)",
                     type(event).__name__, key,
-                    device is not None and device.is_connected,
-                    theme is not None,
                 )
                 continue
             log.debug(

src/trcc/core/commands/led.py

@@ -12,6 +12,7 @@
 )
 from ..events import (
     ErrorOccurred,
+    FrameSent,
     HddEnabledChanged,
     LedColorsChanged,
 )
@@ -314,6 +315,12 @@ def execute(self, app: App) -> LedColorsResult:
             app.events.publish(LedColorsChanged(
                 key=self.key, color_count=len(colors),
             ))
+            # Same preview path as LCD: publish the rendered output on
+            # FrameSent so the GUI preview shows exactly what went to the
+            # device (LCD carries a surface; LED carries the colors).
+            app.events.publish(FrameSent(
+                key=self.key, bytes_sent=len(colors), display_colors=colors,
+            ))
         return LedColorsResult(
             ok=ok, key=self.key, colors=colors,
             message=(f"Rendered {style.value} {effective_settings.mode.name} "

src/trcc/core/events.py

@@ -56,6 +56,11 @@ class FrameSent(Event):
     # SendColor / SendImage / keepalive) and would be None across IPC,
     # where a remote client must fall back to a re-render.
     surface: Any = None
+    # LED twin of ``surface``: an LED render has no image, it has per-LED
+    # colors.  Carried on the SAME event so LED uses the SAME preview path as
+    # LCD (one render → FrameSent → handle_frame → preview), not a parallel
+    # one.  Empty for LCD / pure-bytes sends.
+    display_colors: list = field(default_factory=list)
 
 
 @dataclass(frozen=True, slots=True)

src/trcc/ui/gui/led_handler.py

@@ -46,11 +46,10 @@
 class LEDHandler(BaseHandler):
     """Per-LED-device GUI handler.
 
-    Constructor signature matches the legacy positional shape so the
-    window's ``LEDHandler(device, uc_led_control, on_temp_unit_changed)``
-    call works untouched.  The ``app`` handle comes through the parent
-    window's ``self._app`` reference; we re-fetch it from the device's
-    bound App via :meth:`set_app`, or pass it via ``app=`` kwarg.
+    Built through ``TRCCApp._build_handler`` (the single handler chokepoint),
+    which always injects ``app=self._app``.  ``app`` is REQUIRED: a None handle
+    silently disabled every metrics tick (``update_metrics`` gates on it), which
+    was the LED ``--`` bug — so we fail loudly at the composition root instead.
     """
 
     _SAVE_INTERVAL = 20  # cycles between best-effort settings flushes
@@ -63,13 +62,16 @@ def __init__(
         app: App | None = None,
     ) -> None:
         super().__init__(device, 'led')
+        if app is None:
+            raise RuntimeError(
+                "LEDHandler requires an App handle — the composition root must "
+                "pass one (a None handle silently disables metric updates)"
+            )
         self._panel = panel
         self._on_temp_unit_changed = on_temp_unit_changed
         # next/ Device + key (ProductInfo.key = "vid:pid")
         self._device_key: str = device.info.key if device is not None else ''
-        # The window owns the App reference; LED handlers don't drive
-        # render ticks themselves, so we only need it for dispatching.
-        self._app: App | None = app
+        self._app: App = app
         self._active = False
         self._style: Any = None       # LedStyle enum
         self._style_id_int = 0        # legacy 1..12 for uc_led_control
@@ -78,10 +80,6 @@ def __init__(
 
     # ── Public API ────────────────────────────────────────────────────
 
-    def set_app(self, app: App) -> None:
-        """Inject the App reference post-construction (legacy parity)."""
-        self._app = app
-
     @property
     def active(self) -> bool:
         return self._active
@@ -330,8 +328,10 @@ def _on_test_mode_changed(self, on: bool) -> None:
 
     def handle_frame(self, image: Any) -> None:
         """Receive tick result — update LED color display on the panel."""
+        display_colors = image.get('display_colors') if isinstance(image, dict) else None
+        log.debug("handle_frame: active=%s colors=%s",
+                  self._active, len(display_colors) if display_colors else None)
         if not self._active:
             return
-        display_colors = image.get('display_colors') if isinstance(image, dict) else None
         if display_colors is not None:
             self._panel.set_led_colors(display_colors)