feat: standardize power on cpu / gpu / total across every platform

Retire power.pkg and report the same three power metrics on every platform, the
way btop/mactop/top do:
- power.cpu   — CPU (RAPL package on Linux, IOReport CPU on macOS)
- power.gpu   — GPU
- power.total — whole machine (cpu+gpu+npu, or the SMC whole-system total on Apple)

Fixes AMD APUs under-counting and the busy-GPU-hidden-behind-a-tiny-package
headline. Top view and host detail both show CPU / GPU / total. power.cpu says
why it's missing where there's no source (GB10 no RAPL, Windows no RAPL). Per-core
CPU keeps rendering in the top view; cpu.cores now also carries the per-core avg.

Author: kinncj

CHANGELOG.md

@@ -7,6 +7,23 @@ and the project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [Unreleased]
 
+### Changed
+- **Standardized power on three metrics everywhere: `power.cpu`, `power.gpu`,
+  `power.total`** — the same CPU / GPU / total split btop, mactop, and top show.
+  `power.pkg` is retired; the CPU rail is always `power.cpu`:
+  - **Linux**: `power.cpu` = the RAPL **package** (whole CPU socket — what btop
+    calls "CPU"); the unreliable RAPL `core` subdomain is dropped.
+  - **macOS**: `power.cpu` = IOReport CPU; `power.total` = SMC `PSTR`
+    (whole-system) — the SMC figure is no longer mislabelled `power.pkg`.
+  - `power.total` = `cpu + gpu + npu` on every non-Apple host (Apple already
+    reports a whole-system total). This fixes **AMD APUs (Strix Halo)**
+    under-counting: RAPL package and amdgpu are separate rails and are now summed
+    (matching btop's CPU + GPU).
+- Both the **top view** and the **host detail view** now show CPU, GPU, and total
+  power.
+- `power.cpu` is reported Unavailable-with-reason where no source exists: GB10
+  (no RAPL on Grace/ARM) and Windows (RAPL inaccessible).
+
 ## [2.2.9] - 2026-07-01
 
 ### Added

app/cmd/helper/main.go

@@ -102,7 +102,7 @@ func demoMetrics(context.Context) []domain.Metric {
 	return []domain.Metric{
 		{Name: "power.cpu", Unit: "watts", Status: domain.StatusOK, Gauge: 8.4},
 		{Name: "power.gpu", Unit: "watts", Status: domain.StatusOK, Gauge: 3.1},
-		{Name: "power.pkg", Unit: "watts", Status: domain.StatusOK, Gauge: 12.7},
+		{Name: "power.total", Unit: "watts", Status: domain.StatusOK, Gauge: 11.5},
 		{Name: "gpu.util", Unit: "percent", Status: domain.StatusOK, Gauge: 41},
 		{Name: "gpu.vram", Unit: "percent", Status: domain.StatusOK, Gauge: 36},
 		{Name: "gpu.temp", Unit: "celsius", Status: domain.StatusOK, Gauge: 54},

app/internal/adapters/cpu.go

@@ -36,7 +36,7 @@ func (CPU) Collect(ctx context.Context) ([]domain.Metric, error) {
 	if len(per) > 0 {
 		out = append(out, domain.Metric{
 			Name: "cpu.cores", Unit: "percent", Status: domain.StatusOK,
-			Kind: domain.KindPerCore, PerCore: per,
+			Kind: domain.KindPerCore, Gauge: avg, PerCore: per,
 		})
 	}
 	return out, nil

app/internal/adapters/helper.go

@@ -36,7 +36,7 @@ type Helper struct {
 func (Helper) Describe() domain.AdapterInfo {
 	return domain.AdapterInfo{
 		ID:                "privileged",
-		Metrics:           []string{"power.pkg", "power.cpu", "power.gpu", "power.npu", "gpu.util", "gpu.vram", "gpu.temp", "gpu.clock", "gpu.mem.util", "gpu.fan", "npu.util"},
+		Metrics:           []string{"power.total", "power.cpu", "power.gpu", "power.npu", "gpu.util", "gpu.vram", "gpu.temp", "gpu.clock", "gpu.mem.util", "gpu.fan", "npu.util"},
 		RequiresPrivilege: true,
 	}
 }
@@ -62,7 +62,7 @@ func (h Helper) Collect(ctx context.Context) ([]domain.Metric, error) {
 		return ms, nil
 	}
 	return []domain.Metric{
-		{Name: "power.pkg", Status: domain.StatusInsufficientPermission, Detail: "needs helper"},
+		{Name: "power.cpu", Status: domain.StatusInsufficientPermission, Detail: "needs helper"},
 		{Name: "gpu.util", Status: domain.StatusInsufficientPermission, Detail: "needs helper"},
 	}, nil
 }

app/internal/adapters/helper_test.go

@@ -22,7 +22,7 @@ func TestHelperAdapterNeedsHelperWhenAbsent(t *testing.T) {
 	a := Helper{
 		Client: absentClient(t),
 		Direct: func(context.Context) []domain.Metric {
-			return []domain.Metric{{Name: "power.pkg", Status: domain.StatusUnavailable}}
+			return []domain.Metric{{Name: "power.cpu", Status: domain.StatusUnavailable}}
 		},
 	}
 	ms, err := a.Collect(context.Background())
@@ -33,7 +33,7 @@ func TestHelperAdapterNeedsHelperWhenAbsent(t *testing.T) {
 	for _, m := range ms {
 		got[m.Name] = m.Status
 	}
-	for _, name := range []string{"power.pkg", "gpu.util"} {
+	for _, name := range []string{"power.cpu", "gpu.util"} {
 		if got[name] != domain.StatusInsufficientPermission {
 			t.Errorf("%s status = %v, want insufficient_permission", name, got[name])
 		}
@@ -47,7 +47,7 @@ func TestHelperAdapterUsesDirectWhenPrivileged(t *testing.T) {
 		Client: absentClient(t),
 		Direct: func(context.Context) []domain.Metric {
 			return []domain.Metric{
-				{Name: "power.pkg", Unit: "W", Status: domain.StatusOK, Gauge: 12.5},
+				{Name: "power.cpu", Unit: "W", Status: domain.StatusOK, Gauge: 12.5},
 				{Name: "gpu.util", Unit: "%", Status: domain.StatusOK, Gauge: 40},
 			}
 		},
@@ -60,8 +60,8 @@ func TestHelperAdapterUsesDirectWhenPrivileged(t *testing.T) {
 	for _, m := range ms {
 		got[m.Name] = m
 	}
-	if got["power.pkg"].Status != domain.StatusOK || got["power.pkg"].Gauge != 12.5 {
-		t.Errorf("power.pkg = %+v, want 12.5W ok", got["power.pkg"])
+	if got["power.cpu"].Status != domain.StatusOK || got["power.cpu"].Gauge != 12.5 {
+		t.Errorf("power.cpu = %+v, want 12.5W ok", got["power.cpu"])
 	}
 	if got["gpu.util"].Status != domain.StatusOK || got["gpu.util"].Gauge != 40 {
 		t.Errorf("gpu.util = %+v, want 40%% ok", got["gpu.util"])
@@ -82,7 +82,7 @@ func (f fakeMetricClient) Collect(context.Context) ([]domain.Metric, error) { re
 func TestHelperEmptyReplyFallsBackToDirect(t *testing.T) {
 	a := Helper{
 		Client: fakeMetricClient{ms: []domain.Metric{
-			{Name: "power.pkg", Status: domain.StatusInsufficientPermission, Detail: "needs helper"},
+			{Name: "power.cpu", Status: domain.StatusInsufficientPermission, Detail: "needs helper"},
 			{Name: "gpu.util", Status: domain.StatusInsufficientPermission, Detail: "needs helper"},
 		}},
 		Direct: func(context.Context) []domain.Metric {
@@ -110,15 +110,15 @@ func TestHelperOKReplyIsUsedWithoutDirect(t *testing.T) {
 	directRan := false
 	a := Helper{
 		Client: fakeMetricClient{ms: []domain.Metric{
-			{Name: "power.pkg", Unit: "W", Status: domain.StatusOK, Gauge: 15},
+			{Name: "power.cpu", Unit: "W", Status: domain.StatusOK, Gauge: 15},
 		}},
 		Direct: func(context.Context) []domain.Metric { directRan = true; return nil },
 	}
 	ms, _ := a.Collect(context.Background())
 	if directRan {
 		t.Fatal("Direct must not run when the helper already has ok metrics")
 	}
-	if len(ms) != 1 || ms[0].Name != "power.pkg" || ms[0].Status != domain.StatusOK {
-		t.Fatalf("want helper power.pkg ok, got %+v", ms)
+	if len(ms) != 1 || ms[0].Name != "power.cpu" || ms[0].Status != domain.StatusOK {
+		t.Fatalf("want helper power.cpu ok, got %+v", ms)
 	}
 }

app/internal/domain/registry_test.go

@@ -121,15 +121,15 @@ func TestNonOKStatusPreserved(t *testing.T) {
 	r := NewRegistry(time.Second)
 	r.Register(okAdapter("gpu", []string{"gpu.util"},
 		Metric{Name: "gpu.util", Status: StatusUnavailable, Detail: "no NVIDIA GPU"}))
-	r.Register(okAdapter("power", []string{"power.pkg"},
-		Metric{Name: "power.pkg", Status: StatusInsufficientPermission, Detail: "needs helper"}))
+	r.Register(okAdapter("power", []string{"power.cpu"},
+		Metric{Name: "power.cpu", Status: StatusInsufficientPermission, Detail: "needs helper"}))
 
 	got := metricsByName(r.Collect(context.Background()))
 	if got["gpu.util"].Status != StatusUnavailable {
 		t.Errorf("Unavailable coerced: %+v", got["gpu.util"])
 	}
-	if got["power.pkg"].Status != StatusInsufficientPermission {
-		t.Errorf("InsufficientPermission coerced: %+v", got["power.pkg"])
+	if got["power.cpu"].Status != StatusInsufficientPermission {
+		t.Errorf("InsufficientPermission coerced: %+v", got["power.cpu"])
 	}
 }
 

app/internal/fake/fleet.go

@@ -174,9 +174,16 @@ func metricsFor(h *spec) []domain.Metric {
 		ms = append(ms, domain.Metric{Name: "gpu.util", Status: domain.StatusUnavailable, Detail: "no GPU"})
 	}
 	if h.hasPower {
-		ms = append(ms, domain.Metric{Name: "power.pkg", Unit: "watts", Status: domain.StatusOK, Gauge: h.pwr})
+		ms = append(ms, domain.Metric{Name: "power.cpu", Unit: "watts", Status: domain.StatusOK, Gauge: h.pwr, Detail: "CPU package"})
+		total := h.pwr
+		if h.hasGPU {
+			gpuW := h.pwr * 1.5 // demo: a busy GPU pulls more than the CPU package
+			ms = append(ms, domain.Metric{Name: "power.gpu", Unit: "watts", Status: domain.StatusOK, Gauge: gpuW})
+			total += gpuW
+		}
+		ms = append(ms, domain.Metric{Name: "power.total", Unit: "watts", Status: domain.StatusOK, Gauge: total, Detail: "system total"})
 	} else {
-		ms = append(ms, domain.Metric{Name: "power.pkg", Status: domain.StatusInsufficientPermission, Detail: "needs helper"})
+		ms = append(ms, domain.Metric{Name: "power.cpu", Status: domain.StatusInsufficientPermission, Detail: "needs helper"})
 	}
 	return ms
 }

app/internal/helper/collect.go

@@ -39,21 +39,13 @@ func PrivilegedMetrics(ctx context.Context) []domain.Metric {
 	out = mergeByName(out, linuxPrivileged(ctx))
 	// Windows privileged sources (WMI thermal zones); no-op off Windows.
 	out = mergeByName(out, windowsPrivileged(ctx))
-	// gpuSeparate marks the GPU as its own power rail (a discrete card, or the GB10
-	// superchip where the Blackwell GPU is metered apart from the Grace CPU). Only
-	// nvidia-smi reports such a rail here; an integrated GPU (Apple, AMD APU) is
-	// already inside the CPU package, so its power must not be added to the total.
-	gpuSeparate := false
 	if nv, present, err := runNvidiaSMI(ctx); present {
 		if err != nil {
 			// nvidia-smi is installed but broke (e.g. driver/library mismatch after
 			// an un-rebooted driver upgrade) — surface why instead of blanking GPU.
 			out = mergeByName(out, nvidiaErrorMetrics(nv))
 		} else {
 			ms := parseNvidiaSMI(nv)
-			if hasName(ms, "power.gpu") {
-				gpuSeparate = true
-			}
 			// Unified-memory NVIDIA (GB10 Grace-Blackwell) has no aggregate VRAM
 			// counter — nvidia-smi memory.* reads [N/A]. Derive gpu.vram from the
 			// per-process compute-apps memory over the system RAM total.
@@ -73,38 +65,30 @@ func PrivilegedMetrics(ctx context.Context) []domain.Metric {
 	// only add names not already set, so an NVIDIA or Apple reading is never
 	// shadowed, and a non-AMD host contributes nothing.
 	out = mergeByName(out, amdGPU(ctx))
-	out = withTotalPower(out, runtime.GOOS, gpuSeparate)
+	out = withTotalPower(out)
 	out = ensureNPUUtil(out)
 	if !hasOK(out) {
 		return []domain.Metric{
-			{Name: "power.pkg", Status: domain.StatusUnavailable, Detail: "no power source"},
+			{Name: "power.cpu", Status: domain.StatusUnavailable, Detail: "no power source"},
 			{Name: "gpu.util", Status: domain.StatusUnavailable, Detail: "no gpu source"},
 		}
 	}
 	return out
 }
 
-// withTotalPower appends a source-aware power.total so the panel can headline
-// real whole-machine draw instead of just the CPU package. It must never
-// double-count: Apple's power.pkg is SMC PSTR (already whole-system), and an
-// integrated GPU is already inside the CPU package — only a separate GPU rail
-// (discrete NVIDIA, or the GB10 Grace+Blackwell split) is added.
-func withTotalPower(ms []domain.Metric, goos string, gpuSeparate bool) []domain.Metric {
-	pkg, hasPkg := okGauge(ms, "power.pkg")
-	gpu, hasGPU := okGauge(ms, "power.gpu")
-	npu, _ := okGauge(ms, "power.npu")
-	var total float64
-	switch {
-	case goos == "darwin":
-		total = pkg // SMC PSTR is already whole-system
-	case gpuSeparate:
-		total = pkg + gpu + npu // CPU package + a discrete/superchip GPU rail
-	default:
-		total = pkg // integrated GPU is already counted inside the package
-		if !hasPkg && hasGPU {
-			total = gpu
-		}
+// withTotalPower appends the whole-machine power.total so the panel can headline
+// real draw. On Apple it is already provided directly (SMC PSTR is whole-system),
+// so this leaves it untouched. Everywhere else power.cpu (the RAPL package) and
+// power.gpu are physically separate rails — the same split btop/top show — so the
+// total is their sum plus any NPU rail.
+func withTotalPower(ms []domain.Metric) []domain.Metric {
+	if hasName(ms, "power.total") {
+		return ms
 	}
+	cpu, _ := okGauge(ms, "power.cpu")
+	gpu, _ := okGauge(ms, "power.gpu")
+	npu, _ := okGauge(ms, "power.npu")
+	total := cpu + gpu + npu
 	if total <= 0 {
 		return ms
 	}
@@ -138,11 +122,11 @@ func powerMetric(name string, w float64) domain.Metric {
 
 // assembleApplePower builds the macOS power/util metrics from the available
 // sources. Per-domain CPU/GPU/ANE power and GPU utilisation come from the
-// IOReport energy counters when present. Package power has a strict precedence:
-// SMC PSTR ("System Total Power") first, then powermetrics, then the IOReport
-// per-domain sum as a last resort. The ordering matters: on Apple Silicon
-// Pro/Max chips IOReport reports 0 for CPU/ANE and only a sub-watt GPU figure,
-// so the energy-sum is a phantom — it must never shadow a real SMC or
+// IOReport energy counters when present. The whole-system total has a strict
+// precedence: SMC PSTR ("System Total Power") first, then powermetrics, then the
+// IOReport per-domain sum as a last resort. The ordering matters: on Apple
+// Silicon Pro/Max chips IOReport reports 0 for CPU/ANE and only a sub-watt GPU
+// figure, so the energy-sum is a phantom — it must never shadow a real SMC or
 // powermetrics reading. pm is the parsed powermetrics output (may be nil).
 func assembleApplePower(cpu, gpu, ane, gpuUtil float64, ioOK bool, smcPkg float64, smcOK bool, pm []domain.Metric) []domain.Metric {
 	var out []domain.Metric
@@ -160,16 +144,16 @@ func assembleApplePower(cpu, gpu, ane, gpuUtil float64, ioOK bool, smcPkg float6
 			out = append(out, domain.Metric{Name: "gpu.util", Unit: "percent", Status: domain.StatusOK, Gauge: gpuUtil})
 		}
 	}
-	// SMC PSTR is the authoritative whole-system figure and needs no root.
+	// SMC PSTR is the authoritative whole-system total and needs no root.
 	if smcOK && smcPkg > 0 {
-		out = append(out, powerMetric("power.pkg", smcPkg))
+		out = append(out, powerMetric("power.total", smcPkg))
 	}
-	// powermetrics fills any name not already set (package when SMC is absent,
+	// powermetrics fills any name not already set (the total when SMC is absent,
 	// plus CPU/GPU/util gaps).
 	out = mergeByName(out, pm)
 	// Last resort: the IOReport per-domain sum, only when nothing better gave a
-	// package figure.
-	if !hasName(out, "power.pkg") {
+	// whole-system figure.
+	if !hasName(out, "power.total") {
 		sum := 0.0
 		if ioOK {
 			for _, w := range []float64{cpu, gpu, ane} {
@@ -179,7 +163,7 @@ func assembleApplePower(cpu, gpu, ane, gpuUtil float64, ioOK bool, smcPkg float6
 			}
 		}
 		if sum > 0 {
-			out = append(out, powerMetric("power.pkg", sum))
+			out = append(out, powerMetric("power.total", sum))
 		}
 	}
 	// Apple Silicon is unified memory — there is no discrete VRAM to read. Report

app/internal/helper/collect_linux.go

@@ -9,85 +9,31 @@ import (
 	"context"
 	"os"
 	"path/filepath"
-	"strings"
 	"time"
 
 	"heimdall/app/internal/domain"
 )
 
-// linuxPrivileged reads CPU power/temperature from RAPL and hwmon. power.pkg is
-// the whole CPU package (cores + uncore) and power.cpu is the cores alone — both
-// are the CPU socket only; a discrete GPU is a separate rail (power.gpu), which
-// is why on a workstation power.pkg can read far below power.gpu. Any source may
-// be absent (no powercap, no core subdomain, no trusted sensor); whatever is
-// found is returned and the rest is omitted, so an unsupported host degrades to
-// the Unavailable fallback rather than failing.
+// linuxPrivileged reads CPU power from RAPL and package temperature from hwmon.
+// power.cpu is the RAPL package (the whole CPU socket — cores + uncore), which is
+// what btop/top report as "CPU power". The GPU is a separate rail (power.gpu) and
+// the two are summed into power.total upstream. When the SoC exposes no RAPL at
+// all (e.g. GB10 Grace/ARM), power.cpu is reported Unavailable-with-reason rather
+// than left blank; a trusted temp sensor is added when present.
 func linuxPrivileged(ctx context.Context) []domain.Metric {
 	var out []domain.Metric
 	if w, ok := raplPackageWatts(ctx); ok {
-		out = append(out, domain.Metric{Name: "power.pkg", Unit: "watts", Status: domain.StatusOK, Gauge: w, Detail: "CPU package"})
+		out = append(out, domain.Metric{Name: "power.cpu", Unit: "watts", Status: domain.StatusOK, Gauge: w, Detail: "CPU package"})
 	} else if len(raplDomainDirs()) == 0 {
 		// No powercap tree at all — the SoC exposes no RAPL (e.g. GB10 Grace/ARM).
-		// Say so rather than leaving CPU power a silent blank.
-		out = append(out, domain.Metric{Name: "power.pkg", Status: domain.StatusUnavailable, Detail: "no RAPL power sensor (SoC/ARM)"})
-	}
-	if w, ok := raplCoreWatts(ctx); ok {
-		out = append(out, domain.Metric{Name: "power.cpu", Unit: "watts", Status: domain.StatusOK, Gauge: w, Detail: "CPU cores"})
+		out = append(out, domain.Metric{Name: "power.cpu", Status: domain.StatusUnavailable, Detail: "no RAPL power sensor (SoC/ARM)"})
 	}
 	if c, ok := hwmonPackageTemp(); ok {
 		out = append(out, domain.Metric{Name: "temp.pkg", Unit: "celsius", Status: domain.StatusOK, Gauge: c})
 	}
 	return out
 }
 
-// isCoreDomain reports whether a RAPL domain name is the CPU-core (pp0) subdomain
-// that maps to power.cpu — as opposed to the package, uncore, dram, or psys.
-func isCoreDomain(name string) bool {
-	return strings.TrimSpace(name) == "core"
-}
-
-// raplCoreWatts samples the RAPL "core" subdomain to report CPU-core power as
-// power.cpu, distinct from the package power.pkg. It is absent on CPUs that do
-// not expose the core subdomain, in which case power.cpu simply stays unset.
-func raplCoreWatts(ctx context.Context) (float64, bool) {
-	path, ok := raplCoreEnergyPath()
-	if !ok {
-		return 0, false
-	}
-	e0, err := readMicrojoules(path)
-	if err != nil {
-		return 0, false
-	}
-	const window = 200 * time.Millisecond
-	select {
-	case <-time.After(window):
-	case <-ctx.Done():
-		return 0, false
-	}
-	e1, err := readMicrojoules(path)
-	if err != nil {
-		return 0, false
-	}
-	w := raplWatts(e0, e1, window)
-	return w, w > 0
-}
-
-// raplCoreEnergyPath locates the energy counter of the RAPL "core" subdomain,
-// matching by the domain's name file rather than by index.
-func raplCoreEnergyPath() (string, bool) {
-	for _, d := range raplDomainDirs() {
-		name, err := os.ReadFile(filepath.Join(d, "name"))
-		if err != nil || !isCoreDomain(string(name)) {
-			continue
-		}
-		ep := filepath.Join(d, "energy_uj")
-		if _, err := os.Stat(ep); err == nil {
-			return ep, true
-		}
-	}
-	return "", false
-}
-
 // raplDomainDirs returns the RAPL domain directories, preferring the intel-rapl
 // tree (present on both Intel and most AMD kernels) and falling back to the
 // generic powercap tree.