trcc-linux 9.7.5__tar.gz → 9.7.6__tar.gz

{trcc_linux-9.7.5 → trcc_linux-9.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 9.7.5
+Version: 9.7.6
 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
@@ -182,6 +182,8 @@ Then **unplug and replug the USB cable** and run `trcc gui`.
 
 > `pipx` not installed? `sudo apt install pipx` (Debian/Ubuntu), `sudo dnf install pipx` (Fedora), `sudo pacman -S python-pipx` (Arch). See the **[Install Guide](doc/GUIDE_INSTALL.md)** for your distro.
 
+> **NVIDIA GPU metrics?** The app detects your card and offers to install the sensor reader on first launch (it installs into your environment automatically). To add it upfront instead: `pipx install "trcc-linux[nvidia]"`.
+
 ### Automatic (git clone)
 
 ```bash
@@ -308,7 +310,7 @@ Set the angle to **90°** (or 270°) in the GUI, then open **Cloud Themes** —
 | **Multi-device** | Per-device config, auto-detect, multi-device with device selection |
 | **Security** | udev rules, polkit policy, SELinux support, no root required after setup |
 
-**Under the hood**: 147 source files, ~49K lines of Python, 5799 tests across 96 test files in 9 directories. Hexagonal architecture with strict dependency injection — GUI, CLI, and API all talk to the same core services. 6 USB protocols reverse-engineered from the Windows C# app.
+**Under the hood**: 223 source files, ~71K lines of Python, 1783 tests across 104 test files. Hexagonal architecture with strict dependency injection — GUI, CLI, and API all talk to the same core services. 6 USB protocols reverse-engineered from the Windows C# app.
 
 ### What we do better than Windows TRCC
 

{trcc_linux-9.7.5 → trcc_linux-9.7.6}/README.md

@@ -108,6 +108,8 @@ Then **unplug and replug the USB cable** and run `trcc gui`.
 
 > `pipx` not installed? `sudo apt install pipx` (Debian/Ubuntu), `sudo dnf install pipx` (Fedora), `sudo pacman -S python-pipx` (Arch). See the **[Install Guide](doc/GUIDE_INSTALL.md)** for your distro.
 
+> **NVIDIA GPU metrics?** The app detects your card and offers to install the sensor reader on first launch (it installs into your environment automatically). To add it upfront instead: `pipx install "trcc-linux[nvidia]"`.
+
 ### Automatic (git clone)
 
 ```bash
@@ -234,7 +236,7 @@ Set the angle to **90°** (or 270°) in the GUI, then open **Cloud Themes** —
 | **Multi-device** | Per-device config, auto-detect, multi-device with device selection |
 | **Security** | udev rules, polkit policy, SELinux support, no root required after setup |
 
-**Under the hood**: 147 source files, ~49K lines of Python, 5799 tests across 96 test files in 9 directories. Hexagonal architecture with strict dependency injection — GUI, CLI, and API all talk to the same core services. 6 USB protocols reverse-engineered from the Windows C# app.
+**Under the hood**: 223 source files, ~71K lines of Python, 1783 tests across 104 test files. Hexagonal architecture with strict dependency injection — GUI, CLI, and API all talk to the same core services. 6 USB protocols reverse-engineered from the Windows C# app.
 
 ### What we do better than Windows TRCC
 

{trcc_linux-9.7.5 → trcc_linux-9.7.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trcc-linux"
-version = "9.7.5"
+version = "9.7.6"
 description = "Linux implementation of Thermalright LCD Control Center"
 readme = "README.md"
 license = "GPL-3.0-or-later"

{trcc_linux-9.7.5 → trcc_linux-9.7.6}/src/trcc/__main__.py

@@ -100,7 +100,7 @@ if sys.platform == 'win32':
 
 try:
     # Auto-launch GUI when invoked as trcc-gui.exe (windowed PyInstaller build)
-    if os.path.basename(sys.executable).lower().startswith('trcc-gui'):
+    if Path(sys.executable).name.lower().startswith('trcc-gui'):
         from trcc.ui.cli.main import gui
         sys.exit(gui() or 0)
     # Everything else goes through the shared entry so python -m trcc and

{trcc_linux-9.7.5 → trcc_linux-9.7.6}/src/trcc/__version__.py

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

{trcc_linux-9.7.5 → trcc_linux-9.7.6}/src/trcc/adapters/device/led.py

@@ -4,10 +4,12 @@ HID 64-byte report transport.  Shares the Type 2 DA/DB/DC/DD magic with
 HID LCD devices, but LED packets use cmd=2 with per-LED RGB payload.
 
 Payload shape passed to send():
-    LedPayload(colors=[(r,g,b), ...], is_on=None, global_on=True, brightness=100)
+    LedPayload(colors=[(r,g,b), ...], is_on=None, global_on=True)
 
-Color scaling matches FormLED.cs SendHidVal:
-    scaled = channel * (brightness/100) * 0.4
+Colours arrive already brightness-baked by the service layer
+(``led_effects.apply_brightness``).  The wire is pure transport — it
+applies only the FormLED hardware perceptual scale, never brightness:
+    scaled = channel * 0.4          # FormLED.cs SendHidVal, sans brightness
 """
 from __future__ import annotations
 
@@ -348,7 +350,6 @@ class Led(Device[BulkTransport]):
                     colors=remapped_colors,
                     is_on=remapped_is_on,
                     global_on=payload.global_on,
-                    brightness=payload.brightness,
                 )
 
         packet = self._build_packet(payload)
@@ -409,15 +410,17 @@ class Led(Device[BulkTransport]):
         payload_len = count * 3
         header = cls._build_header(payload_len)
 
-        brightness = max(0, min(100, payload.brightness)) / 100.0
+        # Pure transport: the colours arrive already brightness-baked by the
+        # service (apply_brightness); the wire applies only the FormLED
+        # hardware perceptual scale + the on/off mask, never brightness.
         body = bytearray(payload_len)
         for i, (r, g, b) in enumerate(payload.colors):
             on = payload.global_on and (
                 payload.is_on[i] if payload.is_on is not None else True
             )
             if on:
-                body[i * 3] = min(255, max(0, int(r * brightness * _COLOR_SCALE)))
-                body[i * 3 + 1] = min(255, max(0, int(g * brightness * _COLOR_SCALE)))
-                body[i * 3 + 2] = min(255, max(0, int(b * brightness * _COLOR_SCALE)))
+                body[i * 3] = min(255, max(0, int(r * _COLOR_SCALE)))
+                body[i * 3 + 1] = min(255, max(0, int(g * _COLOR_SCALE)))
+                body[i * 3 + 2] = min(255, max(0, int(b * _COLOR_SCALE)))
             # else: stays 0,0,0 (off)
         return header + bytes(body)

trcc_linux-9.7.6/src/trcc/adapters/diagnostics/adapter.py

@@ -0,0 +1,73 @@
+"""Concrete ``Diagnostics`` port — wraps the diagnostics functions.
+
+The health/doctor/debug-report/gpu-reader logic already lives as module-level
+functions that consume the ``Platform`` port.  This adapter binds them to one
+platform instance and exposes them through the core ``Diagnostics`` ABC, so core
+Commands + the quickstart service depend on the port, never on these modules.
+
+The probe functions are called **module-qualified** (``_health.foo()``) rather
+than imported by name so a test can ``monkeypatch.setattr`` the module attribute
+and have the adapter see it — the attribute resolves at call time.
+"""
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from ...core.diagnostics import DoctorResult, GpuReaderState, HealthReport
+from ...core.ports import Diagnostics, Platform
+from ..sensors import nvml as _nvml
+from . import debug_report as _debug_report
+from . import doctor as _doctor
+from . import health as _health
+
+log = logging.getLogger(__name__)
+
+
+class DiagnosticsAdapter(Diagnostics):
+    """Platform-bound diagnostics, exposed through the core port."""
+
+    def __init__(self, platform: Platform) -> None:
+        self._platform = platform
+
+    def health(self) -> HealthReport:
+        log.info("DiagnosticsAdapter.health")
+        return _health.run_health_checks(self._platform)
+
+    def doctor(self) -> DoctorResult:
+        log.info("DiagnosticsAdapter.doctor")
+        return _doctor.run_doctor(self._platform)
+
+    def render_doctor(self, report: HealthReport) -> str:
+        log.info("DiagnosticsAdapter.render_doctor: %d check(s)", len(report.checks))
+        return _doctor.render_doctor_output(report)
+
+    def debug_report(self, log_tail_lines: int) -> str:
+        log.info("DiagnosticsAdapter.debug_report: log_tail_lines=%d", log_tail_lines)
+        return _debug_report.build_debug_report(
+            self._platform, log_tail_lines=log_tail_lines,
+        ).render_text()
+
+    def write_debug_report(self, rendered: str, path: Path) -> Path:
+        log.info("DiagnosticsAdapter.write_debug_report: path=%s", path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(rendered, encoding="utf-8")
+        return path
+
+    def package_manager(self) -> str | None:
+        pm = _health.detect_package_manager()
+        log.info("DiagnosticsAdapter.package_manager: %s", pm)
+        return pm
+
+    def gpu_reader_state(self) -> GpuReaderState:
+        reader_installed, initialized, _ = _nvml.nvml_init_state()
+        present = _health.nvidia_gpu_present()
+        log.info(
+            "DiagnosticsAdapter.gpu_reader_state: present=%s installed=%s init=%s",
+            present, reader_installed, initialized,
+        )
+        return GpuReaderState(
+            nvidia_present=present,
+            reader_installed=reader_installed,
+            initialized=initialized,
+        )

{trcc_linux-9.7.5 → trcc_linux-9.7.6}/src/trcc/adapters/diagnostics/doctor.py

@@ -7,27 +7,15 @@ sit on top of the same ``HealthCheckResult`` data.
 from __future__ import annotations
 
 import logging
-from dataclasses import dataclass
 
+from ...core.diagnostics import DoctorResult, HealthReport
 from ...core.ports import Platform
-from .health import HealthReport, run_health_checks
+from .health import run_health_checks
 
 log = logging.getLogger(__name__)
 
-
-@dataclass(frozen=True, slots=True)
-class DoctorResult:
-    """What the doctor decided.
-
-    ``exit_code`` is 0 when nothing FAILed, 1 otherwise — wraps the
-    standard "broken / not broken" CLI convention so scripts can branch.
-    """
-    report: HealthReport
-    exit_code: int
-
-    @property
-    def is_healthy(self) -> bool:
-        return self.exit_code == 0
+# ``DoctorResult`` moved to ``core.diagnostics`` (pure data); re-exported here.
+__all__ = ["DoctorResult", "render_doctor_output", "run_doctor"]
 
 
 def run_doctor(platform: Platform) -> DoctorResult:

{trcc_linux-9.7.5 → trcc_linux-9.7.6}/src/trcc/adapters/diagnostics/health.py

@@ -21,48 +21,26 @@ import logging
 import shutil
 import subprocess
 import sys
-from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Literal
 
+from ...core.diagnostics import HealthCheckResult, HealthReport, Severity
 from ...core.ports import Paths, Platform
 from ..sensors.nvml import NVML_RELOAD_HINT, nvml_init_state
 
 log = logging.getLogger(__name__)
 
-
-Severity = Literal["OK", "WARN", "FAIL"]
-
-
-@dataclass(frozen=True, slots=True)
-class HealthCheckResult:
-    """One check's outcome — name, severity, message, optional fix hint."""
-    name: str
-    severity: Severity
-    message: str
-    fix_hint: str = ""
-
-
-@dataclass(frozen=True, slots=True)
-class HealthReport:
-    """The full set of checks plus a one-line summary."""
-    checks: list[HealthCheckResult] = field(default_factory=list)
-
-    @property
-    def worst_severity(self) -> Severity:
-        if any(c.severity == "FAIL" for c in self.checks):
-            return "FAIL"
-        if any(c.severity == "WARN" for c in self.checks):
-            return "WARN"
-        return "OK"
-
-    @property
-    def fail_count(self) -> int:
-        return sum(1 for c in self.checks if c.severity == "FAIL")
-
-    @property
-    def warn_count(self) -> int:
-        return sum(1 for c in self.checks if c.severity == "WARN")
+# DTOs moved to ``core.diagnostics`` (pure data the Diagnostics port speaks);
+# re-exported here so existing ``from ...health import HealthReport`` keeps working.
+__all__ = [
+    "HealthCheckResult",
+    "HealthReport",
+    "Severity",
+    "detect_package_manager",
+    "nvidia_gpu_present",
+    "package_install_hint",
+    "quick_subprocess",
+    "run_health_checks",
+]
 
 
 # =========================================================================

{trcc_linux-9.7.5 → trcc_linux-9.7.6}/src/trcc/adapters/infra/sysinfo_config.py

@@ -62,10 +62,10 @@ _PANEL_ROW_BINDINGS: dict[tuple[int, int], str] = {
     (3, 1): "memory:percent",
     (3, 2): "memory:used",
     (3, 3): "memory:available",
-    # Disk panel (category_id=4) — ``disk:0:temp`` requires SMART; aggregator
-    # currently doesn't ship a SMART source, so the row stays unbound until
-    # a SmartDisk source lands.
-    (4, 0): "disk:0:temp",
+    # Disk panel (category_id=4) — ``disk:temp`` is the hottest drive's temp,
+    # published by the per-OS DiskSource (Linux hwmon nvme/drivetemp, Windows
+    # LHM storage).  Boxes whose drives expose no temp sensor stay unbound (--).
+    (4, 0): "disk:temp",
     (4, 1): "disk:activity",
     (4, 2): "disk:read",
     (4, 3): "disk:write",

{trcc_linux-9.7.5 → trcc_linux-9.7.6}/src/trcc/adapters/render/qt.py

@@ -380,6 +380,24 @@ class QtRenderer(Renderer):
         ).copy()  # .copy() detaches from input buffer
         return qimg.convertToFormat(QImage.Format.Format_ARGB32)
 
+    # ── Fonts ─────────────────────────────────────────────────────────
+
+    def list_fonts(self) -> list[str]:
+        """Enumerate installed font families via the Qt font database.
+
+        ``__init__`` already brought up a ``QGuiApplication`` (so
+        ``QFontDatabase.families()`` won't abort the process); call the
+        idempotent guard again defensively, then read the families.
+        """
+        _ensure_qt_app()
+        try:
+            families = sorted(QFontDatabase.families())
+        except RuntimeError as e:
+            log.warning("QtRenderer.list_fonts: QFontDatabase error: %s", e)
+            return []
+        log.info("QtRenderer.list_fonts: %d families", len(families))
+        return families
+
     # ── Convenience: QPixmap export for GUI preview ───────────────────
 
     @staticmethod

{trcc_linux-9.7.5 → trcc_linux-9.7.6}/src/trcc/adapters/repo/data_install.py

@@ -35,7 +35,7 @@ from typing import Protocol
 
 from ...core._safe import is_safe_zip_member
 from ...core.errors import HttpFetchError, TrccError
-from ...core.ports import HttpFetcher
+from ...core.ports import DataInstaller, HttpFetcher
 
 log = logging.getLogger(__name__)
 
@@ -120,11 +120,11 @@ class SevenZipExtractor:
 
 
 # =========================================================================
-# DataInstaller — public adapter, DI'd into the service layer
+# HttpDataInstaller — concrete DataInstaller port, DI'd into the service layer
 # =========================================================================
 
 
-class DataInstaller:
+class HttpDataInstaller(DataInstaller):
     """Downloads + extracts per-resolution archives from GitHub.
 
     Construct with an ``HttpFetcher`` (the existing adapter from

{trcc_linux-9.7.5 → trcc_linux-9.7.6}/src/trcc/adapters/sensors/_lhm.py

@@ -28,7 +28,7 @@ from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
-from ...core.ports import CpuSource, GpuSource
+from ...core.ports import CpuSource, DiskSource, GpuSource
 
 log = logging.getLogger(__name__)
 
@@ -56,6 +56,7 @@ _TYPE_DATA = "Data"              # MemUsed/MemAvailable in GB
 # helper matches via ``startswith("Gpu")``.
 _HW_CPU = "Cpu"
 _HW_GPU_PREFIX = "Gpu"
+_HW_STORAGE = "Storage"
 
 
 def _probe_wmi_namespace() -> Any:
@@ -586,3 +587,86 @@ def discover_lhm_gpus(
     except Exception:
         log.debug("LHM GPU enumeration failed", exc_info=True)
     return out
+
+
+# =========================================================================
+# LhmDisk — one per LHM-detected Storage row (NVMe / SATA SSD / HDD)
+# =========================================================================
+
+
+class LhmDisk(DiskSource):
+    """Storage temperature via LHM — one per ``Storage`` Hardware row.
+
+    LHM's storage tree (``HardwareType == "Storage"``) carries a
+    ``Temperature`` sensor per drive — the same WMI shape as the GPU
+    temp, so this is :class:`LhmGpu`'s temperature path narrowed to the
+    one reading the model's ``disk_temp`` slot needs.  Returns ``None``
+    when LHM isn't running or the drive has no temp sensor yet.
+    """
+
+    def __init__(
+        self,
+        hardware_identifier: str,
+        display_name: str,
+        *,
+        handle_factory: Callable[[], Any] = _default_handle_factory,
+    ) -> None:
+        # Defer the handle to first read (born on the reading thread's
+        # apartment, #131); identity is the apartment-agnostic LHM identifier.
+        self._handle_factory = handle_factory
+        self._id = hardware_identifier
+        self._display_name = display_name
+
+    @property
+    def key(self) -> str:
+        # LHM storage identifiers look like "/nvme/0" or "/hdd/0" — flatten to
+        # a stable per-drive key ("lhm:nvme:0").
+        ident = self._id.lower().lstrip("/").replace("/", ":")
+        return f"lhm:{ident}"
+
+    @property
+    def name(self) -> str:
+        return self._display_name
+
+    def _row(self, ns: Any) -> Any | None:
+        if ns is None:
+            return None
+        try:
+            rows = list(ns.Hardware(Identifier=self._id))
+        except Exception:
+            return None
+        return rows[0] if rows else None
+
+    def temp(self) -> float | None:
+        ns = self._handle_factory()
+        if (row := self._row(ns)) is None:
+            return None
+        return _max_value(_sensors_for(ns, row, _TYPE_TEMP))
+
+
+def discover_lhm_disks(
+    *,
+    handle_factory: Callable[[], Any] = _default_handle_factory,
+) -> list[DiskSource]:
+    """Enumerate storage devices LHM is currently reporting on.
+
+    Returns ``[]`` when LHM isn't running.  The aggregator folds the hottest
+    into ``disk:temp``; multiple drives each get their own source.
+    """
+    log.info("discover_lhm_disks: called")
+    ns = handle_factory()
+    if ns is None:
+        return []
+    out: list[DiskSource] = []
+    try:
+        for hw in ns.Hardware():
+            if str(hw.HardwareType) != _HW_STORAGE:
+                continue
+            out.append(LhmDisk(
+                hardware_identifier=str(hw.Identifier),
+                display_name=str(hw.Name),
+                handle_factory=handle_factory,
+            ))
+    except Exception:
+        log.debug("LHM disk enumeration failed", exc_info=True)
+    return out

{trcc_linux-9.7.5 → trcc_linux-9.7.6}/src/trcc/adapters/sensors/aggregator.py

@@ -7,7 +7,7 @@ the normalized keys overlays use:
     gpu:primary:temp | gpu:0:temp | gpu:nvidia:0:temp | gpu:amd:0:temp
     memory:used | memory:available | memory:total | memory:percent
     fan:cpu:rpm | fan:gpu:percent | fan:<key>:rpm
-    disk:read | disk:write | disk:activity
+    disk:temp | disk:read | disk:write | disk:activity
     net:up | net:down | net:total_up | net:total_down
     time:{hour,minute,second} | date:{year,month,day,dow}
 
@@ -28,6 +28,7 @@ from contextlib import AbstractContextManager, nullcontext
 from ...core.models import MIN_REFRESH_INTERVAL_S, SensorReading
 from ...core.ports import (
     CpuSource,
+    DiskSource,
     FanSource,
     GpuSource,
     MemorySource,
@@ -36,6 +37,7 @@ from ...core.ports import (
 from .hwmon import (
     HwmonCpu,
     discover_amd_gpus,
+    discover_disk_temp,
     discover_fans,
     discover_intel_gpus,
     find_cpu_temp_device,
@@ -88,6 +90,7 @@ def _gpu_reading_keys(prefix: str) -> list[tuple[str, str, str]]:
 
 def _io_keys() -> list[tuple[str, str, str]]:
     return [
+        ("disk:temp", "temperature", "°C"),
         ("disk:read", "disk_io", "MB/s"),
         ("disk:write", "disk_io", "MB/s"),
         ("disk:activity", "disk_io", "%"),
@@ -125,12 +128,14 @@ class BaselineSensors(SensorEnumerator):
                  memory: MemorySource | None = None,
                  gpus: list[GpuSource] | None = None,
                  fans: list[FanSource] | None = None,
+                 disks: list[DiskSource] | None = None,
                  thread_context: Callable[[], AbstractContextManager[None]]
                      = nullcontext) -> None:
         self._cpu = cpu or PsutilCpu()
         self._memory = memory or PsutilMemory()
         self._gpus: list[GpuSource] = gpus if gpus is not None else discover_nvidia_gpus()
         self._fans: list[FanSource] = fans or []
+        self._disks: list[DiskSource] = disks or []
         # Per-thread OS setup the poll thread enters before touching OS
         # sensor APIs (Windows → COM apartment for WMI; others → no-op).
         # Injected as a narrow callable so this OS-neutral aggregator never
@@ -352,6 +357,16 @@ class BaselineSensors(SensorEnumerator):
             _store(r, f"fan:{fan.key}:percent",
                    self._read(fan.percent, f"fan:{fan.key}:percent"))
 
+        # Disk temperature — one DiskSource per drive; the model carries a
+        # single ``disk_temp`` slot, so collapse to the HOTTEST drive (the one
+        # most likely to throttle), mirroring cpu_temp = hottest socket.
+        disk_temps = [
+            t for disk in self._disks
+            if (t := self._read(disk.temp, f"disk:{disk.key}:temp")) is not None
+        ]
+        if disk_temps:
+            _store(r, "disk:temp", max(disk_temps))
+
         # IO + time
         try:
             self._io.poll(r)
@@ -399,8 +414,9 @@ def build_linux_sensors() -> BaselineSensors:
     gpus.extend(discover_amd_gpus(hwmon_devices))
     gpus.extend(discover_intel_gpus(hwmon_devices))
     fans = discover_fans(hwmon_devices)
-    log.info("Linux sensors: cpu_temp=%s, gpus=%d, fans=%d",
+    disks = discover_disk_temp(hwmon_devices)
+    log.info("Linux sensors: cpu_temp=%s, gpus=%d, fans=%d, disks=%d",
              "yes" if cpu.temp() is not None else "no",
-             len(gpus), len(fans))
+             len(gpus), len(fans), len(disks))
     return BaselineSensors(cpu=cpu, memory=PsutilMemory(),
-                           gpus=gpus, fans=fans)
+                           gpus=gpus, fans=fans, disks=disks)

{trcc_linux-9.7.5 → trcc_linux-9.7.6}/src/trcc/adapters/sensors/hwmon.py

@@ -24,7 +24,7 @@ import threading
 import time
 from pathlib import Path
 
-from ...core.ports import CpuSource, FanSource, GpuSource
+from ...core.ports import CpuSource, DiskSource, FanSource, GpuSource
 from .psutil_sources import PsutilCpu
 
 log = logging.getLogger(__name__)
@@ -461,3 +461,47 @@ def discover_fans(devices: list[HwmonDevice]) -> list[FanSource]:
             label = _read_text(dev.path / f"fan{idx}_label")
             fans.append(HwmonFan(dev, idx, label))
     return fans
+
+
+# ── Disk temperature (NVMe / SATA SSD/HDD via the drivetemp module) ──
+
+# hwmon drivers that expose a storage-device temperature: the kernel ``nvme``
+# driver (NVMe Composite temp at temp1) and ``drivetemp`` (SATA SSD/HDD SMART
+# temperature, modprobe drivetemp).  One physical drive per device → read the
+# primary temp1 only (NVMe's temp2/temp3 are extra on-controller sensors of the
+# SAME drive; the model carries one disk_temp, so the composite is the number).
+_DISK_DRIVERS = ("nvme", "drivetemp")
+
+
+class HwmonDisk(DiskSource):
+    """One storage device's temp1 sensor on a hwmon ``nvme`` / ``drivetemp`` node."""
+
+    def __init__(self, hwmon: HwmonDevice, label: str | None) -> None:
+        self._hwmon = hwmon
+        self._label = label or f"{hwmon.driver} disk"
+
+    @property
+    def key(self) -> str:
+        return f"hwmon:{self._hwmon.driver}:temp1"
+
+    @property
+    def name(self) -> str:
+        return self._label
+
+    def temp(self) -> float | None:
+        return self._hwmon.read_temp(1)
+
+
+def discover_disk_temp(devices: list[HwmonDevice]) -> list[DiskSource]:
+    """One :class:`HwmonDisk` per ``nvme`` / ``drivetemp`` device with a temp1."""
+    log.info("discover_disk_temp: devices=%d", len(devices))
+    disks: list[DiskSource] = []
+    for dev in devices:
+        if dev.driver not in _DISK_DRIVERS:
+            continue
+        if dev.read_temp(1) is None:
+            log.debug("discover_disk_temp: %s has no temp1_input — skip", dev.driver)
+            continue
+        label = _read_text(dev.path / "temp1_label")
+        disks.append(HwmonDisk(dev, label))
+    return disks

{trcc_linux-9.7.5 → trcc_linux-9.7.6}/src/trcc/adapters/sensors/windows.py

@@ -18,7 +18,7 @@ from contextlib import AbstractContextManager, nullcontext
 
 from ...core.ports import CpuSource, GpuSource
 from ._hwinfo import HwinfoCpu, discover_hwinfo_gpus
-from ._lhm import LhmCpu, discover_lhm_gpus
+from ._lhm import LhmCpu, discover_lhm_disks, discover_lhm_gpus
 from ._msacpi import WmiAcpiCpu
 from ._wmi_gpu import discover_wmi_gpus
 from .aggregator import BaselineSensors
@@ -46,9 +46,11 @@ def build_windows_sensors(
         PsutilCpu(),
     ])
     gpus = _build_windows_gpu_chains()
-    log.info("Windows sensors: cpu chain ready, gpus=%d", len(gpus))
+    disks = discover_lhm_disks()
+    log.info("Windows sensors: cpu chain ready, gpus=%d, disks=%d",
+             len(gpus), len(disks))
     return BaselineSensors(
-        cpu=cpu, memory=PsutilMemory(), gpus=gpus, fans=[],
+        cpu=cpu, memory=PsutilMemory(), gpus=gpus, fans=[], disks=disks,
         thread_context=thread_context,
     )
 

{trcc_linux-9.7.5 → trcc_linux-9.7.6}/src/trcc/adapters/system/linux.py

@@ -169,7 +169,7 @@ def _resolve_scsi_path(vid: int, pid: int) -> str | None:
 def _walk_sysfs_for_vid_pid(start: Path) -> tuple[int, int] | None:
     """Walk up sysfs parents until we find idVendor + idProduct files."""
     log.debug("_walk_sysfs_for_vid_pid: start=%s", start)
-    path = Path(os.path.realpath(start))
+    path = Path(start).resolve()
     for _ in range(10):
         path = path.parent
         vid_file = path / "idVendor"
@@ -528,6 +528,10 @@ class LinuxPlatform(Platform):
         pkg = _LINUX_INSTALL_PKGS.get(tool, tool)
         return package_install_hint(pkg)
 
+    def permission_denied_hint(self) -> str:
+        log.debug("LinuxPlatform.permission_denied_hint: called")
+        return "run 'trcc system setup' to install udev rules"
+
     def no_devices_hint(self) -> str:
         log.debug("LinuxPlatform.no_devices_hint: called")
         return (

{trcc_linux-9.7.5 → trcc_linux-9.7.6}/src/trcc/adapters/system/macos.py

@@ -202,6 +202,11 @@ class MacOSPlatform(Platform):
             return f"Install {tool} and ensure it is on PATH"
         return f"{tool} not found — install it:\n  {hint}"
 
+    def permission_denied_hint(self) -> str:
+        log.debug("MacOSPlatform.permission_denied_hint: called")
+        return ("try running with sudo, or check System Settings → "
+                "Privacy & Security → Files and Folders")
+
     def no_devices_hint(self) -> str:
         log.debug("no_devices_hint: called")
         return (

{trcc_linux-9.7.5 → trcc_linux-9.7.6}/src/trcc/adapters/system/windows.py

@@ -482,6 +482,10 @@ class WindowsPlatform(Platform):
             return f"Install {tool} and ensure it is on PATH"
         return f"{tool} not found — install it:\n  {hint}"
 
+    def permission_denied_hint(self) -> str:
+        log.debug("WindowsPlatform.permission_denied_hint: called")
+        return "install the WinUSB driver via 'trcc system setup'"
+
     def no_devices_hint(self) -> str:
         log.debug("no_devices_hint: called")
         return (