feat: windows cpu power via LibreHardwareMonitor, explain the apple/detail dashes

Windows has no user-space RAPL — reading CPU energy MSRs needs a ring-0 driver
we don't ship (that's what Scaphandre/WinPowerMonitor install). So instead of
signing our own driver, read CPU power from LibreHardwareMonitor if it's running:
query its WMI provider for the CPU-package power sensor and report power.cpu
(Intel + AMD, no cgo). Absent, power.cpu says to run LHM.

Also stop the silent CPU blank on Apple Pro/Max: IOReport and powermetrics both
report 0 for the CPU/ANE channels there (verified on an M3 Max — powermetrics
prints "CPU Power: 0 mW" with the clusters pegged), so power.cpu now reads
"Pro/Max: no per-domain CPU power" and power.total still carries the SMC total.

The host detail view renders the unavailable reason next to the dash now, clamped
to width so a long reason can't wrap and break the panel.

Author: kinncj

CHANGELOG.md

@@ -7,6 +7,26 @@ and the project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [Unreleased]
 
+## [2.3.1] - 2026-07-01
+
+### Added
+- **Windows CPU power via LibreHardwareMonitor.** Windows exposes no RAPL to user
+  space (reading the CPU energy MSRs needs a ring-0 driver Heimdall doesn't ship).
+  When **LibreHardwareMonitor** is running, Heimdall now reads the CPU-package
+  power sensor from its WMI provider (`root/LibreHardwareMonitor`) and reports it
+  as `power.cpu` — Intel and AMD, no cgo. Absent, `power.cpu` reads
+  `no RAPL on Windows — run LibreHardwareMonitor for CPU power`.
+
+### Fixed
+- **Apple Pro/Max: `power.cpu` explains the dash.** On Pro/Max dies the CPU/ANE
+  power channels read 0 in *both* IOReport and powermetrics (only the SMC
+  whole-system total is real; base M-series expose the per-domain figure). Instead
+  of a silent blank, `power.cpu` now reads Unavailable with `Pro/Max: no per-domain
+  CPU power`. `power.total` still carries the real whole-machine draw.
+- **Host detail view now shows *why* a metric is dashed** — the Unavailable reason
+  (e.g. the CPU-power notes above) renders next to the dash, clamped to width so it
+  can't wrap or break the layout.
+
 ## [2.3.0] - 2026-07-01
 
 ### Changed

app/internal/helper/collect.go

@@ -166,6 +166,16 @@ func assembleApplePower(cpu, gpu, ane, gpuUtil float64, ioOK bool, smcPkg float6
 			out = append(out, powerMetric("power.total", sum))
 		}
 	}
+	// Apple Pro/Max SoCs expose no per-domain CPU power — IOReport and powermetrics
+	// both report 0 for the CPU/ANE channels (only the SMC whole-system total is
+	// real). Base M-series populate it. Say why rather than leaving power.cpu a
+	// silent blank; power.total still carries the real whole-machine figure.
+	if ioOK && !hasName(out, "power.cpu") {
+		out = append(out, domain.Metric{
+			Name: "power.cpu", Status: domain.StatusUnavailable,
+			Detail: "Pro/Max: no per-domain CPU power",
+		})
+	}
 	// Apple Silicon is unified memory — there is no discrete VRAM to read. Report
 	// gpu.vram as Unavailable-with-reason so the panel explains the dash instead
 	// of silently omitting the metric.

app/internal/helper/collect_windows.go

@@ -8,25 +8,56 @@ package helper
 import (
 	"context"
 	"os/exec"
+	"strconv"
 
 	"heimdall/app/internal/domain"
 )
 
-// windowsPrivileged reads CPU/zone temperature from WMI via PowerShell, matching
-// the helper's existing shell-out pattern (no new dependency). CPU power is not
-// available on Windows without a kernel driver (RAPL is inaccessible), so
-// power.cpu is reported Unavailable-with-reason; the GPU rail (nvidia-smi) still
-// comes through and power.total upstream is then the GPU alone.
+// windowsPrivileged reports CPU power and package temperature on Windows.
+//
+// Windows exposes no RAPL to user space — reading the CPU energy MSRs needs a
+// ring-0 driver, which Heimdall does not ship. So CPU power comes from a
+// driver-backed monitor the operator already runs: LibreHardwareMonitor publishes
+// CPU package power over WMI (root/LibreHardwareMonitor), which we read here (no
+// cgo, Intel + AMD). When it isn't running, power.cpu is Unavailable with a reason
+// pointing at how to enable it. Package temperature still comes from the ACPI
+// thermal zone via WMI.
 func windowsPrivileged(ctx context.Context) []domain.Metric {
-	out := []domain.Metric{{Name: "power.cpu", Status: domain.StatusUnavailable, Detail: "no CPU power counter on Windows (RAPL inaccessible)"}}
-	b, err := exec.CommandContext(ctx, "powershell", "-NoProfile", "-Command",
+	var out []domain.Metric
+	if w, ok := lhmCPUPackageWatts(ctx); ok {
+		out = append(out, domain.Metric{Name: "power.cpu", Unit: "watts", Status: domain.StatusOK, Gauge: w, Detail: "CPU package (LibreHardwareMonitor)"})
+	} else {
+		out = append(out, domain.Metric{Name: "power.cpu", Status: domain.StatusUnavailable, Detail: "no RAPL on Windows — run LibreHardwareMonitor for CPU power"})
+	}
+	if b, err := exec.CommandContext(ctx, "powershell", "-NoProfile", "-Command",
 		"Get-CimInstance -Namespace root/wmi -ClassName MSAcpi_ThermalZoneTemperature "+
-			"| Select-Object -ExpandProperty CurrentTemperature").Output()
+			"| Select-Object -ExpandProperty CurrentTemperature").Output(); err == nil {
+		if c, ok := parseThermalZoneCelsius(string(b)); ok {
+			out = append(out, domain.Metric{Name: "temp.pkg", Unit: "celsius", Status: domain.StatusOK, Gauge: c})
+		}
+	}
+	return out
+}
+
+// lhmCPUPackageWatts reads CPU package power from a running LibreHardwareMonitor
+// via its WMI provider. LHM ships a signed driver that reads the RAPL MSRs Windows
+// won't expose otherwise, and surfaces them as Sensor instances. Absent (0, false)
+// when LHM isn't running or exposes no CPU package power sensor.
+func lhmCPUPackageWatts(ctx context.Context) (float64, bool) {
+	out, err := exec.CommandContext(ctx, "powershell", "-NoProfile", "-Command",
+		"$s = Get-CimInstance -Namespace root/LibreHardwareMonitor -ClassName Sensor -ErrorAction SilentlyContinue "+
+			"| Where-Object { $_.SensorType -eq 'Power' -and $_.Name -like '*Package*' } "+
+			"| Select-Object -First 1 -ExpandProperty Value; if ($s) { $s }").Output()
 	if err != nil {
-		return out
+		return 0, false
 	}
-	if c, ok := parseThermalZoneCelsius(string(b)); ok {
-		out = append(out, domain.Metric{Name: "temp.pkg", Unit: "celsius", Status: domain.StatusOK, Gauge: c})
+	line := firstNonEmptyLine(string(out))
+	if line == "" {
+		return 0, false
 	}
-	return out
+	w, err := strconv.ParseFloat(line, 64)
+	if err != nil || w <= 0 {
+		return 0, false
+	}
+	return w, true
 }

app/internal/helper/smc_power_test.go

@@ -20,8 +20,10 @@ func TestAssembleApplePower_SMCWinsOverPhantomIOReport(t *testing.T) {
 	if m := got["power.gpu"]; m.Status != domain.StatusOK || m.Gauge != 0.1 {
 		t.Errorf("power.gpu = %+v, want 0.1W from IOReport", m)
 	}
-	if _, ok := got["power.cpu"]; ok {
-		t.Errorf("power.cpu should be absent when IOReport CPU energy is 0")
+	// Pro/Max exposes no per-domain CPU power (IOReport and powermetrics both read
+	// 0); say why rather than leaving a silent blank.
+	if m := got["power.cpu"]; m.Status != domain.StatusUnavailable || m.Detail == "" {
+		t.Errorf("power.cpu = %+v, want unavailable-with-reason on Pro/Max", m)
 	}
 	if m := got["gpu.util"]; m.Status != domain.StatusOK || m.Gauge != 5 {
 		t.Errorf("gpu.util = %+v, want 5%%", m)

app/internal/tui/dashboard/detail.go

@@ -236,7 +236,13 @@ func (m Model) detailBody(h domain.HostView, w int) []string {
 		lab := label.Style().Render(fmt.Sprintf("  %-6s", d.lab))
 		mm := pickMetric(byName, d.keys...)
 		if mm.Status != domain.StatusOK {
-			b.WriteString(lab + "  " + m.nonOK(mm) + "\n")
+			line := lab + "  " + m.nonOK(mm)
+			// Show why it's dashed (e.g. "Pro/Max: no per-domain CPU power") when
+			// there's room; the whole view is clamped to width, so it can't wrap.
+			if mm.Detail != "" && showDetail {
+				line += "  " + muted.Style().Render(mm.Detail)
+			}
+			b.WriteString(line + "\n")
 			continue
 		}
 		gauge := render.Gauge(m.mode, mm.Gauge, gaugeCells)

docs/guides/16-privileged-windows.md

@@ -32,12 +32,20 @@ and the GPU panel works **unprivileged** — same as
 **not** wired (the amdgpu sysfs path is Linux-only, and `amd-smi` parsing is not
 yet exercised on Windows).
 
-## CPU package power
+## CPU power
 
-`power.cpu` is **not available on Windows**. RAPL is reachable only through a
-signed kernel driver, which Heimdall does not ship — so CPU power stays
-`unavailable` rather than failing. This is a platform limit, not a
-misconfiguration.
+Windows exposes no RAPL to user space — reading the CPU energy MSRs needs a
+ring-0 driver, which Heimdall does not ship (that's exactly what tools like
+Scaphandre and WinPowerMonitor install). Rather than sign our own driver,
+Heimdall reads CPU power from a **driver-backed monitor you already run**:
+
+- **[LibreHardwareMonitor](https://github.com/LibreHardwareMonitor/LibreHardwareMonitor)**
+  — start it (its signed driver reads the RAPL MSRs on Intel **and** AMD) and
+  leave "Remote Web Server / WMI" enabled. Heimdall queries its WMI provider
+  (`root/LibreHardwareMonitor`) and reports the CPU-package sensor as `power.cpu`.
+
+When no such monitor is running, `power.cpu` reads `unavailable` with
+`no RAPL on Windows — run LibreHardwareMonitor for CPU power` rather than failing.
 
 ## How the helper works on Windows
 
@@ -53,7 +61,7 @@ daemon** can't. Here's what each Windows source needs:
 |---|---|---|
 | `nvidia-smi` (`gpu.util/vram/temp`, `power.gpu`) | normally **no** | richest panel on Windows when an NVIDIA GPU is present |
 | WMI `temp.pkg` (`MSAcpi_ThermalZoneTemperature`) | usually **yes** | only if the firmware exposes an ACPI thermal zone — many laptops don't |
-| `power.cpu` (RAPL) | — | **not available** on Windows, no driver |
+| `power.cpu` | no (reads WMI) | needs **LibreHardwareMonitor** running (its driver reads RAPL); else `unavailable` |
 
 `nvidia-smi` is normally unprivileged, so a daemon running as your user *should*
 collect the GPU panel without the helper. But account/PATH setups vary — don't