trcc-linux 9.6.1__tar.gz → 9.6.2__tar.gz

{trcc_linux-9.6.1 → trcc_linux-9.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 9.6.1
+Version: 9.6.2
 Summary: Linux implementation of Thermalright LCD Control Center
 Project-URL: Homepage, https://github.com/Lexonight1/thermalright-trcc-linux
 Project-URL: Documentation, https://github.com/Lexonight1/thermalright-trcc-linux#readme
@@ -26,6 +26,7 @@ Requires-Python: >=3.10
 Requires-Dist: certifi>=2023.7.22
 Requires-Dist: click>=7.0
 Requires-Dist: fastapi>=0.100
+Requires-Dist: libusb-package>=1.0.26.3; sys_platform == 'win32' and python_version < '3.14'
 Requires-Dist: numpy>=1.24.0
 Requires-Dist: prompt-toolkit>=3.0.0
 Requires-Dist: psutil>=5.9.0

{trcc_linux-9.6.1 → trcc_linux-9.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trcc-linux"
-version = "9.6.1"
+version = "9.6.2"
 description = "Linux implementation of Thermalright LCD Control Center"
 readme = "README.md"
 license = "GPL-3.0-or-later"
@@ -33,6 +33,14 @@ dependencies = [
     "numpy>=1.24.0",
     "psutil>=5.9.0",
     "pyusb>=1.2.0",
+    # libusb-package bundles libusb-1.0.dll on Windows so pip-installed
+    # users get a working pyusb backend out of the box. Pyocd's canonical
+    # pattern (#131 — usb.core.NoBackendError on pip-install Windows).
+    # Pinned for Windows + Python <3.14 because upstream wheels only go
+    # to cp313 (verified PyPI 2026-05-14); pip install of trcc-linux on
+    # Python 3.14 Windows would otherwise fail at sdist build. Lift the
+    # python_version cap once libusb-package ships a cp314 wheel.
+    "libusb-package>=1.0.26.3; sys_platform == 'win32' and python_version < '3.14'",
     "click>=7.0",
     "typer>=0.9.0",
     "fastapi>=0.100",

{trcc_linux-9.6.1 → trcc_linux-9.6.2}/src/trcc/__version__.py

@@ -1,4 +1,4 @@
 """TRCC Linux version information. History in doc/CHANGELOG.md."""
 
-__version__ = "9.6.1"
+__version__ = "9.6.2"
 __version_info__ = tuple(int(x) for x in __version__.split("."))

trcc_linux-9.6.2/src/trcc/adapters/device/_pyusb_find.py

@@ -0,0 +1,46 @@
+"""PyUSB find() wrapper — uses libusb_package's bundled backend on Windows.
+
+PyUSB needs ``libusb-1.0`` userspace to talk to USB devices. On Linux and
+macOS the system package manager ships it. On Windows there is no system
+libusb — pip-installed users hit ``usb.core.NoBackendError: No backend
+available`` (issue #131, lallemandgianni-boop on Windows 11 v9.6.1).
+
+The canonical fix is `libusb-package <https://github.com/pyocd/libusb-package>`_
+(pyocd's project) — a Windows wheel that bundles ``libusb-1.0.dll`` and
+exposes ``find()`` as a drop-in for ``usb.core.find()``.  pyproject.toml
+adds it as a Windows-only dependency::
+
+    libusb-package>=1.0.26.2; sys_platform == 'win32'
+
+This module exports a single :func:`find` shim that uses
+``libusb_package.find`` when available (Windows wheel installed) and
+falls back to ``usb.core.find`` otherwise (Linux/macOS users with system
+libusb, or anyone who installed the optional wheel themselves).  Every
+``usb.core.find`` call site in ``trcc.adapters.device`` goes through
+this seam so there's exactly one place that knows about the Windows
+quirk.
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+log = logging.getLogger(__name__)
+
+try:
+    from libusb_package import find as _find  # type: ignore[import-not-found]
+    log.debug("pyusb backend: libusb-package (bundled libusb-1.0)")
+except ImportError:
+    from usb.core import find as _find  # type: ignore[no-redef]
+    log.debug("pyusb backend: system libusb via usb.core.find")
+
+
+def find(*args: Any, **kwargs: Any) -> Any:
+    """Drop-in for ``usb.core.find()`` with Windows-compatible backend.
+
+    Identical signature, identical return type. Routes through
+    ``libusb_package.find`` on platforms where it's installed (Windows
+    via pip), otherwise calls ``usb.core.find`` directly (Linux, macOS,
+    or any environment where the user manages libusb themselves).
+    """
+    return _find(*args, **kwargs)

{trcc_linux-9.6.1 → trcc_linux-9.6.2}/src/trcc/adapters/device/_usb_bot_scsi.py

@@ -51,8 +51,9 @@ class UsbBotScsiTransport(ScsiTransport):
     def open(self) -> bool:
         """Find device, detach kernel driver, claim interface."""
         try:
-            import usb.core  # pyright: ignore[reportMissingImports]
             import usb.util  # pyright: ignore[reportMissingImports]
+
+            from . import _pyusb_find
         except ImportError:
             log.error(self._pyusb_install_hint)
             return False
@@ -60,7 +61,7 @@ class UsbBotScsiTransport(ScsiTransport):
         kwargs: dict[str, Any] = {'idVendor': self._vid, 'idProduct': self._pid}
         if self._usb_address is not None:
             kwargs['custom_match'] = self._usb_address.matches
-        dev: Any = usb.core.find(**kwargs)
+        dev: Any = _pyusb_find.find(**kwargs)
         if dev is None:
             where = f" @ {self._usb_address}" if self._usb_address else ""
             log.error("Device %04X:%04X%s not found", self._vid, self._pid, where)

{trcc_linux-9.6.1 → trcc_linux-9.6.2}/src/trcc/adapters/device/_usb_helpers.py

@@ -109,11 +109,11 @@ def _detach_kernel_drivers(dev: Any, count: int = 4) -> bool:
 
 def _reset_and_refind(dev: Any, vid: int, pid: int) -> Any:
     """Reset USB device, wait, re-find, detach drivers. Returns new handle."""
-    import usb.core  # type: ignore[import-untyped]
+    from . import _pyusb_find
 
     dev.reset()  # type: ignore[union-attr]
     time.sleep(0.5)
-    new_dev = usb.core.find(idVendor=vid, idProduct=pid)
+    new_dev = _pyusb_find.find(idVendor=vid, idProduct=pid)
     if new_dev is None:
         raise RuntimeError(_ERR_NOT_FOUND.format(vid=vid, pid=pid))
     _detach_kernel_drivers(new_dev)
@@ -145,13 +145,15 @@ def open_usb_device(
         RuntimeError: Device not found, or kernel driver could not be detached.
         usb.core.USBError: Permission denied (errno 13).
     """
-    import usb.core  # type: ignore[import-untyped]
+    import usb.core  # type: ignore[import-untyped]  # for USBError below
     import usb.util  # type: ignore[import-untyped]
 
+    from . import _pyusb_find
+
     kwargs: dict[str, Any] = {'idVendor': vid, 'idProduct': pid}
     if usb_address is not None:
         kwargs['custom_match'] = usb_address.matches
-    dev = usb.core.find(**kwargs)
+    dev = _pyusb_find.find(**kwargs)
     if dev is None:
         where = f" @ {usb_address}" if usb_address else ""
         raise RuntimeError(_ERR_NOT_FOUND.format(vid=vid, pid=pid) + where)

{trcc_linux-9.6.1 → trcc_linux-9.6.2}/src/trcc/adapters/device/detector.py

@@ -85,7 +85,7 @@ class DeviceDetector:
     def _detect(scsi_resolver: ScsiResolver | None) -> list[DetectedDevice]:
         """Core detection via pyusb with injected SCSI resolver."""
         try:
-            import usb.core  # pyright: ignore[reportMissingImports]
+            from . import _pyusb_find
         except ImportError:
             log.error("pyusb not installed — pip install pyusb")
             return []
@@ -95,7 +95,7 @@ class DeviceDetector:
             # find_all=True yields every match; `or ()` handles None when
             # no devices are present, so two same-VID/PID coolers each
             # produce their own DetectedDevice (issue #128).
-            for usb_dev in (usb.core.find(find_all=True, idVendor=vid, idProduct=pid) or ()):
+            for usb_dev in (_pyusb_find.find(find_all=True, idVendor=vid, idProduct=pid) or ()):
                 dev: Any = usb_dev
                 usb_path = f'usb:{dev.bus}:{dev.address}'
                 scsi_dev = (

{trcc_linux-9.6.1 → trcc_linux-9.6.2}/src/trcc/adapters/device/hid.py

@@ -37,6 +37,7 @@ from trcc.core.models import (
     pm_to_fbl,
 )
 
+from . import _pyusb_find
 from .frame import FrameDevice
 
 # hidapi is optional ([hid] extra)
@@ -634,7 +635,7 @@ class PyUsbTransport(UsbTransport):
             # idVendor/idProduct prefilter for speed.
             kwargs['custom_match'] = self._usb_address.matches
 
-        self._device = usb.core.find(**kwargs)  # type: ignore[union-attr]
+        self._device = _pyusb_find.find(**kwargs)  # type: ignore[union-attr]
         if self._device is None:
             where = f" @ {self._usb_address}" if self._usb_address else ""
             raise RuntimeError(
@@ -888,7 +889,7 @@ def find_hid_devices() -> list:
     ]
 
     for vid, pid, dtype in known:
-        found = usb.core.find(find_all=True, idVendor=vid, idProduct=pid)
+        found = _pyusb_find.find(find_all=True, idVendor=vid, idProduct=pid)
         for dev in found or []:
             serial_idx = getattr(dev, 'iSerialNumber', 0)
             serial = usb.util.get_string(dev, serial_idx) if serial_idx else ""

{trcc_linux-9.6.1 → trcc_linux-9.6.2}/src/trcc/adapters/device/macos/detector.py

@@ -35,7 +35,7 @@ class MacOSDeviceDetector:
         devices: list[DetectedDevice] = []
 
         try:
-            import usb.core  # pyright: ignore[reportMissingImports]
+            from .. import _pyusb_find
         except ImportError:
             log.error("pyusb not installed — pip install pyusb")
             return []
@@ -60,7 +60,7 @@ class MacOSDeviceDetector:
         for registry, protocol, device_type in all_registries:
             for (vid, pid), entry in registry.items():
                 # find_all=True so two same-VID/PID coolers both surface (issue #128).
-                for usb_dev in (usb.core.find(find_all=True, idVendor=vid, idProduct=pid) or ()):
+                for usb_dev in (_pyusb_find.find(find_all=True, idVendor=vid, idProduct=pid) or ()):
                     dev: Any = usb_dev
                     impl = 'hid_led' if registry is _LED_DEVICES else entry.implementation
                     dt = device_type if device_type is not None else getattr(entry, 'device_type', 2)

{trcc_linux-9.6.1 → trcc_linux-9.6.2}/src/trcc/adapters/infra/diagnostics.py

@@ -226,6 +226,18 @@ _INSTALL_MAP: dict[str, dict[str, str]] = {
         'pacman': 'python-hid',
         'zypper': 'python3-hidapi',
     },
+    'nvidia-ml-py': {
+        # Distro names lag PyPI — pyproject pins `nvidia-ml-py>=11.0.0` but
+        # Debian/Fedora repos still ship the legacy `pynvml`-prefixed alias
+        # (same upstream code, exposes the `pynvml` module). Arch ships the
+        # official current name. Reflected in packaging/arch/PKGBUILD +
+        # release.yml Recommends/optdepend so doctor + packagers agree.
+        'apt': 'python3-pynvml',
+        'dnf': 'python3-pynvml',
+        'pacman': 'python-nvidia-ml-py',
+        'zypper': 'python3-nvidia-ml-py',
+        'rpm-ostree': 'python3-pynvml',
+    },
 }
 
 _INSTALL_CMD: dict[str, str] = {
@@ -406,8 +418,8 @@ def _check_library(
     return True
 
 
-def _check_gpu_packages() -> None:
-    if not (results := check_gpu()):
+def _check_gpu_packages(pm: str | None = None) -> None:
+    if not (results := check_gpu(pm)):
         print(f"  {_OPT}  No discrete GPU detected")
         return
     for g in results:
@@ -649,8 +661,14 @@ def check_system_deps(
     return results
 
 
-def check_gpu() -> list[GpuResult]:
-    """Detect GPU vendors and check matching packages."""
+def check_gpu(pm: str | None = None) -> list[GpuResult]:
+    """Detect GPU vendors and check matching packages.
+
+    ``pm`` is the active package manager (apt/dnf/pacman/…). When passed,
+    the NVIDIA install hint resolves to the right distro package
+    (issue #145 — `pip install nvidia-ml-py` fails on PEP 668-managed
+    Pythons like Ubuntu 24.04 / Mint 22). None → falls back to pip.
+    """
     from pathlib import Path  # local so tests can patch pathlib.Path
     pci_base = Path('/sys/bus/pci/devices')
     if not pci_base.exists():
@@ -672,10 +690,14 @@ def check_gpu() -> list[GpuResult]:
     results: list[GpuResult] = []
     if '10de' in vendors:
         ver = get_module_version('pynvml')
+        # Per-distro hint resolves to the right native package name —
+        # apt → python3-pynvml, pacman → python-nvidia-ml-py, etc.
+        # Falls back to pip when no package manager is detected.
+        hint = _install_hint('nvidia-ml-py', pm) if pm else 'pip install nvidia-ml-py'
         results.append(GpuResult(
             vendor='nvidia', label='NVIDIA GPU',
             package_installed=ver is not None,
-            install_cmd='pip install nvidia-ml-py',
+            install_cmd=hint,
         ))
     if '1002' in vendors:
         results.append(GpuResult(
@@ -842,7 +864,7 @@ def run_doctor(doctor_config: DoctorPlatformConfig | None = None) -> int:
 
     if doctor_config.run_gpu_check:
         print()
-        _check_gpu_packages()
+        _check_gpu_packages(pm)
 
     if doctor_config.check_libusb:
         print()

{trcc_linux-9.6.1 → trcc_linux-9.6.2}/src/trcc/core/ports.py

@@ -443,6 +443,49 @@ class AutostartManager(ABC):
         return self.is_enabled()
 
 
+# =========================================================================
+# Metrics Loop ABC — the underlying command stream that ticks every device
+# =========================================================================
+
+
+class MetricsLoop(ABC):
+    """Port: the per-process loop that drives device animation + sensor poll.
+
+    Owns two cadences in one mechanism:
+      * **Tick** — drive `device.tick()` for every connected device, publish
+        `Topic.FRAME` results. Fast (50ms on the polling default).
+      * **Poll** — read `system_svc.all_metrics`, push to every device's
+        `update_metrics()`, publish `Topic.METRICS`. Cadence = the user's
+        ``settings.refresh_interval``.
+
+    The mechanism is OS-discretionary. Default `PollingMetricsLoop` is a
+    thread-based polling loop used by every OS today. Future per-OS
+    overrides can switch to native event sources (WMI events on Windows,
+    IOReportSubscribe on macOS) without changing the contract.
+
+    Concrete implementations:
+        - PollingMetricsLoop (services/metrics_loop.py)
+        - NullMetricsLoop    (services/metrics_loop.py) — for tests + proxy clients
+    """
+
+    @abstractmethod
+    def start(self) -> None:
+        """Begin ticking + polling. Idempotent — safe to call when running."""
+
+    @abstractmethod
+    def stop(self) -> None:
+        """Stop the loop and release any threads. Idempotent."""
+
+    @abstractmethod
+    def wake(self) -> None:
+        """Force an immediate poll iteration (used after settings changes)."""
+
+    @property
+    @abstractmethod
+    def is_running(self) -> bool:
+        """True iff the loop is currently active."""
+
+
 # =========================================================================
 # Platform ABC — OS foundation, drop in an OS so devices can speak to it
 # =========================================================================
@@ -599,6 +642,21 @@ class Platform(ABC):
         """
         del on_suspend, on_resume  # default: no-op stub, subclasses override
 
+    def build_metrics_loop(self, trcc: Any) -> MetricsLoop:
+        """Construct the OS-appropriate `MetricsLoop` for this host.
+
+        Default returns a thread-based `PollingMetricsLoop` — works on
+        every OS today. Override per-OS for native event sources
+        (e.g. WindowsPlatform → WMI events, MacOSPlatform → IOReport).
+        Devices stay thin: they consume `update_metrics()` calls without
+        caring which mechanism produced them.
+
+        ``trcc`` is the host whose ``lcd_devices`` / ``led_devices`` /
+        ``events`` / ``settings`` / ``system_svc`` the loop reads.
+        """
+        from ..services.metrics_loop import PollingMetricsLoop
+        return PollingMetricsLoop(trcc)
+
     def resolve_assets_dir(self, pkg_assets_dir: Any) -> Any:
         """Resolve GUI assets directory. Non-Linux copies to user dir."""
         return pkg_assets_dir

{trcc_linux-9.6.1 → trcc_linux-9.6.2}/src/trcc/core/trcc.py

@@ -2,7 +2,9 @@
 
 The one class every UI talks to. Composes LCDCommands, LEDCommands,
 ControlCenterCommands, and an EventBus. Holds discovered devices.
-Owns the metrics tick loop, data extraction pipeline, and hotplug.
+Owns lifecycle for the injected `MetricsLoop` (started by `discover`,
+stopped by `cleanup` and OS suspend), data extraction pipeline, and
+hotplug.
 
 Parity rule: every method reachable from one UI is reachable from all
 three. No shortcuts, no UI-specific extensions. See TRCC_CONTRACT.md.
@@ -45,13 +47,10 @@ if TYPE_CHECKING:
     from .device.lcd import LCDDevice
     from .device.led import LEDDevice
     from .models import DetectedDevice, DeviceInfo
-    from .ports import EnsureDataFn, Platform, Renderer
+    from .ports import EnsureDataFn, MetricsLoop, Platform, Renderer
 
 log = logging.getLogger(__name__)
 
-# Animation tick rate — 50ms gives 20 FPS for video and overlay updates.
-_TICK_INTERVAL = 0.05
-
 
 class Trcc:
     """Universal command facade and process context.
@@ -67,9 +66,8 @@ class Trcc:
     __slots__ = (
         '_current_metrics', '_download_pack_fn', '_ensure_data_fn',
         '_lcd_devices', '_led_devices', '_list_available_fn',
-        '_metrics_stop', '_metrics_thread', '_metrics_wake',
-        '_platform', '_renderer', '_settings', '_system_svc',
-        'control_center', 'events', 'lcd', 'led',
+        '_metrics_loop', '_platform', '_renderer', '_settings',
+        '_system_svc', 'control_center', 'events', 'lcd', 'led',
     )
 
     def __init__(
@@ -105,16 +103,18 @@ class Trcc:
         self._lcd_devices: DeviceRegistry[LCDDevice] = DeviceRegistry()
         self._led_devices: DeviceRegistry[LEDDevice] = DeviceRegistry()
 
-        self._metrics_thread: threading.Thread | None = None
-        self._metrics_stop: threading.Event = threading.Event()
-        self._metrics_wake: threading.Event = threading.Event()
-
         self.events = EventBus()
         self.lcd = LCDCommands(self._lcd_devices, self.events, self._settings)
         self.led = LEDCommands(self._led_devices, self.events)
         self.control_center = ControlCenterCommands(
             platform, self.events, self._settings)
 
+        # The OS produces the metrics loop — fourth factory in the chain
+        # (Platform / Protocol / Device / MetricsLoop). Default is a
+        # thread-based PollingMetricsLoop; per-OS overrides plug in native
+        # event sources (WMI / IOReport) without touching Trcc.
+        self._metrics_loop: MetricsLoop = platform.build_metrics_loop(self)
+
         # Subscribe to OS suspend/resume so a sleeping machine doesn't leave
         # devices with stale USB handles after wake (issue #144).  Platform
         # default is a no-op; Linux uses logind's PrepareForSleep, other
@@ -343,6 +343,15 @@ class Trcc:
         if ensure_data:
             self._ensure_data_blocking()
 
+        # Start the underlying command stream now that devices are connected.
+        # Idempotent — safe across suspend/resume and hotplug. RuntimeError
+        # when SystemService is missing is tolerated so headless / smoke
+        # paths still report a successful discover.
+        try:
+            self._metrics_loop.start()
+        except RuntimeError:
+            log.warning('discover: metrics loop not started — SystemService missing')
+
         lcd_infos = [d.device_info for d in self._lcd_devices]
         led_infos = [d.device_info for d in self._led_devices]
         return DiscoveryResult(
@@ -491,98 +500,33 @@ class Trcc:
         """Most recently polled metrics with temp unit applied, or None."""
         return self._current_metrics
 
-    def start_metrics_loop(self, interval: float | None = None) -> None:
-        """Start the 50ms tick + sensor-poll loop in a background thread.
-
-        Two cadences in one thread:
-          * **Tick** (every 50ms): advance device animation, send frames,
-            publish ``frame`` events.
-          * **Poll** (every ``settings.refresh_interval``): read sensors,
-            update every device, publish ``metrics``.
+    def set_current_metrics(self, metrics: Any) -> None:
+        """Update the cached metrics snapshot.
 
-        UIs (GUI / CLI / API) subscribe to events — none run their own
-        tick loops.
+        Called by the injected `MetricsLoop` after every poll iteration,
+        and by :meth:`apply_temp_unit` when the user switches °C ↔ °F.
+        Public so the loop port stays decoupled from Trcc's private state.
         """
-        if self._system_svc is None:
-            raise RuntimeError(
-                'Trcc.start_metrics_loop: SystemService not injected. '
-                'Pass system_svc=… at construction or call set_system_service().')
-        self.stop_metrics_loop()
-        self._metrics_stop.clear()
-        sys_svc = self._system_svc
-
-        # Capture settings at loop start — bound through DI when available,
-        # falls back to the global lazily otherwise (Phase 10A.3 partial).
-        _settings = self.settings
+        self._current_metrics = metrics
+
+    @property
+    def system_svc(self) -> SystemService | None:
+        """The injected sensor read-out service (or None if not yet set).
 
-        def _loop() -> None:
-            from .models import HardwareMetrics
-            tick_count = 0
-            while not self._metrics_stop.is_set():
-                try:
-                    poll_interval = (
-                        interval if interval is not None
-                        else max(1, _settings.refresh_interval)
-                    )
-                    metrics_every = max(1, int(poll_interval / _TICK_INTERVAL))
-                    if tick_count % metrics_every == 0:
-                        try:
-                            metrics = HardwareMetrics.with_temp_unit(
-                                sys_svc.all_metrics, _settings.temp_unit)
-                            self._current_metrics = metrics
-                            for device in tuple(chain(
-                                self._lcd_devices, self._led_devices,
-                            )):
-                                try:
-                                    device.update_metrics(metrics)
-                                except Exception:
-                                    log.exception('Metrics update error')
-                            self.events.publish(Topic.METRICS, metrics)
-                        except Exception:
-                            log.exception('Metrics poll error')
-
-                    for device in tuple(self._lcd_devices):
-                        path = getattr(device, 'device_path', '?') or '?'
-                        try:
-                            if (result := device.tick()) is not None:
-                                self.events.publish(Topic.FRAME, path, result)
-                            elif device.playing:
-                                device.update_video_cache_text(self._current_metrics)
-                        except Exception:
-                            log.exception('LCD tick error: %s', path)
-                    for device in tuple(self._led_devices):
-                        info = device.device_info
-                        path = (getattr(info, 'path', '?') if info else '?') or '?'
-                        try:
-                            if (result := device.tick()) is not None:
-                                self.events.publish(Topic.FRAME, path, result)
-                        except Exception:
-                            log.exception('LED tick error: %s', path)
-                except Exception:
-                    log.exception('Tick loop error')
-                tick_count += 1
-                self._metrics_wake.wait(_TICK_INTERVAL)
-                self._metrics_wake.clear()
-
-        self._metrics_thread = threading.Thread(
-            target=_loop, daemon=True, name='trcc-metrics')
-        self._metrics_thread.start()
-        log.debug('Metrics loop started (tick=%.0fms, poll=settings.refresh_interval)',
-                  _TICK_INTERVAL * 1000)
-
-    def stop_metrics_loop(self) -> None:
-        """Stop the background metrics loop. Idempotent."""
-        self._metrics_stop.set()
-        self._metrics_wake.set()
-        if self._metrics_thread and self._metrics_thread.is_alive():
-            self._metrics_thread.join(timeout=3)
-        self._metrics_thread = None
-        self._metrics_wake.clear()
-        self._metrics_stop.clear()
+        Exposed so the injected `MetricsLoop` can poll metrics without
+        reaching into Trcc's private state. Updated by
+        :meth:`set_system_service` for the test/dev fixture chain.
+        """
+        return self._system_svc
 
     def wake_metrics_loop(self) -> None:
-        """Wake the metrics loop immediately — used after settings changes."""
-        self._metrics_wake.set()
+        """Force an immediate poll iteration — used after settings changes.
+
+        Delegates to the injected `MetricsLoop.wake()`. Kept as a method
+        on Trcc so callers (control center commands) don't reach into
+        the loop directly.
+        """
+        self._metrics_loop.wake()
 
     # ── Cross-cutting OS operations (touch every device + the loop) ──
 
@@ -651,6 +595,7 @@ class Trcc:
         """
         from ..adapters.device.factory import DeviceProtocolFactory
         self.events.publish(Topic.SYSTEM_SUSPENDED)
+        self._metrics_loop.stop()
         for dev in self:
             try:
                 dev.cleanup()
@@ -680,7 +625,7 @@ class Trcc:
         close instead of reaching into ``DeviceProtocolFactory.close_all``.
         """
         from ..adapters.device.factory import DeviceProtocolFactory
-        self.stop_metrics_loop()
+        self._metrics_loop.stop()
         for dev in self:
             try:
                 dev.cleanup()

{trcc_linux-9.6.1 → trcc_linux-9.6.2}/src/trcc/daemon.py

@@ -2,7 +2,8 @@
 
 One process per user. Built once, lives until SIGTERM/SIGINT or the
 user runs ``trcc daemon stop``. Holds the singleton `Trcc`, discovers
-devices, runs the metrics loop (Phase 9 wires that in), and serves
+devices, runs the per-process `MetricsLoop` (started by
+`Trcc.discover()` after device enumeration — issue #148), and serves
 `Command` requests over the Unix socket through `IPCServer`.
 
 Singleton enforcement is socket-presence: the first invocation that