@@ -78,6 +78,8 @@ A multinode master row with `cpu-power: true` beside `power: true` adds srt-slur
 
 The package then carries `power/cpu/samples.csv` in srt-slurm's wide format (one row per scrape, host, and Grace socket; two sockets per worker host in the manifest topology), and the aggregate adds `cpu_power_valid`, `avg_cpu_socket_power_w`, `avg_total_cpu_power_w`, and `total_cpu_energy_j` from the `CPU<n>:cpuSidePowerUsageW` series, plus `avg_total_cpu_rail_power_w` / `total_cpu_rail_energy_j` (ACPI `CPU Power Socket N`, cores only) and `avg_total_cpu_sysio_power_w` / `total_cpu_sysio_energy_j` (ACPI `SysIO Power Socket N`), each pair only when every socket reports that rail without gaps. The meters nest ([NVIDIA Grace power guide](https://docs.nvidia.com/dccpu/grace-perf-tuning-guide/power-thermals.html)): `Grace Power Socket N` is the whole socket (CPU rail, SysIO rail, LPDDR5X, and regulator loss) and the two rails are a breakdown inside it, so never add them to or subtract them from the total; a GB300 socket reads about 97 W while its rails sum to about 55 W. The DRAM rail is blank on the CI NVL72 firmware. srt-slurm v2.59.0+ writes NVML superchip module power as `module_w` (CPU samples schema v3) when its exporter can load NVML (the aarch64 glibc build, srt-slurm #609), and the aggregate then publishes `avg_total_module_power_w` / `total_module_energy_j` under the same every-socket, gap-free rule; the module includes both GPUs, so never add it to the CPU or GPU totals. Every series is integrated over the bound formal GPU window with the GPU leg's trapezoid, boundary interpolation, and 3.0 s gap limit; the sidecar's `cpu` block, mirrored as `power_audit.cpu`, records `sensor_kind: grace_socket`, `source`, socket and row counts, and reason codes. A valid GPU leg also publishes `workers[]`: one entry per worker per host (`role`, the manifest's `worker_idx`, `hosts` holding that one host, `num_gpus`, `avg_power_w`), so a worker spanning trays repeats its index once per host and can be modeled per tray; it is omitted when a GPU belongs to two workers.
 
+A native single-node fixed-sequence row with `cpu-power: true` adds the same leg. Single-node rows have no `power` field because their native points always measure GPU power; eval-only and acceptance-gate jobs bind no CPU exporter. RAPL clusters (`mi300x-amd`, `mi325x-amd`, `mi355x-amds`) read each AMD EPYC package as `CPU<n>:packagePowerUsageW` and publish the three headline CPU keys with `sensor_kind: rapl_package` and no rail keys. RAPL `energy_uj` counters are root-only, so a job that binds a RAPL exporter adds a host-setup command that gives the job user each top-level counter and a teardown that returns them to root. A failed grant only warns, so the CPU leg is then judged by the verdict below; a cancelled job skips teardown, and a failed restore shows up only in the job's `logs/host_teardown_<node>.out`.
+
 The CPU verdict is independent of `power_valid`: a failed leg records `cpu_power_valid: 0` with no CPU keys and leaves every GPU field unchanged. It fails the job only when power is required (`REQUIRE_POWER=1`, or always on AgentX lanes whose launcher validates power) and the row set `cpu-power`; missing CPU artifacts are then a verdict (`cpu_artifacts_missing`) rather than silence. Other reason codes: `cpu_samples_missing`, `cpu_samples_header_mismatch`, `cpu_samples_malformed`, `cpu_socket_count_mismatch` (also when a host reports only the DCGM CPU rail), `cpu_sample_gap_exceeded`, `cpu_window_not_bracketed`, `cpu_window_unavailable`, and the shared `non_finite_power_metric`.
 
 Every power result, valid or invalid, carries `power_metric_schema_version`. Version 2 defines each unprefixed `joules_per_*` field as whole-deployment GPU-board energy over the named denominator; role-scoped energy uses the explicit `prefill_*` / `decode_*` keys. Rows without the field predate the whole-deployment switch and their unprefixed joules are not comparable across topologies.
 
@@ -101,6 +101,7 @@ env:
   SALLOC_TIME_LIMIT: '480'
   IS_MULTINODE: 'false'
   REQUIRE_POWER: ${{ inputs.require-power && '1' || '0' }}
+  CPU_POWER: ${{ fromJSON(inputs.config)['cpu-power'] && '1' || '0' }}
   RANDOM_RANGE_RATIO: 0.8
   HF_TOKEN: ${{ secrets.INFERENCEX_OFFICIAL_RO_HF_TOKEN }}
   HF_HUB_CACHE: '/mnt/hf_hub_cache/'
 
@@ -87,7 +87,7 @@ recipe and master settings; the recipe still owns the native configuration.
 
 Active recipes, fixed-sequence and AgentX, single- and multi-node, are fragments: native srt-slurm YAML holding only recipe-specific settings. At launch the fragment is composed and bound:
 
-1. The lane's shared block in [`configs/srt-recipes/`](../../../configs/srt-recipes) (`fixed-sequence-{single,multi}.yaml` or `agentic.yaml`) is merged under the fragment (under `base` for bundles). A multi-node row with `power: true` also gets [`telemetry-dcgm.yaml`](../../../configs/srt-recipes/telemetry-dcgm.yaml), its exporter on the cluster's `srt-slurm.power-exporter-port`; the lane must allow power (`POWER_LANES`). The fragment wins: mappings merge and lists replace, so a fragment may keep telemetry tunables such as `collector_join_timeout_seconds`. Native single-node benchmarks also get [`telemetry-native.yaml`](../../../configs/srt-recipes/telemetry-native.yaml) before variant selection. That block enables best-effort power collection with the cluster's `default_gpu_exporter`; eval-only points omit collection. The binder sets `telemetry.required` from `REQUIRE_POWER`, so a single-node fragment may not set it, and gives AgentX clients matching power switches.
+1. The lane's shared block in [`configs/srt-recipes/`](../../../configs/srt-recipes) (`fixed-sequence-{single,multi}.yaml` or `agentic.yaml`) is merged under the fragment (under `base` for bundles). A multi-node row with `power: true` also gets [`telemetry-dcgm.yaml`](../../../configs/srt-recipes/telemetry-dcgm.yaml), its exporter on the cluster's `srt-slurm.power-exporter-port`; the lane must allow power (`POWER_LANES`). The fragment wins: mappings merge and lists replace, so a fragment may keep telemetry tunables such as `collector_join_timeout_seconds`. Native single-node benchmarks also get [`telemetry-native.yaml`](../../../configs/srt-recipes/telemetry-native.yaml) before variant selection. That block enables best-effort power collection with the cluster's `default_gpu_exporter`; eval-only points omit collection. A native single-node point on a cluster that declares `srt-slurm.cpu-power-exporter`, and a `cpu-power: true` row, also gets `telemetry.cpu_power_exporter` with that source. The binder sets `telemetry.required` from `REQUIRE_POWER`, so a single-node fragment may not set it, and gives AgentX clients matching power switches.
 2. The row's selector picks the variant. A single-node variant may name its `benchmark.env.CONC`, which keeps that concurrency paired with its tuning.
 3. The binder ([`workload.py`](../../../infx/srt_slurm/workload.py)) writes the matrix point into the selected recipe: `model.path: hf:<model>`, `model.container: <image>`, `model.precision`, `identity.container.image` (as a registry reference) and `identity.model.repo` when the fragment declares `identity.container`/`identity.model`, and `benchmark.concurrencies` when telemetry is enabled. Fixed-sequence recipes also get `benchmark.env.ISL`/`OSL`; single-node recipes get `MODEL` and `CONC`, and fixed-sequence ones `RANDOM_RANGE_RATIO` and `USE_CHAT_TEMPLATE` (`true` exactly when the recipe speculates). Multi-node AgentX recipes get the client's `RESULT_DIR`, `AIPERF_DATASET_MMAP_CACHE_DIR` and `HF_HUB_CACHE` from the launcher, which derives them from the volumes it mounts (`volume-mounts`, `agentic-volume-mounts`, lane mounts); a fragment that sets `HF_HOME` keeps its own cache. They also get `IS_MULTINODE: "true"` and `ENABLE_AGENTX_POWER`, `"1"` exactly when the launcher collects the point's AgentX power (a `power: true` row whose lane rule collects AgentX or adapter power) and `"0"` otherwise, and `REQUIRE_POWER`, `"1"` when the workflow requires power or the lane rule marks the point `require`, so the client fails a point whose power is invalid. The multi-node client reads `CONC_LIST`, `CONC`, `MODEL` and the other matrix inputs, prefill and decode topology included, from the job environment, so fragments do not copy them (`TP`, `PP_SIZE`, `PCP_SIZE` and `EP_SIZE` describe single-node points only); single-node AgentX points get them as runtime arguments.
 4. A component a repository setup script installs gets the master config's version. When `setup_script`, or a service `preamble` that runs `/configs/<script>`, is one of the installers in the binder's `INSTALLERS`, the binder writes the point's `router` or `kv-offload-backend` version as `ROUTER_VERSION` or `KV_OFFLOAD_BACKEND_VERSION` into the top-level `environment` (workers and static routers) or into that service's `env` (services do not inherit `environment`). A point that does not declare the version fails, and a `vllm-router==` pin in `SETUP_PIP_PACKAGES` must equal the master router version.
@@ -102,7 +102,7 @@ Inspect what the launcher submits without a cluster:
 uv run --extra recipes infx generate --config-key 'dsr1-fp8-h200-*' --output-dir /tmp/recipes
 ```
 
-It writes one bound recipe per fixed-sequence or AgentX point, validated by the pinned srtctl, plus a `manifest.json` that maps each file to its matrix point and to the one cluster its runner label schedules on (`null` when the label spans several). Multi-node points take their cluster's binder inputs (DCGM exporter port, AgentX client env); a point that needs them fails unless its runner label names one cluster and the lane accepts the row's `power`. Native single-node points validate against each eligible cluster's exporter defaults while retaining cluster-independent recipe output. Fabric references take that cluster's facts; when the label spans several clusters they stay references. Launch-time edits such as the job name, health-check floor and runtime `--set` values are not applied.
+It writes one bound recipe per fixed-sequence or AgentX point, validated by the pinned srtctl, plus a `manifest.json` that maps each file to its matrix point and to the one cluster its runner label schedules on (`null` when the label spans several). Multi-node points take their cluster's binder inputs (DCGM exporter port, AgentX client env); a point that needs them fails unless its runner label names one cluster and the lane accepts the row's `power`. Native single-node points validate against each eligible cluster's exporter defaults while retaining cluster-independent recipe output, except that a point whose runner label names one cluster takes that cluster's CPU exporter source, and a `cpu-power` point must name one. Fabric references take that cluster's facts; when the label spans several clusters they stay references. Launch-time edits such as the job name, health-check floor and runtime `--set` values are not applied.
 
 ## Recipe fingerprints
 
 
@@ -154,7 +154,7 @@ input.
 Notes:
 - The fields above are the common ones, not the full schema. The Pydantic models in [`infx/matrix/validation.py`](../infx/matrix/validation.py) are the authoritative contract; they also accept fields such as `spec-decoding`, `num-nodes`, `require-power` and `power`, and they reject any field they do not define, which fails matrix generation.
 - A multinode search-space entry with `power: true` measures DCGM power: its rows carry `power: true`, the launcher merges the shared telemetry block into the recipe and rejects lanes without a power rule.
-- A multinode entry with `cpu-power: true` beside `power: true` also measures CPU power: its rows carry `cpu-power: true` and the launcher binds the cluster's `cpu-power-exporter` record beside the DCGM block. Single-node entries cannot carry it.
+- A multinode entry with `cpu-power: true` beside `power: true` also measures CPU power: its rows carry `cpu-power: true` and the launcher binds the cluster's `cpu-power-exporter` record beside the DCGM block. Native single-node points measure CPU power by default on a cluster that declares a `cpu-power-exporter`; a single-node fixed-sequence entry sets `cpu-power: true` alone to count a missing CPU leg as invalid.
 - srt-slurm entries require `srt-recipe-dir`. Every row requires `srt-recipe: <file>[:<selector>]` under it (selector: `base`, `override_<name>` or `zip_override_<name>[<i>]`). Multinode rows may add `eval-srt-recipe`. Validation rejects missing files or variants, and `CONFIG_FILE`/`EVAL_CONFIG_FILE` settings. Only `llmd-vllm` keeps `CONFIG_FILE`. Generated rows carry the path from `inferencex-e2e/`.
 - Setting the fields above only guarantees that their values are passed as environment variables to benchmark scripts. Single-node jobs receive `PP_SIZE`, `DCP_SIZE`, and `PCP_SIZE`. Multinode jobs receive `PREFILL_PP_SIZE`, `PREFILL_DCP_SIZE`, `PREFILL_PCP_SIZE`, `DECODE_PP_SIZE`, `DECODE_DCP_SIZE`, and `DECODE_PCP_SIZE`. Actually using those variables is an implementation detail of the benchmark Bash script.
 
@@ -266,9 +266,10 @@ schema; unknown keys fail.
   volumes every job mounts to container paths, `mounts` does the same for host
   paths outside the volumes (devices), `agentic-volume-mounts` adds world-writable
   volumes for multi-node AgentX jobs, `power-exporter-port` is the DCGM exporter port
-  of power points, `cpu-power-exporter` (`source`) is the CPU power exporter a
-  `cpu-power` row binds beside it (`make setup` installs it from the pinned srt-slurm
-  release), `env` is the environment of the srt-slurm
+  of power points, `cpu-power-exporter` (`source: acpi` or `rapl`) is the CPU power exporter native
+  single-node points and `cpu-power` rows bind beside it (`make setup` installs it from the pinned srt-slurm
+  release; a RAPL job's host setup gives the job user the RAPL counters until teardown),
+  `env` is the environment of the srt-slurm
   launch, `container-aliases` and `nginx-aliases` name the recipe containers that
   resolve to the main image and to the staged nginx, and `outputs`,
   `shared-run-root` and `uv-cache-root` are the directories the srt-slurm launcher
 
@@ -107,6 +107,7 @@ dsr1-fp8-mi300x-sglang:
         conc-start: 4
         conc-end: 64
         srt-recipe: 8k1k.yaml
+        cpu-power: true
 
 dsr1-fp8-mi325x-sglang:
   image: lmsysorg/sglang:v0.5.22-rocm720-mi30x@sha256:58b6bc333f527c88fe5ff1b4bd8d17e82214eabcb3044549117159878967c930
@@ -126,6 +127,7 @@ dsr1-fp8-mi325x-sglang:
         conc-start: 4
         conc-end: 64
         srt-recipe: 8k1k.yaml
+        cpu-power: true
 
 dsr1-fp8-mi355x-sglang:
   image: lmsysorg/sglang:v0.5.22-rocm720-mi35x@sha256:c4b61360b251d62bb17da63f175d571ab22479eb46a144548d79f3ed3998ea11
@@ -170,6 +172,7 @@ dsr1-fp8-mi355x-sglang-mtp:
         conc-end: 64
         spec-decoding: mtp
         srt-recipe: 8k1k.yaml
+        cpu-power: true
 
 # MI355X FP8 AgentX, TP4 only. The grid follows the TP4 band of the B200 FP8
 # AgentX arm so the two SKUs are directly comparable point for point, with the
 
@@ -709,6 +709,7 @@ clusters:
         single-node-time-limit: 180
         gpus-per-node-directive: true
         segment-directive: false
+        cpu-power-exporter: {source: rapl}
         host-setup:
           script: runners/srt-slurm/hooks/mi300x-amd/setup.sh
         mounts:
@@ -758,6 +759,7 @@ clusters:
         single-node-time-limit: 480
         gpus-per-node-directive: true
         segment-directive: false
+        cpu-power-exporter: {source: rapl}
         mounts:
           /dev/kfd: /dev/kfd
           /dev/dri: /dev/dri
@@ -807,6 +809,7 @@ clusters:
         gpus-per-node-directive: true
         segment-directive: false
         outputs: /it-share/gharunners2/srt-slurm/outputs
+        cpu-power-exporter: {source: rapl}
         host-setup:
           script: runners/srt-slurm/hooks/mi355x-amds/setup.sh
           env:
 
@@ -13,7 +13,7 @@
 from pydantic import AfterValidator, Field, PlainSerializer, field_validator, model_validator
 
 from infx.clusters.base import Record, SchedulerSettings, Visibility, Volume
-from infx.srt_slurm.workload import resolve_fabric
+from infx.srt_slurm.workload import CpuPowerSource, resolve_fabric
 
 if TYPE_CHECKING:
     from infx.clusters import Cluster
@@ -174,13 +174,14 @@ def rendered(self) -> dict[str, str | None]:
 
 
 class CpuPowerExporter(Record):
-    """The Grace CPU power exporter srt-slurm scrapes on this cluster's compute trays.
+    """The CPU power exporter srt-slurm scrapes on this cluster's nodes.
 
     A point that selects ``cpu-power`` binds ``telemetry.cpu_power_exporter`` with this source.
-    Only ACPI serves the Grace socket meter the CPU leg integrates.
+    ACPI serves the Grace socket meter and RAPL the AMD EPYC package counter, the meters the
+    CPU leg integrates.
     """
 
-    source: Literal["acpi"]
+    source: CpuPowerSource
 
 
 class SrtSlurmSettings(Record):
 
@@ -69,12 +69,16 @@ def run_single_node(launch: Launch) -> int:
             step_mib, job_mib = None, 0
         if (options := config.srun_options(run.backend.settings, step_mib)) is not None:
             run.env["SRT_SRUN_OPTIONS"] = options
-        if rc := submit.bind_point(run, checkout, root / "arguments"):
+        native_power = not request.eval_only and not request.al_gate
+        cpu_source = config.cpu_power_source(
+            run.cluster, run.srt, native_power and request.cpu_power, default=native_power
+        )
+        if rc := submit.bind_point(run, checkout, root / "arguments", cpu_source):
             return rc
         selected, bound, runtime_args = submit.bound_arguments(root / "arguments")
         event.set(recipe=selected.removeprefix(f"{run.workspace}/"))
         containers = {}
-        if not request.eval_only and not request.al_gate:
+        if native_power:
             image, reference = config.stage_gpu_exporter(run, single_node=True)
             containers[image] = reference
         job_config = config.SrtJob(
@@ -90,10 +94,11 @@ def run_single_node(launch: Launch) -> int:
             single_node=True,
             account=run.account,
             mem_mib=job_mib,
+            cpu_power_source=cpu_source,
         )
         config.create_volume_mounts(run)
         config.write(checkout.root / "srtslurm.yaml", config.render(run.cluster, job_config))
-        if rc := run_setup(run, checkout):
+        if rc := run_setup(run, checkout, cpu_power_exporter=cpu_source is not None):
             return rc
 
     fetched = root / "fetched-outputs"
@@ -114,7 +119,7 @@ def run_single_node(launch: Launch) -> int:
     status = run.backend.state(job)
     with event.stage("collect"):
         logs = run.backend.fetch_outputs(job, fetched) / "logs"
-        if not request.eval_only and not request.al_gate:
+        if native_power:
             (logs / "power").mkdir(parents=True, exist_ok=True)
             (logs / "power/native-job-status.txt").write_text(f"{job.id}|{status.raw}\n")
         rc = collect.finalize_single_node_results(run, logs, checkout.commit)