diff --git a/.github/AGENT_OPERATIONS.md b/.github/AGENT_OPERATIONS.md
index 93ff5ce300..86fadeb6c3 100644
--- a/.github/AGENT_OPERATIONS.md
+++ b/.github/AGENT_OPERATIONS.md
@@ -48,7 +48,7 @@ gh api -X POST \
   -f 'inputs[duration-override]='
 ```
 
-The top-level `ref` selects the workflow definition and is normally `main`. `inputs[ref]` selects the repository revision under test. Direct config dispatches set `inputs[generate-cli-command]` with paths relative to the selected checkout's `inferencex-e2e/` directory. Trusted changelog-driven dispatches instead set both `inputs[changelog-base-ref]` and `inputs[changelog-head-ref]`. `duration-override` replaces per-config seconds, and `require-power` makes invalid multi-node power telemetry fatal.
+The top-level `ref` selects the workflow definition and is normally `main`. `inputs[ref]` selects the repository revision under test. Direct config dispatches set `inputs[generate-cli-command]` with paths relative to the selected checkout's `inferencex-e2e/` directory. Trusted changelog-driven dispatches instead set both `inputs[changelog-base-ref]` and `inputs[changelog-head-ref]`. `duration-override` replaces per-config seconds, and `require-power` makes invalid power telemetry fatal for multi-node jobs and native single-node throughput and AgentX jobs; single-node matrix rows cannot set it.
 
 For AgentX preflight, add `-F 'inputs[agentx-fast]=true'`. Official runs use 10 warmup requests per lane and a one-hour profile.
 
@@ -68,15 +68,15 @@ Eval selection, the `--no-evals` / `--evals-only` / `--all-evals` flags, and cha
 
 ## Power telemetry
 
-Multinode srt-slurm results may include `power_valid`, `avg_power_w`, `avg_total_gpu_power_w`, `total_gpu_energy_j`, and joules per query/input/output/total token. Invalid telemetry records `power_valid: 0` without energy metrics and fails only with `REQUIRE_POWER=1`. Single-node results carry no power fields until srt-slurm telemetry covers those lanes.
+Multinode srt-slurm results, and single-node fixed-sequence and AgentX results with a retained native telemetry package, may include `power_valid`, `avg_power_w`, `avg_total_gpu_power_w`, `total_gpu_energy_j`, and joules per query/input/output/total token. Invalid telemetry records `power_valid: 0` without energy metrics and fails only with `REQUIRE_POWER=1`.
 
 Multinode disaggregated results add `prefill_gpu_energy_j`, `decode_gpu_energy_j`, `prefill_avg_power_w`, `decode_avg_power_w`, `prefill_joules_per_input_token`, and `decode_joules_per_output_token`. Role energy covers the full formal benchmark window, not kernel-level phases, and the role watts are that energy divided by the same window and by the role's GPU count.
 
 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.
 
-A multinode master row with `power: true` enables official energy collection: the launcher merges `inferencex-e2e/configs/srt-recipes/telemetry-dcgm.yaml` into its srt-slurm recipe. The Git submodule pointer at `inferencex-e2e/utils/srt-slurm` is the source of truth for every srt-slurm job, including TileRT. CI derives `POWER_PRODUCER_SHA` from the launcher stamp. The aggregate-power and AgentX power tests validate telemetry and provenance. These local tests do not prove hardware power collection. Eligible `dynamo-sglang` dcgm-power lanes are validated.
+A multinode master row with `power: true` enables official energy collection through the shared telemetry fragment; native single-node throughput and AgentX jobs enable telemetry through their bound recipe. Native single-node jobs inherit the exporter image, labels and metrics from the cluster's `default_gpu_exporter` in `inferencex-e2e/configs/runners.yaml`: DCGM on NVIDIA, the `kind: custom` AMD device-metrics-exporter on AMD. Multi-node power rows keep their shared DCGM telemetry block. Eval-only jobs omit collection. The Git submodule pointer at `inferencex-e2e/utils/srt-slurm` is the source of truth for every srt-slurm job, including TileRT. CI derives `POWER_PRODUCER_SHA` from the launcher stamp. The aggregate-power and AgentX power tests validate telemetry and provenance. These local tests do not prove hardware power collection. Eligible `dynamo-sglang` dcgm-power lanes are validated.
 
-Power audit artifacts are named `power_audit_<result>` and contain the multinode `power_validation_<result>_*.json` sidecars. They are uploaded even when validation fails.
+Power audit artifacts are named `power_audit_<result>` and contain the `power_validation*.json` sidecars plus, for native telemetry jobs, `LOGS/power/` (`samples.csv` v3 with `temperature_c`, `manifest.json`, `windows/`). They are uploaded even when validation fails.
 
 ## Result artifacts and metrics
 
diff --git a/.github/workflows/benchmark-tmpl.yml b/.github/workflows/benchmark-tmpl.yml
index 0a3e0c100b..b9b5eed3ee 100644
--- a/.github/workflows/benchmark-tmpl.yml
+++ b/.github/workflows/benchmark-tmpl.yml
@@ -75,6 +75,11 @@ on:
         required: false
         type: string
         default: ""
+      require-power:
+        description: "Fail result processing when GPU power telemetry is invalid"
+        type: boolean
+        required: false
+        default: false
 env:
   PYTHONPATH: ${{ github.workspace }}/inferencex-e2e
   INFERENCEX_E2E_ROOT: ${{ github.workspace }}
@@ -86,6 +91,7 @@ env:
   SALLOC_TIME_LIMIT: '480'
   KEEP_LOGS: '0'
   IS_MULTINODE: 'false'
+  REQUIRE_POWER: ${{ inputs.require-power && '1' || '0' }}
   RANDOM_RANGE_RATIO: 0.8
   HF_TOKEN: ${{ secrets.INFERENCEX_OFFICIAL_RO_HF_TOKEN }}
   HF_HUB_CACHE: '/mnt/hf_hub_cache/'
@@ -319,6 +325,10 @@ jobs:
             echo "no raw result to process: $RESULT_FILENAME.json" >&2
             exit 1
           fi
+          # A native power job's launcher stamp names the telemetry producer
+          if [ -f power-producer-sha.txt ]; then
+            export POWER_PRODUCER_SHA="$(cat power-producer-sha.txt)"
+          fi
           "$INFERENCEX_RESULTS_PYTHON" -P -m infx.results.fixed_sequence
 
       - name: Upload result
@@ -454,6 +464,23 @@ jobs:
             ${{ env.INFERENCEX_E2E_ROOT }}/srt-setup.log
           if-no-files-found: ignore
 
+      - name: Upload power audit bundle
+        if: ${{ always() && !inputs.eval-only }}
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: power_audit_${{ env.RESULT_FILENAME }}
+          path: |
+            ${{ env.INFERENCEX_E2E_ROOT }}/${{ env.RESULT_FILENAME }}.json
+            ${{ env.INFERENCEX_E2E_ROOT }}/agg_${{ env.RESULT_FILENAME }}.json
+            ${{ env.INFERENCEX_E2E_ROOT }}/power_validation_${{ env.RESULT_FILENAME }}.json
+            ${{ env.INFERENCEX_E2E_ROOT }}/results/agentic_power_timezone_offset.txt
+            ${{ env.INFERENCEX_E2E_ROOT }}/LOGS/power/**
+            ${{ env.INFERENCEX_E2E_ROOT }}/LOGS/agentic/**/agentic_power_concurrency_*.json
+            ${{ env.INFERENCEX_E2E_ROOT }}/LOGS/${{ env.RESULT_FILENAME }}.json
+            ${{ env.INFERENCEX_E2E_ROOT }}/power-producer-sha.txt
+            ${{ env.INFERENCEX_E2E_ROOT }}/exporter-image.sha256
+          if-no-files-found: ignore
+
       - name: Upload eval results (if any)
         id: upload-eval
         if: ${{ always() && (env.RUN_EVAL == 'true' || inputs.eval-only) }}
diff --git a/.github/workflows/e2e-tests.yml b/.github/workflows/e2e-tests.yml
index 1ad5121caa..556d856b39 100644
--- a/.github/workflows/e2e-tests.yml
+++ b/.github/workflows/e2e-tests.yml
@@ -395,6 +395,7 @@ jobs:
         secrets:
             INFERENCEX_OFFICIAL_RO_HF_TOKEN: ${{ secrets.INFERENCEX_OFFICIAL_RO_HF_TOKEN }}
         with:
+            require-power: ${{ inputs.require-power }}
             config: ${{ toJSON(matrix.config) }}
             klaud-run: ${{ inputs.klaud-run }}
             runner: ${{ matrix.config.runner }}
@@ -505,6 +506,7 @@ jobs:
         secrets:
             INFERENCEX_OFFICIAL_RO_HF_TOKEN: ${{ secrets.INFERENCEX_OFFICIAL_RO_HF_TOKEN }}
         with:
+            require-power: ${{ inputs.require-power }}
             config: ${{ toJSON(matrix.config) }}
             klaud-run: ${{ inputs.klaud-run }}
             runner: ${{ matrix.config.runner }}
diff --git a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/RECIPES.md b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/RECIPES.md
index 91acdc5732..ca6e82049e 100644
--- a/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/RECIPES.md
+++ b/inferencex-e2e/benchmarks/multi_node/srt-slurm-recipes/RECIPES.md
@@ -40,8 +40,8 @@ Recipes use `schema: 2`, `engine`, and `roles`. Each worker role owns its node c
 | `roles.prefill.args.tp-size` (SGLang) | `prefill.tp` |
 | `roles.prefill.args.ep-size` (SGLang) | `prefill.ep` |
 | `roles.prefill.args.enable-dp-attention` | `prefill.dp-attn` |
-| `benchmark.concurrencies` | `conc-list` (bound for `power: true` rows) |
-| `telemetry:` | search-space `power: true` |
+| `benchmark.concurrencies` | `conc-list` (bound for multi-node `power: true` rows) or the native single-node point's concurrency |
+| `telemetry:` | multi-node search-space `power: true`; shared native telemetry for single-node benchmarks |
 | Recipe directory, relative to this tree | entry-level `srt-recipe-dir` |
 | Recipe file, optionally with a `base`, `override_<name>`, or `zip_override_<name>[<index>]` selector | search-space `srt-recipe`; `eval-srt-recipe` for eval-only real verification |
 
@@ -53,7 +53,7 @@ All referenced recipes must be checked in: srt-slurm 2 ships curated examples in
 
 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`.
+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.
 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` (GB200 and GB300 Kimi-K3 AgentX), 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.
@@ -68,11 +68,11 @@ 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`. 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. 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
 
-The planner gives every benchmark row a `recipe-fingerprint`: a SHA-256 of its matrix fields (except `conc` and `exp-name`) and the bound variant the launcher submits, composed with its shared block (and the telemetry block for `power: true`). Concurrency values, the job `name` and everything the launcher adds for a cluster stay out, so a recipe keeps one fingerprint across concurrencies and clusters. An `eval-srt-recipe` contributes only its path; rows without an srt-slurm recipe hash their matrix fields alone.
+The planner gives every benchmark row a `recipe-fingerprint`: a SHA-256 of its matrix fields (except `conc` and `exp-name`) and the bound variant the launcher submits, composed with its shared block and the native single-node or multi-node `power: true` telemetry block. Concurrency values, the job `name` and everything the launcher adds for a cluster stay out, so a recipe keeps one fingerprint across concurrencies and clusters. An `eval-srt-recipe` contributes only its path; rows without an srt-slurm recipe hash their matrix fields alone.
 
 The planner selects variants without srtctl ([`variants.py`](../../../infx/srt_slurm/variants.py)), the way the launcher does, so a row that no variant serves fails planning instead of its launch. Before writing a `perf-changelog.yaml` entry, list the config keys whose results the change invalidates:
 
diff --git a/inferencex-e2e/configs/CONFIGS.md b/inferencex-e2e/configs/CONFIGS.md
index 4df4884a03..2e63d9eee9 100644
--- a/inferencex-e2e/configs/CONFIGS.md
+++ b/inferencex-e2e/configs/CONFIGS.md
@@ -266,3 +266,19 @@ schema; unknown keys fail.
   The cluster's own `env` and `srt-slurm.host-setup.env` values may take a field the
   same way; they resolve when the record loads, and `env` still rejects the commas of a
   list.
+- `slurm.srt-slurm.extra.default_gpu_exporter` is the cluster's native power exporter.
+  Native single-node throughput and AgentX jobs inherit it when the bound recipe
+  enables telemetry without selecting its own exporter; eval-only jobs collect no power.
+  A cluster without the block stops preparation before the benchmark starts. An invalid
+  measurement fails the job under `REQUIRE_POWER=1` and otherwise records an invalid
+  verdict without energy metrics. NVIDIA clusters run `dcgm-exporter`; AMD clusters use
+  srt-slurm's
+  [`kind: custom` schema](https://github.com/NVIDIA/srt-slurm/blob/545233a0d36e7d21cf74bb01a4365475c9214003/docs/power-telemetry.md#gpu-exporter-labels-and-metrics),
+  which requires `gpu_labels` and `gpu_metrics` and rejects unknown keys such as the
+  former `power_profile`. The AMD exporter reads
+  [`runners/srt-slurm/exporters/amd-power.json`](../runners/srt-slurm/exporters/amd-power.json);
+  [`runners/srt-slurm/patches/README.md`](../runners/srt-slurm/patches/README.md) lists
+  the srt-slurm patches native power collection relies on.
+- `slurm.srt-slurm.workspace-mounts` maps files relative to `inferencex-e2e/` into
+  job containers. The renderer resolves each source against the job checkout;
+  host-absolute paths belong in `mounts`, and volume aliases in `volume-mounts`.
diff --git a/inferencex-e2e/configs/runners.yaml b/inferencex-e2e/configs/runners.yaml
index 68a8715c1c..a6f618953a 100644
--- a/inferencex-e2e/configs/runners.yaml
+++ b/inferencex-e2e/configs/runners.yaml
@@ -822,6 +822,8 @@ clusters:
         import: all-nodes
         lock-timeout-s: 600
       srt-slurm:
+        workspace-mounts: &amd-exporter-config
+          runners/srt-slurm/exporters/amd-power.json: /etc/metrics/config.json
         network-interface: ""
         single-node-time-limit: 180
         gpus-per-node-directive: true
@@ -833,6 +835,22 @@ clusters:
           /dev/dri: /dev/dri
         extra:
           visible_devices_env: ROCR_VISIBLE_DEVICES
+          default_gpu_exporter: &amd-exporter
+            container_image: ghcr.io#semianalysisai/amd-device-metrics-exporter@sha256:0d1c32c965f955b0fbf1dc87a84f7205be9019ce8d2fdf1eb929de28c71cec54
+            port: 19500
+            command: /home/amd/tools/entrypoint.sh
+            kind: custom
+            gpu_labels:
+              index: gpu_id
+              identity: serial_number
+            gpu_metrics:
+              power:
+                metric: gpu_power_usage
+                scope: gpu_device_power_as_reported_by_amd_device_metrics_exporter
+              gpu_util:
+                metric: gpu_gfx_activity
+              temperature:
+                metric: gpu_junction_temperature
   # Barite shares its login and NFS with mi300x-amd, but not its GPU partition.
   mi325x-amd:
     gpus-per-node: 8
@@ -854,6 +872,7 @@ clusters:
         import: compute
         lock-timeout-s: 600
       srt-slurm:
+        workspace-mounts: *amd-exporter-config
         network-interface: ""
         single-node-time-limit: 480
         gpus-per-node-directive: true
@@ -863,6 +882,7 @@ clusters:
           /dev/dri: /dev/dri
         extra:
           visible_devices_env: ROCR_VISIBLE_DEVICES
+          default_gpu_exporter: *amd-exporter
           default_bash_preamble: |-
             export XDG_CACHE_HOME="/tmp/xdg-cache-$SLURM_JOB_ID"
             export TRITON_CACHE_DIR="/tmp/triton-cache-$SLURM_JOB_ID"
@@ -897,6 +917,7 @@ clusters:
         import: compute
         multi-node-import: false
       srt-slurm:
+        workspace-mounts: *amd-exporter-config
         network-interface: eno0
         fabric:
           rdma-devices: [rdma0, rdma1, rdma2, rdma3, rdma4, rdma5, rdma6, rdma7]
@@ -921,5 +942,5 @@ clusters:
           /it-share/hf_home: /it-share/hf_home
         extra:
           visible_devices_env: ROCR_VISIBLE_DEVICES
-          default_gpu_exporter: null
+          default_gpu_exporter: *amd-exporter
           nginx_raise_ulimit: false
diff --git a/inferencex-e2e/configs/srt-recipes/telemetry-native.yaml b/inferencex-e2e/configs/srt-recipes/telemetry-native.yaml
new file mode 100644
index 0000000000..308a006d29
--- /dev/null
+++ b/inferencex-e2e/configs/srt-recipes/telemetry-native.yaml
@@ -0,0 +1,7 @@
+# Native single-node benchmarks inherit the GPU exporter from the cluster record.
+# The binder sets `required` from REQUIRE_POWER.
+telemetry:
+  enabled: true
+  storage_subdir: power
+  # Cold AMD exporter image pulls can outlast srtctl's default readiness timeout.
+  startup_timeout_seconds: 300
diff --git a/inferencex-e2e/infx/bench/agentic/run.py b/inferencex-e2e/infx/bench/agentic/run.py
index b2652958ab..e4fda327af 100644
--- a/inferencex-e2e/infx/bench/agentic/run.py
+++ b/inferencex-e2e/infx/bench/agentic/run.py
@@ -30,7 +30,6 @@
 POWER_SWITCHES = ("ENABLE_AGENTX_POWER", "REQUIRE_POWER")
 FAILED_REQUEST_THRESHOLD = "0.10"
 TRUE_VALUES = frozenset({"1", "true", "TRUE", "yes", "YES"})
-
 PowerMode = Literal["off", "window", "missing"]
 
 
@@ -53,7 +52,8 @@ def from_env(cls, env: Mapping[str, str]) -> Plan:
         """Validate every input before any setup, so a bad point fails in seconds."""
         values = inputs.require(*REQUIRED, *REPLAY_REQUIRED, env=env)
         multinode = inputs.flag("IS_MULTINODE", env)
-        switches = inputs.require(*POWER_SWITCHES, env=env) if multinode else {}
+        matrix_point = env.get("IS_AGENTIC") == "1" or env.get("SCENARIO_TYPE") == "agentic-coding"
+        switches = inputs.require(*POWER_SWITCHES, env=env) if multinode or matrix_point else {}
         result_dir = Path(values["RESULT_DIR"]).absolute()
         result_filename = values["RESULT_FILENAME"]
         if multinode:
@@ -61,7 +61,7 @@ def from_env(cls, env: Mapping[str, str]) -> Plan:
             result_filename += f"_conc{values['CONC']}"
         replay = ReplayConfig.from_env(env, result_dir)
         _require_single_point(env, values["CONC"])
-        if env.get("IS_AGENTIC") == "1" or env.get("SCENARIO_TYPE") == "agentic-coding":
+        if matrix_point:
             _validate_kv_offload(env)
         eval_only = inputs.flag("EVAL_ONLY", env)
         return cls(
@@ -152,7 +152,7 @@ def _download_traces(cfg: ReplayConfig, runtime: Runtime, env: Mapping[str, str]
 
 
 def _open_power_window(plan: Plan, python: str, env: Mapping[str, str]) -> int:
-    """Record the replay clock's UTC offset and mark srt-slurm's multi-node window running."""
+    """Record the replay clock's UTC offset and open srt-slurm's measurement window."""
     if plan.power != "window":
         return 0
     now = dt.datetime.now(dt.timezone.utc).astimezone()
diff --git a/inferencex-e2e/infx/bench/fixed_seq.py b/inferencex-e2e/infx/bench/fixed_seq.py
index 7e0b1e0e1f..15704cfe11 100644
--- a/inferencex-e2e/infx/bench/fixed_seq.py
+++ b/inferencex-e2e/infx/bench/fixed_seq.py
@@ -77,7 +77,7 @@ def served_model(base_url: str) -> str:
 
 
 def srt_single(args: argparse.Namespace) -> int:
-    """One srt-slurm single-node point; srt-slurm owns the server."""
+    """One single-node point; srt-slurm owns the server and power sampling."""
     values = env.require(
         "MODEL", "CONC", "ISL", "OSL", "RANDOM_RANGE_RATIO", "RESULT_FILENAME", "RESULT_DIR",
         "SRT_FRONTEND_HOST", "SRT_FRONTEND_PORT", "RUN_EVAL", "EVAL_ONLY", "USE_CHAT_TEMPLATE",
@@ -108,7 +108,12 @@ def srt_single(args: argparse.Namespace) -> int:
     if eval_only:
         print("EVAL_ONLY mode: skipping throughput benchmark", flush=True)
         return 0
-    return _run_client(point)
+    env.require("SRT_MEASUREMENT_WINDOW_DIR")
+    with proc.RelaySignals() as relay:
+        rc = relay.run(client_argv(point))
+        if rc:
+            return rc
+        return relay.run([PYTHON, "-m", "infx.results.power.window", str(point.result), str(conc)])
 
 
 def srt_sweep(args: argparse.Namespace) -> int:
diff --git a/inferencex-e2e/infx/clusters/slurm.py b/inferencex-e2e/infx/clusters/slurm.py
index c459af29cf..c7c670f00c 100644
--- a/inferencex-e2e/infx/clusters/slurm.py
+++ b/inferencex-e2e/infx/clusters/slurm.py
@@ -201,9 +201,22 @@ class SrtSlurmSettings(Record):
         default_factory=dict, alias="agentic-volume-mounts"
     )
     mounts: dict[str, str] = Field(default_factory=dict)
+    workspace_mounts: dict[str, str] = Field(default_factory=dict, alias="workspace-mounts")
     power_exporter_port: int | None = Field(default=None, alias="power-exporter-port", gt=0)
     extra: dict[str, Any] = Field(default_factory=dict)
 
+    @field_validator("workspace_mounts")
+    @classmethod
+    def _workspace_mount_paths(cls, mounts: dict[str, str]) -> dict[str, str]:
+        """Mount checked-in workspace assets at explicit absolute container paths."""
+        for source, target in mounts.items():
+            path = PurePosixPath(source)
+            if not source or path == PurePosixPath(".") or path.is_absolute() or ".." in path.parts:
+                raise ValueError(f"workspace-mounts source must be repository-relative: {source}")
+            if not PurePosixPath(target).is_absolute():
+                raise ValueError(f"workspace-mounts target must be absolute: {target}")
+        return mounts
+
     @model_validator(mode="before")
     @classmethod
     def _host_setup_fabric(cls, data: Any) -> Any:
diff --git a/inferencex-e2e/infx/klaud/validation.py b/inferencex-e2e/infx/klaud/validation.py
index 251be80e80..948ce4a6ab 100644
--- a/inferencex-e2e/infx/klaud/validation.py
+++ b/inferencex-e2e/infx/klaud/validation.py
@@ -54,7 +54,7 @@ def canonical_matrix(repository: str, head: str, family: str) -> dict:
         validate_master_config,
         validate_runner_config,
     )
-    from infx.srt_slurm.workload import SHARED_BLOCKS, TELEMETRY_BLOCK
+    from infx.srt_slurm.workload import NATIVE_TELEMETRY_BLOCK, SHARED_BLOCKS, TELEMETRY_BLOCK
 
     OwnedCandidate(id="0" * 16 + "-" + "0" * 16, family=family, base=head)
     source, key = family.split(":", 1)
@@ -66,7 +66,10 @@ def canonical_matrix(repository: str, head: str, family: str) -> dict:
         root = Path(temp)
         references = srt_recipe_references(family_config)[key]
         paths = {reference.partition(":")[0] for reference in references}
-        blocks = [block.as_posix() for block in (*SHARED_BLOCKS.values(), TELEMETRY_BLOCK)]
+        blocks = [
+            block.as_posix()
+            for block in (*SHARED_BLOCKS.values(), TELEMETRY_BLOCK, NATIVE_TELEMETRY_BLOCK)
+        ]
         for path in [*paths, *blocks]:
             (root / path).parent.mkdir(parents=True, exist_ok=True)
             (root / path).write_bytes(github.file_at(repository, head, prefix + path))
diff --git a/inferencex-e2e/infx/launch/artifacts.py b/inferencex-e2e/infx/launch/artifacts.py
index deaa823ebb..57505e4562 100644
--- a/inferencex-e2e/infx/launch/artifacts.py
+++ b/inferencex-e2e/infx/launch/artifacts.py
@@ -203,21 +203,40 @@ def validate_agentic_power(
             _warn("ERROR: INFERENCEX_RESULTS_PYTHON is required")
             rc = 1
             continue
-        python_path = os.environ.get("PYTHONPATH")
-        env = {
-            **os.environ,
-            "PYTHONPATH": f"{_PROJECT_ROOT}:{python_path}" if python_path else str(_PROJECT_ROOT),
-        }
-        argv = [
-            results_python, "-m", "infx.results.agentic.power_adapter",
-            "--result-dir", str(logs_dir / "agentic" / f"conc_{concurrency}"),
-            "--agg-result", str(workspace / f"{result_filename}_conc{concurrency}.json"),
-            "--power-dir", str(logs_dir / "power"),
-            "--logs-root", str(logs_dir),
-            "--expected-producer-sha", producer_sha,
-            *(["--require-power"] if require_power else []),
-        ]  # fmt: skip
-        step = proc.run(argv, env=env, cwd=workspace).returncode
-        if step:
+        if step := run_power_adapter(
+            results_python, workspace, logs_dir,
+            logs_dir / "agentic" / f"conc_{concurrency}",
+            workspace / f"{result_filename}_conc{concurrency}.json",
+            producer_sha, require_power=require_power,
+        ):  # fmt: skip
             rc = step
     return rc
+
+
+def run_power_adapter(
+    results_python: str,
+    workspace: Path,
+    logs_dir: Path,
+    result_dir: Path,
+    agg_result: Path,
+    producer_sha: str,
+    *extra: str,
+    require_power: bool,
+) -> int:
+    """Join one AgentX point's aggregate to the power package under ``logs_dir``."""
+    python_path = os.environ.get("PYTHONPATH")
+    env = {
+        **os.environ,
+        "PYTHONPATH": f"{_PROJECT_ROOT}:{python_path}" if python_path else str(_PROJECT_ROOT),
+    }
+    argv = [
+        results_python, "-m", "infx.results.agentic.power_adapter",
+        "--result-dir", str(result_dir),
+        "--agg-result", str(agg_result),
+        "--power-dir", str(logs_dir / "power"),
+        "--logs-root", str(logs_dir),
+        "--expected-producer-sha", producer_sha,
+        *extra,
+        *(["--require-power"] if require_power else []),
+    ]  # fmt: skip
+    return proc.run(argv, env=env, cwd=workspace).returncode
diff --git a/inferencex-e2e/infx/launch/drivers/srt/__init__.py b/inferencex-e2e/infx/launch/drivers/srt/__init__.py
index edb714085c..cc89b4b4c0 100644
--- a/inferencex-e2e/infx/launch/drivers/srt/__init__.py
+++ b/inferencex-e2e/infx/launch/drivers/srt/__init__.py
@@ -57,13 +57,17 @@ def run_single_node(launch: Launch) -> int:
     hf_cache = models.single_node_hf_cache(run.cluster, request)
     time_limit = lanes.srt_time_limit(run.cluster.id, request, None, run.srt)
     root = Path(tempfile.mkdtemp(prefix="srt-single.", dir=run.workspace))
-    checkout = prepare_checkout(run, root / "checkout", power=False)
+    checkout = prepare_checkout(run, root / "checkout", power=not request.eval_only)
     install_srtctl(run, checkout)
     if (options := config.srun_options(run.backend.settings)) is not None:
         run.env["SRT_SRUN_OPTIONS"] = options
     if rc := submit.bind_point(run, checkout, root / "arguments"):
         return rc
     selected, runtime_args = submit.bound_arguments(root / "arguments")
+    containers = {}
+    if not request.eval_only:
+        image, reference = config.stage_gpu_exporter(run, single_node=True)
+        containers[image] = reference
     job_config = config.SrtJob(
         srtctl_root=checkout.root,
         workspace=run.workspace,
@@ -71,6 +75,7 @@ def run_single_node(launch: Launch) -> int:
         image=request.image,
         container=run.backend.stage_image(request.image, single_node=True).reference,
         nginx=config.NGINX_IMAGE if run.srt.nginx_aliases else None,
+        containers=containers,
         model_paths={f"hf:{request.model}": model_path},
         mounts=[(str(hf_cache), request.hf_hub_cache)],
         single_node=True,
@@ -95,9 +100,13 @@ def run_single_node(launch: Launch) -> int:
         run.backend.stream_logs(job)
     except BackendError:
         return 1
-    if not run.backend.state(job).succeeded:
-        return 1
-    return collect.check_single_node(run, run.backend.fetch_outputs(job, fetched) / "logs")
+    status = run.backend.state(job)
+    logs = run.backend.fetch_outputs(job, fetched) / "logs"
+    if not request.eval_only:
+        (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)
+    return rc or int(not status.succeeded)
 
 
 def run_batch(launch: Launch) -> int:
diff --git a/inferencex-e2e/infx/launch/drivers/srt/collect.py b/inferencex-e2e/infx/launch/drivers/srt/collect.py
index b5b4975b2d..7868b2e65d 100644
--- a/inferencex-e2e/infx/launch/drivers/srt/collect.py
+++ b/inferencex-e2e/infx/launch/drivers/srt/collect.py
@@ -24,6 +24,7 @@
     copy_eval_artifacts,
     copy_fixed_sequence_results,
     copy_to_workspace,
+    run_power_adapter,
     validate_agentic_power,
 )
 from infx.launch.backends.base import BackendError
@@ -49,7 +50,11 @@ def _copy_tree_into(source: Path, destination: Path) -> None:
 
 
 def finish_single_node(run: SrtRun, submitted: Submitted, fetched: Path) -> int:
-    """Exit cleanup of a single-node point: cancel a live job, then stage its artifacts."""
+    """Exit cleanup of a single-node point: cancel a live job, then stage its artifacts.
+
+    A power package that cannot be copied fails the point only when valid power was
+    required; otherwise the result stands and the package is reported incomplete.
+    """
     job = submitted.recover(run.backend)
     if job is None:
         return 0
@@ -58,8 +63,9 @@ def finish_single_node(run: SrtRun, submitted: Submitted, fetched: Path) -> int:
     if not output.is_dir():
         return 0
     rc = 0
-    bundle_server_logs(output, run.workspace / SINGLE_NODE_LOGS)
     logs = output / "logs"
+    power_rc = 0 if run.request.eval_only else _stage_power_package(run, logs)
+    bundle_server_logs(output, run.workspace / SINGLE_NODE_LOGS)
     result = logs / f"{run.request.result_filename}.json"
     if result.is_file():
         try:
@@ -73,15 +79,43 @@ def finish_single_node(run: SrtRun, submitted: Submitted, fetched: Path) -> int:
         except OSError as error:
             print(f"ERROR: failed to stage AgentX artifacts: {error}", file=sys.stderr)
             rc = 1
-    return rc
+    return rc or power_rc
 
 
-def check_single_node(run: SrtRun, logs: Path) -> int:
-    """Fail unless each requested eval succeeded and the benchmark result exists.
+def _stage_power_package(run: SrtRun, logs: Path) -> int:
+    """Copy the native power package into LOGS; 1 when power was required and a copy failed."""
+    try:
+        power_dir = logs / "power"
+        power_dir.mkdir(parents=True, exist_ok=True)
+        for name in (EXPORTER_PROVENANCE, "power-producer-sha.txt"):
+            shutil.copyfile(run.workspace / name, power_dir / name)
+        shutil.copytree(logs, run.workspace / "LOGS", symlinks=True, dirs_exist_ok=True)
+    except OSError as error:
+        level = "ERROR" if run.request.require_power else "WARNING"
+        print(f"{level}: failed to stage the native power package: {error}", file=sys.stderr)
+        return int(run.request.require_power)
+    return 0
+
+
+def finalize_single_node_results(run: SrtRun, logs: Path, producer_sha: str) -> int:
+    """Write native AgentX power metrics, then validate evals and the benchmark result.
+
+    A single-node point publishes the fixed-sequence bundle shape: the validation
+    sidecar sits beside the result, named after it, and the audit names that file.
 
     srt-slurm treats a failed post-benchmark eval as non-fatal; InferenceX does not.
     """
     request = run.request
+    power_rc = 0
+    if request.is_agentic and not request.eval_only:
+        require(request, "INFERENCEX_RESULTS_PYTHON")
+        sidecar = f"power_validation_{request.result_filename}.json"
+        power_rc = run_power_adapter(
+            request.inferencex_results_python, run.workspace, logs, logs / "agentic",
+            logs / f"{request.result_filename}.json", producer_sha,
+            "--validation-result", str(run.workspace / sidecar), "--audit-source", sidecar,
+            require_power=request.require_power,
+        )  # fmt: skip
     if request.run_eval or request.eval_only:
         exit_file = logs / "infx-eval-exit-code"
         if not exit_file.is_file() or exit_file.read_text().rstrip("\n") != "0":
@@ -92,7 +126,7 @@ def check_single_node(run: SrtRun, logs: Path) -> int:
         if not result.is_file() or result.stat().st_size == 0:
             print(f"ERROR: benchmark result {result} is missing or empty", file=sys.stderr)
             return 1
-    return 0
+    return power_rc
 
 
 def _stage_logs(run: SrtRun, logs: Path, power: PowerDecision) -> None:
diff --git a/inferencex-e2e/infx/launch/drivers/srt/config.py b/inferencex-e2e/infx/launch/drivers/srt/config.py
index 7139a4f1af..849acb4131 100644
--- a/inferencex-e2e/infx/launch/drivers/srt/config.py
+++ b/inferencex-e2e/infx/launch/drivers/srt/config.py
@@ -30,7 +30,6 @@
     from infx.launch.request import SrtRequest
 
 NGINX_IMAGE = "nginx:1.27.4"
-DCGM_EXPORTER_IMAGE = "nvcr.io/nvidia/k8s/dcgm-exporter:4.6.0-4.8.3-distroless"
 EXPORTER_PROVENANCE = "exporter-image.sha256"
 HEALTH_CHECK = {"max_attempts": HEALTH_ATTEMPTS, "interval_seconds": 10}
 
@@ -119,7 +118,10 @@ def render(cluster: Cluster, job: SrtJob) -> dict[str, Any]:
     volume_mounts = {
         str(volume_path(cluster, name)): target for name, target in srt.volume_mounts.items()
     }
-    mounts = _mounts({**volume_mounts, **srt.mounts}, job.mounts)
+    workspace_mounts = {
+        str(job.workspace / source): target for source, target in srt.workspace_mounts.items()
+    }
+    mounts = _mounts({**volume_mounts, **srt.mounts, **workspace_mounts}, job.mounts)
     if mounts:
         config["default_mounts"] = mounts
     if srt.gpus_per_node_directive is not None:
@@ -160,6 +162,17 @@ def write(path: Path, config: Mapping[str, Any]) -> None:
     path.write_text(yaml.safe_dump(dict(config), sort_keys=False))
 
 
+def stage_gpu_exporter(run: SrtRun, *, single_node: bool = False) -> tuple[str, str]:
+    """Stage the cluster's GPU exporter image: its recipe name and the reference jobs start from."""
+    exporter = run.srt.extra.get("default_gpu_exporter")
+    if not isinstance(exporter, dict) or not exporter.get("container_image"):
+        raise LaunchError("native power requires a cluster GPU exporter")
+    image = exporter["container_image"]
+    staged = run.backend.stage_image(image, helper="dcgm-exporter", single_node=single_node)
+    (run.workspace / EXPORTER_PROVENANCE).write_text(f"{run.backend.image_provenance(staged)}\n")
+    return image, staged.reference
+
+
 def srun_options(settings: SlurmSettings) -> str | None:
     """SRT_SRUN_OPTIONS for the single-node binder: ``slurm.srun-args`` as a JSON mapping."""
     if not settings.srun_args:
@@ -274,9 +287,9 @@ def write_lane_config(
         prefill_image = request.env["PREFILL_IMAGE"]
         containers[prefill_image] = backend.stage_image(prefill_image).reference
     if power.dcgm:
-        exporter = backend.stage_image(DCGM_EXPORTER_IMAGE, helper="dcgm-exporter")
-        (run.workspace / EXPORTER_PROVENANCE).write_text(f"{backend.image_provenance(exporter)}\n")
-        containers["dcgm-exporter"] = exporter.reference
+        image, reference = stage_gpu_exporter(run)
+        containers["dcgm-exporter"] = reference
+        containers[image] = reference
     create_volume_mounts(run)
     job = SrtJob(
         srtctl_root=checkout.root,
diff --git a/inferencex-e2e/infx/results/agentic/power_adapter.py b/inferencex-e2e/infx/results/agentic/power_adapter.py
index 6cceaaea78..9973c0ed7a 100644
--- a/inferencex-e2e/infx/results/agentic/power_adapter.py
+++ b/inferencex-e2e/infx/results/agentic/power_adapter.py
@@ -10,6 +10,7 @@
 import re
 import sys
 import time
+from collections.abc import Mapping
 from datetime import UTC, datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any
@@ -20,6 +21,7 @@
     POWER_METRIC_SCHEMA_VERSION,
     with_power_metrics,
 )
+from infx.results.power.audit import audit_summary
 from infx.results.power.common import _write_json_atomic
 from infx.results.power.multinode import WINDOWS_DIRNAME, run as run_multinode_power
 
@@ -321,7 +323,31 @@ def _gpu_count(value: Any) -> int | None:
     return value
 
 
-def run_multinode_agentic_power(
+def _power_topology(aggregate: Mapping[str, Any]) -> tuple[int, int, int] | None:
+    """The (prefill, decode, aggregate) GPU counts the power validator must find.
+
+    A single-node point is one aggregate worker of ``num_gpus``. A multinode point
+    declares its own roles: disaggregated prefill/decode, or one aggregate worker of their sum.
+    """
+    disagg = aggregate.get("disagg")
+    if aggregate.get("is_multinode") is False:
+        num_gpus = _gpu_count(aggregate.get("num_gpus"))
+        return (0, 0, num_gpus) if disagg is False and num_gpus else None
+    prefill_gpus = _gpu_count(aggregate.get("num_prefill_gpu"))
+    decode_gpus = _gpu_count(aggregate.get("num_decode_gpu"))
+    if (
+        not isinstance(disagg, bool)
+        or prefill_gpus is None
+        or decode_gpus is None
+        or prefill_gpus + decode_gpus <= 0
+    ):
+        return None
+    if disagg:
+        return prefill_gpus, decode_gpus, 0
+    return 0, 0, prefill_gpus + decode_gpus
+
+
+def run_native_agentic_power(
     *,
     result_dir: Path,
     agg_result: Path,
@@ -329,9 +355,11 @@ def run_multinode_agentic_power(
     logs_root: Path,
     expected_producer_sha: str,
     require_power: bool = False,
+    audit_source: str | None = None,
+    validation_result: Path | None = None,
 ) -> int:
-    """Join one AgentX aggregate to the finalized central multinode package."""
-    validation_result = result_dir / "power_validation.json"
+    """Join one AgentX aggregate to the finalized native power package."""
+    validation_result = validation_result or result_dir / "power_validation.json"
     reasons: list[str] = []
     try:
         aggregate = json.loads(agg_result.read_text(encoding="utf-8"))
@@ -343,15 +371,8 @@ def run_multinode_agentic_power(
             reasons.append("agentic_aggregate_invalid")
         aggregate = {}
 
-    prefill_gpus = _gpu_count(aggregate.get("num_prefill_gpu"))
-    decode_gpus = _gpu_count(aggregate.get("num_decode_gpu"))
-    disagg = aggregate.get("disagg")
-    if (
-        not isinstance(disagg, bool)
-        or prefill_gpus is None
-        or decode_gpus is None
-        or prefill_gpus + decode_gpus <= 0
-    ):
+    topology = _power_topology(aggregate)
+    if topology is None:
         reasons.append("agentic_gpu_topology_invalid")
     bench_result = _formal_result_for_directory(result_dir)
     if bench_result is None:
@@ -375,32 +396,38 @@ def run_multinode_agentic_power(
                 f"[agentx_power] Failed to record multinode adapter failure: {exc}",
                 file=sys.stderr,
             )
-        return _fail_multinode_adapter(
+        status = _fail_multinode_adapter(
             "Multinode AgentX power adaptation failed: " + ", ".join(reasons),
             require_power=require_power,
         )
-
-    assert prefill_gpus is not None  # noqa: S101
-    assert decode_gpus is not None  # noqa: S101
-    assert isinstance(disagg, bool)  # noqa: S101
-    assert bench_result is not None  # noqa: S101
-    aggregate_gpus = 0
-    if not disagg:
-        aggregate_gpus = prefill_gpus + decode_gpus
-        prefill_gpus = 0
-        decode_gpus = 0
-    return run_multinode_power(
-        power_dir=power_dir,
-        bench_result=bench_result,
-        agg_result=agg_result,
-        prefill_gpus=prefill_gpus,
-        decode_gpus=decode_gpus,
-        aggregate_gpus=aggregate_gpus,
-        expected_producer_sha=expected_producer_sha,
-        logs_root=logs_root,
-        validation_result=validation_result,
-        require_power=require_power,
-    )
+    else:
+        assert topology is not None  # noqa: S101
+        assert bench_result is not None  # noqa: S101
+        prefill_gpus, decode_gpus, aggregate_gpus = topology
+        status = run_multinode_power(
+            power_dir=power_dir,
+            bench_result=bench_result,
+            agg_result=agg_result,
+            prefill_gpus=prefill_gpus,
+            decode_gpus=decode_gpus,
+            aggregate_gpus=aggregate_gpus,
+            expected_producer_sha=expected_producer_sha,
+            logs_root=logs_root,
+            validation_result=validation_result,
+            require_power=require_power,
+        )
+    if audit_source is not None:
+        try:
+            result = json.loads(agg_result.read_text())
+            validation = json.loads(validation_result.read_text())
+            if not isinstance(result, dict) or not isinstance(validation, dict):
+                raise ValueError("AgentX aggregate and validation must be JSON objects")
+            result.update(audit_summary(validation, audit_source))
+            _write_json_atomic(agg_result, result)
+        except (OSError, ValueError, TypeError) as exc:
+            print(f"[agentx_power] Audit summary unavailable: {exc}", file=sys.stderr)
+            status = max(status, int(require_power))
+    return status
 
 
 def main() -> int:
@@ -413,6 +440,8 @@ def main() -> int:
     parser.add_argument("--power-dir", type=Path)
     parser.add_argument("--logs-root", type=Path)
     parser.add_argument("--expected-producer-sha")
+    parser.add_argument("--audit-source")
+    parser.add_argument("--validation-result", type=Path)
     parser.add_argument(
         "--require-power",
         action="store_true",
@@ -463,13 +492,15 @@ def main() -> int:
         parser.error(
             "--agg-result, --logs-root, and --expected-producer-sha are required with --power-dir"
         )
-    return run_multinode_agentic_power(
+    return run_native_agentic_power(
         result_dir=args.result_dir,
         agg_result=args.agg_result,
         power_dir=args.power_dir,
         logs_root=args.logs_root,
         expected_producer_sha=args.expected_producer_sha,
         require_power=args.require_power,
+        audit_source=args.audit_source,
+        validation_result=args.validation_result,
     )
 
 
diff --git a/inferencex-e2e/infx/results/fixed_sequence.py b/inferencex-e2e/infx/results/fixed_sequence.py
index a3217e009d..68fa62b6f7 100644
--- a/inferencex-e2e/infx/results/fixed_sequence.py
+++ b/inferencex-e2e/infx/results/fixed_sequence.py
@@ -259,13 +259,14 @@ def aggregate_power_result(
     bench_path: Path,
     agg_path: Path,
 ) -> int:
-    """Enrich a written multinode result, preserving best-effort failures."""
+    """Enrich a written result from retained native telemetry."""
     require_power = env.get("REQUIRE_POWER", "").lower() in {"1", "true", "yes"}
     validation_path = Path(f"power_validation_{env['RESULT_FILENAME']}.json")
     source = Path(env.get("POWER_ARTIFACT_DIR", "LOGS/power"))
-    prefill_gpus = int(env["PREFILL_GPUS"])
-    decode_gpus = int(env["DECODE_GPUS"])
-    aggregate_gpus = int(env.get("AGGREGATE_GPUS", "0"))
+    is_multinode = env.get("IS_MULTINODE", "false").lower() == "true"
+    prefill_gpus = int(env["PREFILL_GPUS"]) if is_multinode else 0
+    decode_gpus = int(env["DECODE_GPUS"]) if is_multinode else 0
+    aggregate_gpus = int(env.get("AGGREGATE_GPUS", "0")) if is_multinode else int(env["GPU_COUNT"])
     try:
         from .power.multinode import run
 
@@ -305,7 +306,7 @@ def process_result(env: Mapping[str, str]) -> int:
     with open(agg_path, "w") as f:
         json.dump(data, f, indent=2)
     status = 0
-    if data["is_multinode"]:
+    if data["is_multinode"] or env.get("POWER_PRODUCER_SHA"):
         status = aggregate_power_result(env, bench_path, agg_path)
         validation_path = Path(f"power_validation_{result_filename}.json")
         from .power.audit import audit_summary
diff --git a/inferencex-e2e/infx/results/power/multinode.py b/inferencex-e2e/infx/results/power/multinode.py
index e98c3a9129..b118c1245e 100644
--- a/inferencex-e2e/infx/results/power/multinode.py
+++ b/inferencex-e2e/infx/results/power/multinode.py
@@ -1,8 +1,8 @@
-"""Validate and aggregate multinode srt-slurm DCGM power artifacts.
+"""Validate and aggregate srt-slurm GPU power artifacts.
 
 Consumes the srt-slurm ``dcgm-power`` artifact package (v1 wire contract:
 ``power/{manifest.json, samples.csv, windows/*.json}``) produced for
-multinode runs, re-validates it independently, and patches whole-deployment
+single- or multi-node runs, re-validates it independently, and patches whole-deployment
 energy metrics plus role-level metrics for disaggregated deployments into the
 aggregate JSON.
 
@@ -62,9 +62,7 @@
 
 SCHEMA_VERSION = 1
 PRODUCER = "srt-slurm.dcgm-power"
-POWER_METRIC = "DCGM_FI_DEV_POWER_USAGE"
 POWER_UNIT = "W"
-POWER_SCOPE = "gpu_device_board_as_reported_by_dcgm"
 CLOCK_SOURCE = "head_node_unix_clock"
 
 MANIFEST_FILENAME = "manifest.json"
@@ -83,8 +81,10 @@
 
 SAMPLES_HEADER_V2 = (*SAMPLES_HEADER, "gpu_util_pct", "sm_active")
 SAMPLES_HEADER_V3 = (*SAMPLES_HEADER_V2, "temperature_c")
+SAMPLES_HEADERS = {1: SAMPLES_HEADER, 2: SAMPLES_HEADER_V2, 3: SAMPLES_HEADER_V3}
 
 MAX_SAMPLE_GAP_SECONDS = 3.0
+MAX_TEMPERATURE_C = 200.0
 
 WORKER_ROLES = ("prefill", "decode", "agg")
 
@@ -274,13 +274,15 @@ def _check_wire_contract(manifest: dict) -> list[str]:
     for key, expected in (
         ("schema_version", SCHEMA_VERSION),
         ("producer", PRODUCER),
-        ("source_metric", POWER_METRIC),
         ("unit", POWER_UNIT),
-        ("power_scope", POWER_SCOPE),
         ("timestamp_source", CLOCK_SOURCE),
     ):
         if manifest.get(key) != expected:
             failures.append(f"{key} is {manifest.get(key)!r}, expected {expected!r}")
+    for key in ("source_metric", "power_scope"):
+        value = manifest.get(key)
+        if not (isinstance(value, str) and value):
+            failures.append(f"{key} is not a non-empty string")
 
     status = manifest.get("status")
     if status != STATUS_COMPLETE:
@@ -328,8 +330,7 @@ def _check_wire_contract(manifest: dict) -> list[str]:
 
 def _parse_sample_row(raw: list[str], expected_version: int) -> SampleRow | None:
     """Validate the selected CSV generation, including optional utilization and temperature."""
-    header = {1: SAMPLES_HEADER, 2: SAMPLES_HEADER_V2, 3: SAMPLES_HEADER_V3}[expected_version]
-    if len(raw) != len(header):
+    if len(raw) != len(SAMPLES_HEADERS[expected_version]):
         return None
     try:
         schema_version = int(raw[0])
@@ -345,7 +346,7 @@ def _parse_sample_row(raw: list[str], expected_version: int) -> SampleRow | None
                         return None
         if expected_version == 3 and raw[9]:
             temperature = float(raw[9])
-            if not math.isfinite(temperature) or not -273.15 <= temperature < 0x7FFFFFF0:
+            if not math.isfinite(temperature) or not -273.15 <= temperature <= MAX_TEMPERATURE_C:
                 return None
     except ValueError:
         return None
@@ -376,13 +377,11 @@ def read_samples(path: Path) -> tuple[tuple[SampleRow, ...], tuple[str, ...]]:
         with open(path, newline="", encoding="utf-8") as handle:
             reader = csv.reader(handle)
             header = next(reader, None)
-            if header == list(SAMPLES_HEADER):
-                expected_version = 1
-            elif header == list(SAMPLES_HEADER_V2):
-                expected_version = 2
-            elif header == list(SAMPLES_HEADER_V3):
-                expected_version = 3
-            else:
+            expected_version = next(
+                (version for version, names in SAMPLES_HEADERS.items() if header == list(names)),
+                None,
+            )
+            if expected_version is None:
                 return (), ("samples_csv_header_mismatch",)
             for raw in reader:
                 row = _parse_sample_row(raw, expected_version)
@@ -854,6 +853,18 @@ def _check_stored_evidence(
         if len(set(keys)) != len(keys):
             failures.append(f"{label} contains duplicate keys")
 
+    clock_sync_failures = manifest.get("clock_sync_failures", [])
+    if not isinstance(clock_sync_failures, list) or not all(
+        isinstance(node, str) for node in clock_sync_failures
+    ):
+        failures.append("clock_sync_failures is not a list of strings")
+    elif clock_sync_failures:
+        failures.append(
+            "clock_sync_unverified: "
+            + ", ".join(clock_sync_failures)
+            + " did not prove NTP synchronisation"
+        )
+
     return failures
 
 
diff --git a/inferencex-e2e/infx/srt_slurm/generate.py b/inferencex-e2e/infx/srt_slurm/generate.py
index 435f7edc82..9d3c30fd79 100644
--- a/inferencex-e2e/infx/srt_slurm/generate.py
+++ b/inferencex-e2e/infx/srt_slurm/generate.py
@@ -49,6 +49,7 @@ def point_environment(point: Mapping[str, Any]) -> dict[str, str]:
         "THINKING_MODE": THINKING_MODE,
         "RUN_EVAL": "false",
         "EVAL_ONLY": "false",
+        "REQUIRE_POWER": "1" if point.get("require-power") else "0",
         "ROUTER_METADATA": json.dumps(point["router"]) if point.get("router") else "",
         "KV_OFFLOAD_BACKEND_METADATA": (
             json.dumps(point["kv-offload-backend"])
@@ -170,7 +171,10 @@ def _cluster_fabric(cluster: Cluster) -> dict[str, str | None]:
 
 
 def _apply_acceptance_and_validate(
-    recipe: dict[str, Any], environment: Mapping[str, str], source: str
+    recipe: dict[str, Any],
+    environment: Mapping[str, str],
+    source: str,
+    cluster_defaults: Mapping[str, Any] | None = None,
 ) -> None:
     """Apply golden-acceptance cleanup, then load the result as srtctl would."""
     from marshmallow import ValidationError
@@ -187,7 +191,9 @@ def _apply_acceptance_and_validate(
             [value for flag, value in pairs if flag == "--unset"],
         ),
     )
-    resolved = resolve_config_with_defaults(deepcopy(recipe), None)
+    resolved = resolve_config_with_defaults(
+        deepcopy(recipe), dict(cluster_defaults) if cluster_defaults else None
+    )
     expand_engine_config_defaults(resolved)
     try:
         SrtConfig.Schema().load(resolved)
@@ -235,7 +241,18 @@ def generate_recipes(
             if fabric is not None:
                 recipe = resolve_fabric(recipe, fabric)
             check_setup_script(recipe, root / point["srt-recipe"].partition(":")[0], root)
-            _apply_acceptance_and_validate(recipe, environment, point["srt-recipe"])
+            if "prefill" not in point:
+                clusters = {
+                    inventory.cluster_for(runner).id: inventory.cluster_for(runner)
+                    for runner in inventory.labels[point["runner"]]
+                }
+                for cluster in clusters.values():
+                    srt = slurm_settings(cluster).srt_slurm
+                    _apply_acceptance_and_validate(
+                        recipe, environment, point["srt-recipe"], srt.extra if srt else None
+                    )
+            else:
+                _apply_acceptance_and_validate(recipe, environment, point["srt-recipe"])
             identity = json.dumps({"point": point, "variant": variant}, sort_keys=True)
             digest = hashlib.sha256(identity.encode()).hexdigest()[:12]
             name = f"{re.sub(r'[^A-Za-z0-9_.-]', '_', key)}-{digest}.yaml"
diff --git a/inferencex-e2e/infx/srt_slurm/single_node.py b/inferencex-e2e/infx/srt_slurm/single_node.py
index bf64b507a1..c9f8b6c8ac 100644
--- a/inferencex-e2e/infx/srt_slurm/single_node.py
+++ b/inferencex-e2e/infx/srt_slurm/single_node.py
@@ -79,7 +79,11 @@ def select_recipe(
     path, _, selector = config.partition(":")
     agentic = environment["IS_AGENTIC"] == "1"
     raw = compose_recipe(
-        Path(path), agentic=agentic, multinode=False, root=root or repository_root()
+        Path(path),
+        agentic=agentic,
+        multinode=False,
+        root=root or repository_root(),
+        native_power=environment.get("EVAL_ONLY") != "true",
     )
     recipes = expand(raw, selector or None)
     matches = []
diff --git a/inferencex-e2e/infx/srt_slurm/workload.py b/inferencex-e2e/infx/srt_slurm/workload.py
index dd67fd3f64..50a8372552 100644
--- a/inferencex-e2e/infx/srt_slurm/workload.py
+++ b/inferencex-e2e/infx/srt_slurm/workload.py
@@ -31,6 +31,7 @@
 }
 BOUND_RECIPE = "recipe.yaml"
 TELEMETRY_BLOCK = Path("configs/srt-recipes/telemetry-dcgm.yaml")
+NATIVE_TELEMETRY_BLOCK = Path("configs/srt-recipes/telemetry-native.yaml")
 _POINT_KEYS = (
     ("model", "path"),
     ("model", "container"),
@@ -58,7 +59,13 @@
 BOUND_ENV = {
     (False, False): (*_FIXED_ENV, *_WORKFLOW_ENV, *_SINGLE_NODE_ENV),
     (False, True): (*_FIXED_ENV, *_WORKFLOW_ENV, *_MULTINODE_ENV),
-    (True, False): ("MODEL", *_AGENTIC_ENV, *_WORKFLOW_ENV, *_SINGLE_NODE_ENV),
+    (True, False): (
+        "MODEL",
+        *_AGENTIC_ENV,
+        *_WORKFLOW_ENV,
+        *_SINGLE_NODE_ENV,
+        "ENABLE_AGENTX_POWER",
+    ),
     (True, True): (
         "MODEL",
         *_AGENTIC_ENV,
@@ -126,7 +133,11 @@ def _fragment_versions(block: Any, path: str) -> Iterator[str]:
 
 def check_fragment(raw: Mapping[str, Any], source: Path, *, agentic: bool, multinode: bool) -> None:
     """Reject a fragment that sets a bound key, even to the value the binder would write."""
-    keys = (*_POINT_KEYS, *(("benchmark", "env", name) for name in BOUND_ENV[agentic, multinode]))
+    keys = (
+        *_POINT_KEYS,
+        *(("benchmark", "env", name) for name in BOUND_ENV[agentic, multinode]),
+        *(() if multinode else (("telemetry", "required"),)),
+    )
     if "base" in raw:
         blocks = [(name, block) for name, block in raw.items() if name != "schema"]
     else:
@@ -170,7 +181,13 @@ def check_setup_script(recipe: Mapping[str, Any], source: Path, root: Path) -> N
 
 
 def compose_recipe(
-    path: Path, *, agentic: bool, multinode: bool, root: Path, power_port: int | None = None
+    path: Path,
+    *,
+    agentic: bool,
+    multinode: bool,
+    root: Path,
+    power_port: int | None = None,
+    native_power: bool = False,
 ) -> dict[str, Any]:
     """The fragment at ``path`` over its lane's shared block, under ``base`` for bundles.
 
@@ -181,6 +198,8 @@ def compose_recipe(
         raise ValueError(f"{path}: recipe must be a mapping")
     check_fragment(raw, path, agentic=agentic, multinode=multinode)
     shared = _block(root / SHARED_BLOCKS[agentic, multinode])
+    if native_power:
+        shared = merge_blocks(shared, _block(root / NATIVE_TELEMETRY_BLOCK))
     if power_port is not None:
         exporter = {"telemetry": {"dcgm_exporter": {"port": power_port}}}
         shared = merge_blocks(shared, merge_blocks(_block(root / TELEMETRY_BLOCK), exporter))
@@ -313,6 +332,14 @@ def bind_workload(
     )
     if (bound.get("telemetry") or {}).get("enabled") is True:
         benchmark["concurrencies"] = concurrencies
+        if not multinode:
+            required = environment.get("REQUIRE_POWER", "0") in {"1", "true", "TRUE", "yes", "YES"}
+            bound["telemetry"]["required"] = required
+            workload["REQUIRE_POWER"] = "1" if required else "0"
+    if agentic and not multinode:
+        workload["ENABLE_AGENTX_POWER"] = (
+            "1" if (bound.get("telemetry") or {}).get("enabled") is True else "0"
+        )
     _bind_components(bound, environment)
     return bound
 
diff --git a/inferencex-e2e/infx/tests/bench/test_agentic_command.py b/inferencex-e2e/infx/tests/bench/test_agentic_command.py
index 694aa48478..260809124b 100644
--- a/inferencex-e2e/infx/tests/bench/test_agentic_command.py
+++ b/inferencex-e2e/infx/tests/bench/test_agentic_command.py
@@ -28,6 +28,11 @@
     "RESULT_FILENAME": "agentx",
     "EVAL_ONLY": "false",
     "IS_MULTINODE": "false",
+    "ENABLE_AGENTX_POWER": "0",
+    "REQUIRE_POWER": "0",
+    "TP": "3",
+    "PP_SIZE": "2",
+    "PCP_SIZE": "2",
     "IS_AGENTIC": "1",
     "KV_OFFLOADING": "none",
     "PRECISION": "fp4",
@@ -54,12 +59,21 @@
     *) echo "unexpected $*" >> "$EVENTS"; exit 99 ;;
 esac
 """
-FAKE_AIPERF = r"""#!/bin/sh
-echo replay >> "$EVENTS"
-sleep "${REPLAY_SECONDS:-0}"
-exit "${REPLAY_RC:-0}"
+FAKE_AIPERF = f"""#!{sys.executable}
+import os, time
+with open(os.environ["EVENTS"], "a") as events:
+    events.write("replay\\n")
+time.sleep(float(os.environ.get("REPLAY_SECONDS", "0")))
+raise SystemExit(int(os.environ.get("REPLAY_RC", "0")))
 """
 FAKE_HF = '#!/bin/sh\nexit "${HF_RC:-0}"\n'
+FAKE_NVIDIA_SMI = r"""#!/bin/sh
+case " $* " in
+    *" -l 1 "*) exec sleep 60 ;;
+    *noheader*) echo gpu-final-sample >> "$EVENTS" ;;
+    *) echo gpu-identity >> "$EVENTS" ;;
+esac
+"""
 DRIVER = """
 import os, sys
 from pathlib import Path
@@ -69,6 +83,16 @@
 """
 
 
+@pytest.fixture(autouse=True)
+def fake_gpu(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    """Keep an accidental sampler invocation observable and isolated from hardware."""
+    tools = tmp_path / "gpu"
+    tools.mkdir()
+    executable(tools / "nvidia-smi", FAKE_NVIDIA_SMI)
+    monkeypatch.setenv("PATH", f"{tools}{os.pathsep}{os.environ['PATH']}")
+    monkeypatch.setenv("EVENTS", str(tmp_path / "events.log"))
+
+
 def _point(tmp_path: Path, **overrides: str | None) -> dict[str, str]:
     env = {
         **POINT,
@@ -129,7 +153,10 @@ def _events(tmp_path: Path) -> list[str]:
         ({"CONC": "4 8", "CONC_LIST": "4 8"}, "CONC must be a positive integer"),
         ({"IS_MULTINODE": "1"}, "IS_MULTINODE must be true or false"),
         ({"EVAL_ONLY": "true"}, "  - EVAL_ENDPOINT_READY_TIMEOUT_SECONDS"),
-        ({"IS_MULTINODE": "true"}, "  - ENABLE_AGENTX_POWER\n  - REQUIRE_POWER"),
+        (
+            {"IS_MULTINODE": "true", "ENABLE_AGENTX_POWER": None, "REQUIRE_POWER": None},
+            "  - ENABLE_AGENTX_POWER\n  - REQUIRE_POWER",
+        ),
     ],
 )
 def test_points_that_cannot_be_measured_fail_before_setup(tmp_path, overrides, message):
@@ -152,15 +179,28 @@ def test_standalone_srt_slurm_point_needs_no_kv_offload_declaration(tmp_path):
 REPLAYED = {"benchmark.log", "benchmark_command.txt"}
 
 
+def test_single_node_native_power_records_windows_without_local_sampler(tmp_path):
+    rc = _run(tmp_path, ENABLE_AGENTX_POWER="1", SRT_MEASUREMENT_WINDOW_DIR="/w")
+
+    assert rc == 0
+    results = tmp_path / "results"
+    mark = f"adapter --result-dir {results} --concurrency 8 --write-multinode-window"
+    assert _events(tmp_path) == [
+        f"{mark} running", "replay", "aggregate agentx", f"{mark} completed",
+        "analyze", "validate",
+    ]
+    assert not (results / "gpu_metrics.csv").exists()
+
+
 @pytest.mark.parametrize(
     ("overrides", "rc", "events", "files"),
     [
         pytest.param(
-            {"ENABLE_AGENTX_POWER": "1", "REQUIRE_POWER": "1"},
+            {},
             0,
             ["replay", "aggregate agentx", "analyze", "validate"],
             REPLAYED,
-            id="single-node-publishes-no-power",
+            id="power-off",
         ),
         pytest.param(
             {**WINDOW, "ENABLE_AGENTX_POWER": "0", "KV_OFFLOADING": "dram",
@@ -170,6 +210,17 @@ def test_standalone_srt_slurm_point_needs_no_kv_offload_declaration(tmp_path):
             {f"conc_8/{name}" for name in REPLAYED},
             id="multi-node-opt-out",
         ),
+        pytest.param(
+            {"ENABLE_AGENTX_POWER": "1", "REQUIRE_POWER": "1"},
+            0,
+            [
+                "replay", "aggregate agentx", "adapter --result-dir {results} --agg-result {out}/agentx.json"
+                " --multinode-contract-missing --require-power",
+                "analyze", "validate",
+            ],
+            REPLAYED,
+            id="single-node-without-native-window",
+        ),
         pytest.param(
             WINDOW,
             0,
@@ -193,11 +244,11 @@ def test_standalone_srt_slurm_point_needs_no_kv_offload_declaration(tmp_path):
             id="unpublished-window-skips-the-replay",
         ),
         pytest.param(
-            MISSING,
+            {"IS_MULTINODE": "true", "ENABLE_AGENTX_POWER": "1"},
             0,
             [
                 "replay", "aggregate agentx_conc8", "adapter --result-dir {results}/conc_8 --agg-result {out}/agentx_conc8.json"
-                " --multinode-contract-missing --require-power",
+                " --multinode-contract-missing",
                 "analyze", "validate",
             ],
             {f"conc_8/{name}" for name in REPLAYED},
@@ -231,7 +282,7 @@ def test_every_step_runs_and_the_first_failure_in_precedence_wins(
 ):
     rc = _run(
         tmp_path,
-        **MISSING,
+        ENABLE_AGENTX_POWER="1",
         REPLAY_RC=replay,
         AGGREGATE_RC=aggregate,
         VALIDATE_RC=validate,
@@ -266,7 +317,7 @@ def test_required_server_metrics_gate_an_otherwise_clean_point(tmp_path, csv, pr
 
 def test_signal_during_the_replay_skips_scoring_and_exits_128_plus_n(tmp_path):
     runtime = _runtime(tmp_path)
-    env = _point(tmp_path, REPLAY_SECONDS="60", PYTHONPATH=str(REPO_ROOT))
+    env = _point(tmp_path, ENABLE_AGENTX_POWER="1", REPLAY_SECONDS="60", PYTHONPATH=str(REPO_ROOT))
     driver = subprocess.Popen(
         [sys.executable, "-c", DRIVER, str(runtime.root)],
         env=env,
@@ -278,6 +329,9 @@ def test_signal_during_the_replay_skips_scoring_and_exits_128_plus_n(tmp_path):
     try:
         deadline = time.monotonic() + 10
         while "replay" not in _events(tmp_path):
+            if driver.poll() is not None:
+                _, stderr = driver.communicate()
+                pytest.fail(f"driver exited before replay: {stderr}")
             assert time.monotonic() < deadline, "the replay did not start"
             time.sleep(0.01)
         os.killpg(driver.pid, signal.SIGINT)
diff --git a/inferencex-e2e/infx/tests/bench/test_fixed_seq.py b/inferencex-e2e/infx/tests/bench/test_fixed_seq.py
index fd173faf52..9919f20b5c 100644
--- a/inferencex-e2e/infx/tests/bench/test_fixed_seq.py
+++ b/inferencex-e2e/infx/tests/bench/test_fixed_seq.py
@@ -41,7 +41,11 @@ def finish(signum, _frame):
 argv = sys.argv[1:]
 value = lambda flag: argv[argv.index(flag) + 1]
 result = Path(value("--result-dir")) / value("--result-filename")
-record = {"argv": argv, "safe_path": os.environ.get("PYTHONSAFEPATH")}
+record = {
+    "argv": argv,
+    "monitored": (result.parent / "gpu_metrics.csv").exists(),
+    "safe_path": os.environ.get("PYTHONSAFEPATH"),
+}
 with open(os.environ["FAKE_CLIENT_LOG"], "a") as log:
     log.write(json.dumps(record) + "\\n")
 while trap:
@@ -59,17 +63,21 @@ def tools(tmp_path: Path) -> Path:
     """PATH with a stub benchmark client behind python3."""
     bin_dir = tmp_path / "bin"
     bin_dir.mkdir()
-    for tool in ("sh", "dirname", "env"):
+    for tool in ("sh", "sleep", "dirname", "env"):
         (bin_dir / tool).symlink_to(shutil.which(tool))
     (tmp_path / "fake_client.py").write_text(FAKE_CLIENT)
     python, client = shlex.quote(sys.executable), shlex.quote(str(tmp_path / "fake_client.py"))
-    executable(bin_dir / "python3", f"""#!/bin/sh
+    stubs = {
+        "python3": f"""
 if [ "$1 $2" = "-m infx.bench_serving.benchmark_serving" ]; then
     shift 2
     exec {python} {client} "$@"
 fi
 exec {python} "$@"
-""")
+""",
+    }
+    for name, body in stubs.items():
+        executable(bin_dir / name, f"#!/bin/sh\n{body}")
     return bin_dir
 
 
@@ -121,6 +129,7 @@ def single_node_env(tmp_path: Path, tools: Path, **overrides: str | None) -> dic
         "SRT_FRONTEND_PORT": "8000",
         "RUN_EVAL": "false",
         "EVAL_ONLY": "false",
+        "SRT_MEASUREMENT_WINDOW_DIR": None,
         "USE_CHAT_TEMPLATE": "false",
         "FRAMEWORK": "sglang",
         **overrides,
@@ -177,6 +186,25 @@ def point_argv(result: Path) -> list[str]:
     return ["fixed-seq", "point", *(token for pair in flags.items() for token in pair)]
 
 
+@pytest.mark.parametrize("client_failed", [True, False])
+def test_single_node_does_not_report_success_without_a_completed_window(
+    tmp_path, tools, client_failed,
+):
+    windows = tmp_path / "logs" / "power" / "windows"
+    if client_failed:
+        windows.mkdir(parents=True)
+    env = single_node_env(
+        tmp_path, tools, SRT_MEASUREMENT_WINDOW_DIR=str(windows),
+        FAKE_CLIENT_FAIL_CONC="4" if client_failed else "",
+    )
+
+    result = run_shim("single_node/srt_fixed_sequence.sh", env)
+
+    assert result.returncode == (3 if client_failed else 1)
+    assert len(client_runs(tmp_path)) == 1
+    assert not (windows / "point_conc4.json").exists()
+
+
 @pytest.mark.parametrize(
     ("framework", "chat_template", "args", "flags"),
     [
@@ -184,10 +212,15 @@ def point_argv(result: Path) -> list[str]:
         ("trt", "false", ["--trust-remote-code"], {"--backend": "openai", "--trust-remote-code": True}),
     ],
 )
-def test_single_node_shim_runs_one_point_and_writes_only_its_result(
+def test_single_node_shim_runs_one_point_with_native_power(
     tmp_path, tools, framework, chat_template, args, flags
 ):
-    env = single_node_env(tmp_path, tools, FRAMEWORK=framework, USE_CHAT_TEMPLATE=chat_template)
+    windows = tmp_path / "logs" / "power" / "windows"
+    windows.mkdir(parents=True)
+    env = single_node_env(
+        tmp_path, tools, FRAMEWORK=framework, USE_CHAT_TEMPLATE=chat_template,
+        SRT_MEASUREMENT_WINDOW_DIR=str(windows),
+    )
 
     result = run_shim("single_node/srt_fixed_sequence.sh", env, *args)
 
@@ -208,8 +241,15 @@ def test_single_node_shim_runs_one_point_and_writes_only_its_result(
         "--result-filename": "point_conc4.json",
         **flags,
     }
-    assert [path.name for path in logs.iterdir()] == ["point_conc4.json"]
+    assert (logs / "point_conc4.json").is_file()
+    assert not run["monitored"]
     assert run["safe_path"] is None
+    assert not (logs / "gpu_metrics.csv").exists()
+    window = json.loads((windows / "point_conc4.json").read_text())
+    assert window["result_path"] == "point_conc4.json"
+    assert window["concurrency"] == 4
+    assert (window["benchmark_start_time_unix"], window["benchmark_end_time_unix"]) == (100, 160)
+    assert window["status"] == "completed"
 
 
 @pytest.mark.parametrize(
@@ -220,8 +260,10 @@ def test_single_node_shim_runs_one_point_and_writes_only_its_result(
         ({"FRAMEWORK": "no-such-framework"}, 1, "ERROR: unsupported fixed-sequence FRAMEWORK: no-such-framework\n"),
         ({"USE_CHAT_TEMPLATE": "yes"}, 1, "ERROR: USE_CHAT_TEMPLATE must be true or false, got 'yes'\n"),
         ({"RESULT_DIR": "/nonexistent/logs"}, 1, "ERROR: RESULT_DIR must be an existing"),
+        ({}, 1, "SRT_MEASUREMENT_WINDOW_DIR"),
     ],
-    ids=["eval-only", "missing", "unsupported-framework", "malformed-flag", "no-result-dir"],
+    ids=["eval-only", "missing", "unsupported-framework", "malformed-flag", "no-result-dir",
+         "missing-native-power"],
 )
 def test_single_node_point_runs_nothing_when_eval_only_or_misconfigured(
     tmp_path, tools, monkeypatch, capsys, overrides, returncode, reported
diff --git a/inferencex-e2e/infx/tests/launch/fake_slurm.py b/inferencex-e2e/infx/tests/launch/fake_slurm.py
index 6b6852863d..b07b4986ab 100644
--- a/inferencex-e2e/infx/tests/launch/fake_slurm.py
+++ b/inferencex-e2e/infx/tests/launch/fake_slurm.py
@@ -115,6 +115,8 @@
 result = os.environ["RESULT_FILENAME"]
 mode = os.environ["FAKE_RESULTS"]
 if mode == "single":
+    (logs / "power").mkdir()
+    (logs / "power/samples.csv").write_text("retained native samples\n")
     (logs / f"{result}.json").write_text('{"completed": 2}')
 elif mode == "fixed":
     point = logs / "sweep_isl_1024_osl_1024"
@@ -252,6 +254,7 @@ def base_env(*, fakes: Path, logs: Path, workspace: Path, sandbox: Path) -> dict
         EVAL_ONLY="false",
         RUN_EVAL="false",
         REQUIRE_POWER="0",
+        INFERENCEX_RESULTS_PYTHON=sys.executable,
         RESULT_FILENAME="point-identity",
         GITHUB_RUN_ID="9001",
         GITHUB_RUN_ATTEMPT="1",
diff --git a/inferencex-e2e/infx/tests/launch/test_srt_collect_staging.py b/inferencex-e2e/infx/tests/launch/test_srt_collect_staging.py
new file mode 100644
index 0000000000..e792c6b316
--- /dev/null
+++ b/inferencex-e2e/infx/tests/launch/test_srt_collect_staging.py
@@ -0,0 +1,68 @@
+"""Exit staging of a single-node point: power-package copies are best-effort unless power is required."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from infx.launch.drivers.srt import collect
+from infx.launch.drivers.srt.config import EXPORTER_PROVENANCE
+
+
+class _Backend:
+    def __init__(self, output: Path) -> None:
+        self.output = output
+        self.cancelled: list[object] = []
+
+    def cancel(self, job: object) -> None:
+        self.cancelled.append(job)
+
+    def fetch_outputs(self, job: object, fetched: Path) -> Path:
+        return self.output
+
+
+def _point(tmp_path: Path, *, require_power: bool) -> tuple[SimpleNamespace, SimpleNamespace, Path]:
+    output = tmp_path / "outputs" / "42"
+    logs = output / "logs"
+    (logs / "power").mkdir(parents=True)
+    (logs / "power" / "samples.csv").write_text("retained native samples\n")
+    (logs / "point.json").write_text('{"completed": 2}\n')
+    workspace = tmp_path / "workspace"
+    workspace.mkdir()
+    for name in (EXPORTER_PROVENANCE, "power-producer-sha.txt"):
+        (workspace / name).write_text(f"{name}\n")
+    request = SimpleNamespace(eval_only=False, require_power=require_power, result_filename="point")
+    run = SimpleNamespace(backend=_Backend(output), request=request, workspace=workspace)
+    submitted = SimpleNamespace(recover=lambda backend: object())
+    return run, submitted, workspace
+
+
+@pytest.mark.parametrize("require_power", [False, True])
+def test_power_package_copy_failure_fails_the_point_only_when_power_is_required(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], require_power: bool
+) -> None:
+    run, submitted, workspace = _point(tmp_path, require_power=require_power)
+
+    def exploding_copytree(*args: object, **kwargs: object) -> None:
+        raise OSError("No space left on device")
+
+    monkeypatch.setattr(shutil, "copytree", exploding_copytree)
+
+    rc = collect.finish_single_node(run, submitted, tmp_path / "fetched")
+
+    assert rc == int(require_power)
+    assert (workspace / "point.json").read_text() == '{"completed": 2}\n'
+    level = "ERROR" if require_power else "WARNING"
+    assert f"{level}: failed to stage the native power package" in capsys.readouterr().err
+
+
+def test_power_package_is_staged_beside_the_result(tmp_path: Path) -> None:
+    run, submitted, workspace = _point(tmp_path, require_power=True)
+
+    assert collect.finish_single_node(run, submitted, tmp_path / "fetched") == 0
+    assert (workspace / "LOGS" / "power" / "samples.csv").read_text() == "retained native samples\n"
+    assert (workspace / "LOGS" / "power" / "power-producer-sha.txt").is_file()
+    assert (workspace / "point.json").is_file()
diff --git a/inferencex-e2e/infx/tests/launch/test_srt_config.py b/inferencex-e2e/infx/tests/launch/test_srt_config.py
index a968043b13..959a05f3b5 100644
--- a/inferencex-e2e/infx/tests/launch/test_srt_config.py
+++ b/inferencex-e2e/infx/tests/launch/test_srt_config.py
@@ -26,6 +26,29 @@
 ROOT = Path(__file__).resolve().parents[3]
 sys.path.insert(0, str(ROOT / "utils/srt-slurm/src"))
 from srtctl.core.config import resolve_config_with_defaults  # noqa: E402
+from srtctl.core.schema import ClusterConfig  # noqa: E402
+
+AMD_EXPORTER = {
+    "container_image": "ghcr.io#semianalysisai/amd-device-metrics-exporter@sha256:"
+    "0d1c32c965f955b0fbf1dc87a84f7205be9019ce8d2fdf1eb929de28c71cec54",
+    "port": 19500,
+    "command": "/home/amd/tools/entrypoint.sh",
+    "kind": "custom",
+    "gpu_labels": {"index": "gpu_id", "identity": "serial_number"},
+    "gpu_metrics": {
+        "power": {
+            "metric": "gpu_power_usage",
+            "scope": "gpu_device_power_as_reported_by_amd_device_metrics_exporter",
+        },
+        "gpu_util": {"metric": "gpu_gfx_activity"},
+        "temperature": {"metric": "gpu_junction_temperature"},
+    },
+}
+DCGM_EXPORTER = {
+    "container_image": "nvcr.io#nvidia/k8s/dcgm-exporter:4.6.0-4.8.3-distroless",
+    "port": 9401,
+    "command": "dcgm-exporter --collect-interval=1000 --address :{port} -f /configs/dcgm-counters-noprof.csv",
+}
 
 
 def cluster(slurm: dict | None = None, srt: dict | None = None, entries: dict | None = None) -> Cluster:
@@ -62,6 +85,7 @@ def test_the_profile_renders_its_facts_and_mounts_a_volume_at_a_second_target():
             },
             "volume-mounts": {"hub": "/hf_hub_cache/hub"},
             "mounts": {"/dev/kfd": "/dev/kfd"},
+            "workspace-mounts": {"runners/exporter.json": "/etc/exporter.json"},
             "extra": {"visible_devices_env": "ROCR_VISIBLE_DEVICES", "default_gpu_exporter": None},
         },
         entries={"Model-A": {"root": "data", "dir": "Model-A"}},
@@ -71,6 +95,7 @@ def test_the_profile_renders_its_facts_and_mounts_a_volume_at_a_second_target():
         "/share/hub": "/hf_hub_cache/hub",
         "/dev/kfd": "/dev/kfd",
         "/share/hub/": "/mnt/hf_hub_cache/",
+        "/ws/runners/exporter.json": "/etc/exporter.json",
     }
     assert config["default_host_setup"] == {
         "commands": ["IBDEVICES=rdma0,rdma1 bash /ws/runners/hooks/setup.sh"],
@@ -85,6 +110,20 @@ def test_the_profile_renders_its_facts_and_mounts_a_volume_at_a_second_target():
     assert config["cluster"] == "c"
 
 
+@pytest.mark.parametrize("exporter", [AMD_EXPORTER, DCGM_EXPORTER])
+def test_rendered_exporter_defaults_resolve_for_native_telemetry(exporter):
+    config = render(cluster(srt={"extra": {"default_gpu_exporter": exporter}}), job(single_node=True))
+    ClusterConfig.Schema().load(config)
+    recipe = {"schema": 2, "name": "point", "telemetry": {"enabled": True}}
+    assert resolve_config_with_defaults(recipe, config)["telemetry"]["dcgm_exporter"]["port"] == exporter["port"]
+
+
+@pytest.mark.parametrize("source,target", [("/absolute", "/config"), ("../escape", "/config"), ("", "/config"), ("config.json", "relative")])
+def test_workspace_mounts_reject_paths_outside_the_repository_or_container(source, target):
+    with pytest.raises(ValueError, match="workspace-mounts"):
+        cluster(srt={"workspace-mounts": {source: target}})
+
+
 def test_a_host_directory_cannot_be_mounted_at_three_targets():
     record = cluster(slurm={"volumes": {"hub": {"path": "/share/hub"}}}, srt={"volume-mounts": {"hub": "/hf_hub_cache"}})
     with pytest.raises(ValueError, match="conflicting container paths"):
diff --git a/inferencex-e2e/infx/tests/launch/test_srt_driver.py b/inferencex-e2e/infx/tests/launch/test_srt_driver.py
index 9bde38dc13..6fbbfffc44 100644
--- a/inferencex-e2e/infx/tests/launch/test_srt_driver.py
+++ b/inferencex-e2e/infx/tests/launch/test_srt_driver.py
@@ -23,6 +23,7 @@
 from infx.launch.drivers.srt.models import Override
 from infx.launch.policy import LaunchPath, Match
 from infx.tests.launch.fake_slurm import (
+    ROOT,
     base_env,
     install_fakes,
     launch,
@@ -33,7 +34,13 @@
     srtctl_calls,
 )
 
+sys.path.insert(0, str(ROOT / "utils/srt-slurm/src"))
+from srtctl.core.config import resolve_config_with_defaults  # noqa: E402
+from srtctl.core.overrides import apply_overrides_to_recipe, parse_overrides  # noqa: E402
+from srtctl.core.schema import ClusterConfig  # noqa: E402
+
 POINT_RECIPE = {
+    "schema": 2,
     "engine": "sglang",
     "resources": {"gpus_per_node": 8},
     "roles": {"agg": {
@@ -152,6 +159,46 @@ def test_single_node_point_stages_workflow_artifacts(harness):
     assert lines(harness.logs, "scancel") == []
 
 
+@pytest.mark.parametrize("require_power", ["0", "1"])
+@pytest.mark.parametrize(("cluster_id", "kind", "port"), [
+    ("mi355x-amds", "custom", 19500), ("h200-cw", "dcgm", 9401),
+])  # fmt: skip
+def test_single_node_native_power_is_bound_and_retained(harness, require_power, cluster_id, kind, port):
+    env = single_node_env(harness, cluster_id, REQUIRE_POWER=require_power)
+    assert_ok(launch(env, harness.config, harness.workspace))
+
+    workspace = harness.workspace
+    [call] = srtctl_calls(harness.logs)
+    argv = call["argv"]
+    selected = Path(argv[argv.index("--file") + 1])
+    assert selected.name == "recipe.yaml"
+    rendered = srtslurm(workspace)
+    ClusterConfig.Schema().load(rendered)
+    variant = yaml.safe_load(selected.read_text())
+    sets = [argv[i + 1] for i, arg in enumerate(argv) if arg == "--set"]
+    apply_overrides_to_recipe(variant, parse_overrides(sets, []))
+    resolved = resolve_config_with_defaults(variant, rendered)
+    telemetry = resolved["telemetry"]
+    assert telemetry["enabled"] is True
+    assert telemetry["required"] is (require_power == "1")
+    assert telemetry["storage_subdir"] == "power"
+    assert telemetry["startup_timeout_seconds"] == 300.0
+    assert resolved["benchmark"]["concurrencies"] == [2]
+    cluster_exporter = rendered["default_gpu_exporter"]
+    staged = rendered["containers"][cluster_exporter["container_image"]]
+    assert telemetry["dcgm_exporter"] == {**cluster_exporter, "container_image": staged}
+    assert (cluster_exporter.get("kind", "dcgm"), cluster_exporter["port"]) == (kind, port)
+    exporter_config = rendered["default_mounts"].get(str(workspace / "runners/srt-slurm/exporters/amd-power.json"))
+    assert (exporter_config == "/etc/metrics/config.json") is (kind == "custom")
+    assert "AMD_DME" not in yaml.safe_dump(rendered) + " ".join(argv)
+    assert (workspace / "exporter-image.sha256").read_text().rstrip("\n").endswith(staged)
+    assert (workspace / "LOGS/power/samples.csv").read_text() == "retained native samples\n"
+    assert (workspace / "LOGS/power/power-producer-sha.txt").read_text() == env["FAKE_SRT_COMMIT"] + "\n"
+    assert (workspace / "LOGS/power/native-job-status.txt").read_text() == "42|COMPLETED|0:0\n"
+    assert (workspace / "LOGS/point-identity.json").is_file()
+    assert (workspace / "power-producer-sha.txt").read_text() == env["FAKE_SRT_COMMIT"] + "\n"
+
+
 def test_single_node_eval_requires_a_successful_eval(harness):
     env = single_node_env(harness, "h100-cw", RUN_EVAL="true", MAX_MODEL_LEN="1024")
     assert_ok(launch(env, harness.config, harness.workspace))
@@ -365,17 +412,24 @@ def test_sigterm_while_streaming_cancels_the_job_and_exits_143(harness, shape):
         env = lane_env(harness, "b300-dsxe", MODEL_PREFIX="dsr1", PRECISION="fp4", FRAMEWORK="dynamo-trt",
                        MODEL="deepseek-r1-fp4", **extra)  # fmt: skip
     command = [sys.executable, "-m", "infx.launch", "--runner-config", str(harness.config), "run"]
-    process = subprocess.Popen(
-        command, cwd=harness.workspace, env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
-    )
-    deadline = time.monotonic() + 120
-    while not tailing.exists():
-        assert process.poll() is None, process.communicate()
-        assert time.monotonic() < deadline, "the launcher never started streaming"
-        time.sleep(0.1)
-    process.send_signal(signal.SIGTERM)
-    stdout, stderr = process.communicate(timeout=60)
-    assert process.returncode == 143, stdout[-2000:] + stderr[-4000:]
+    output = harness.tmp / "launcher.log"
+    with output.open("w") as stream:
+        process = subprocess.Popen(
+            command,
+            cwd=harness.workspace,
+            env=env,
+            stdout=stream,
+            stderr=subprocess.STDOUT,
+            text=True,
+        )
+        deadline = time.monotonic() + 120
+        while not tailing.exists():
+            assert process.poll() is None, output.read_text()[-4000:]
+            assert time.monotonic() < deadline, "the launcher never started streaming"
+            time.sleep(0.1)
+        process.send_signal(signal.SIGTERM)
+        process.wait(timeout=60)
+    assert process.returncode == 143, output.read_text()[-4000:]
     assert lines(harness.logs, "scancel") == ["42"]
     staged = "srt-single-node-logs.tar.gz" if shape == "single" else "multinode_server_logs.tar.gz"
     assert (harness.workspace / staged).stat().st_size > 0
@@ -395,7 +449,14 @@ def test_b300_flash_agentx_reenters_inside_a_batch_allocation(harness):
     [submit] = lines(harness.logs, "sbatch")
     assert {"--nodes=1", "--ntasks=1", f"--chdir={harness.workspace}", "--time=10"} <= set(submit.split())
     assert (harness.logs / "batch-rc").read_text() == "0"
-    assert json.loads((harness.workspace / "point-identity.json").read_text()) == {"completed": 2}
+    aggregate = json.loads((harness.workspace / "point-identity.json").read_text())
+    assert aggregate["completed"] == 2
+    assert aggregate["power_valid"] == 0
+    assert "agentic_gpu_topology_invalid" in aggregate["power_invalid_reasons"]
+    assert aggregate["power_audit"]["source"] == "power_validation_point-identity.json"
+    sidecar = json.loads((harness.workspace / "power_validation_point-identity.json").read_text())
+    assert sidecar["power_valid"] is False
+    assert "agentic_gpu_topology_invalid" in sidecar["reasons"]
     assert len(srtctl_calls(harness.logs)) == 1
     assert "4242" in lines(harness.logs, "scancel")
     assert list(runner_temp.glob("srt-batch.*.sh")) == []
diff --git a/inferencex-e2e/infx/tests/results/agentic/test_power_adapter.py b/inferencex-e2e/infx/tests/results/agentic/test_power_adapter.py
index e62682e983..9cfa948c33 100644
--- a/inferencex-e2e/infx/tests/results/agentic/test_power_adapter.py
+++ b/inferencex-e2e/infx/tests/results/agentic/test_power_adapter.py
@@ -7,9 +7,76 @@
 import subprocess
 import sys
 from pathlib import Path
+from types import SimpleNamespace
 
 import pytest
 
+from infx.tests.results.power.test_aggregate_power_multinode import PRODUCER_SHA, build_package
+
+
+@pytest.mark.parametrize("require_power", [False, True])
+@pytest.mark.parametrize("failure", [None, "samples_csv_missing", "agentic_gpu_topology_invalid",
+                                     "producer_commit_mismatch"])
+def test_single_node_collector_finalizes_native_agentx_power(
+    tmp_path: Path, require_power: bool, failure: str | None,
+) -> None:
+    from infx.launch.drivers.srt.collect import finalize_single_node_results
+
+    pkg = build_package(tmp_path)
+    result_dir = pkg.logs_root / "agentic"
+    result_dir.mkdir()
+    stem = "agentic_power_concurrency_4"
+    pkg.original_result.replace(result_dir / f"{stem}.json")
+    old_window = pkg.windows_dir / "my_result.json"
+    window = json.loads(old_window.read_text())
+    window.update(benchmark_type="custom", result_path=f"agentic/{stem}.json")
+    old_window.unlink()
+    (pkg.windows_dir / f"{stem}.json").write_text(json.dumps(window))
+    manifest_path = pkg.power_dir / "manifest.json"
+    manifest = json.loads(manifest_path.read_text())
+    for device in manifest["expected_devices"]:
+        for assignment in device["assignments"]:
+            assignment.update(worker_role="agg", het_group=None)
+    manifest["expected_windows"] = [{"benchmark_type": "custom", "concurrency": 4}]
+    manifest["window_validations"][0].update(
+        benchmark_type="custom", window_file=f"windows/{stem}.json"
+    )
+    manifest_path.write_text(json.dumps(manifest))
+    aggregate_path = pkg.logs_root / "point.json"
+    aggregate_path.write_text(json.dumps({
+        "conc": 4, "num_gpus": 0 if failure == "agentic_gpu_topology_invalid" else 4,
+        "is_multinode": False, "disagg": False,
+        "power_valid": 1, "avg_power_w": 999, "total_gpu_energy_j": 999,
+    }))
+    if failure == "samples_csv_missing":
+        (pkg.power_dir / "samples.csv").unlink()
+    env = {**os.environ, "INFERENCEX_RESULTS_PYTHON": sys.executable,
+           "REQUIRE_POWER": str(int(require_power)),
+           "PYTHONPATH": str(Path(__file__).resolve().parents[4])}
+    request = SimpleNamespace(is_agentic=True, eval_only=False, run_eval=False,
+                              require_power=require_power, inferencex_results_python=sys.executable,
+                              result_filename="point", env=env)
+    run = SimpleNamespace(request=request, env=env, workspace=tmp_path)
+    producer_sha = "b" * 40 if failure == "producer_commit_mismatch" else PRODUCER_SHA
+    assert finalize_single_node_results(run, pkg.logs_root, producer_sha) == int(require_power and failure is not None)
+    aggregate = json.loads(aggregate_path.read_text())
+    validation = json.loads((tmp_path / "power_validation_point.json").read_text())
+    assert not (result_dir / "power_validation.json").exists()
+    assert aggregate["power_valid"] == int(failure is None)
+    assert aggregate["power_audit"]["source"] == "power_validation_point.json"
+    if failure is None:
+        assert aggregate["total_gpu_energy_j"] == 84_000
+        assert aggregate["avg_power_w"] == 350
+        assert aggregate["power_audit"]["expected_gpu_count"] == 4
+        assert aggregate["power_audit"]["producer_sha"] == PRODUCER_SHA
+        assert aggregate["power_invalid_reasons"] == []
+    else:
+        assert "avg_power_w" not in aggregate
+        assert "total_gpu_energy_j" not in aggregate
+        reason = "package_recompute_invalid" if failure == "samples_csv_missing" else failure
+        assert reason in aggregate["power_invalid_reasons"]
+        assert reason in validation["reasons"]
+
 
 @pytest.mark.parametrize("require_power", [False, True])
 @pytest.mark.parametrize(
@@ -350,112 +417,6 @@ def test_multinode_window_writer_fails_closed_on_invalid_window_environment(
     assert "formal measurement-window contract" in capsys.readouterr().err
 
 
-def test_multinode_aggregation_uses_central_package_and_aggregate_topology(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-):
-    from infx.results.agentic import power_adapter
-
-    logs_root = tmp_path / "logs"
-    result_dir = logs_root / "agentic" / "conc_8"
-    result_dir.mkdir(parents=True)
-    bench_result = result_dir / "agentic_power_concurrency_8.json"
-    bench_result.write_text(json.dumps({"max_concurrency": 8}))
-    agg_result = tmp_path / "agg_agentx_conc8.json"
-    agg_result.write_text(
-        json.dumps(
-            {"disagg": True, "num_prefill_gpu": 16, "num_decode_gpu": 16}
-        ),
-        encoding="utf-8",
-    )
-    power_dir = logs_root / "power"
-    power_dir.mkdir(parents=True)
-    calls: list[dict] = []
-
-    def fake_run(**kwargs) -> int:
-        calls.append(kwargs)
-        return 0
-
-    monkeypatch.setattr(power_adapter, "run_multinode_power", fake_run)
-
-    exit_code = power_adapter.run_multinode_agentic_power(
-        result_dir=result_dir,
-        agg_result=agg_result,
-        power_dir=power_dir,
-        logs_root=logs_root,
-        expected_producer_sha="a1b8c7af10c00e5ea40074aebdc0086189bbc064",
-        require_power=True,
-    )
-
-    assert exit_code == 0
-    assert calls == [
-        {
-            "power_dir": power_dir,
-            "bench_result": bench_result,
-            "agg_result": agg_result,
-            "prefill_gpus": 16,
-            "decode_gpus": 16,
-            "aggregate_gpus": 0,
-            "expected_producer_sha": "a1b8c7af10c00e5ea40074aebdc0086189bbc064",
-            "logs_root": logs_root,
-            "validation_result": result_dir / "power_validation.json",
-            "require_power": True,
-        }
-    ]
-
-
-def test_multinode_aggregation_maps_aggregate_deployment_to_agg_role(
-    tmp_path: Path,
-    monkeypatch: pytest.MonkeyPatch,
-):
-    from infx.results.agentic import power_adapter
-
-    logs_root = tmp_path / "logs"
-    result_dir = logs_root / "agentic" / "conc_8"
-    result_dir.mkdir(parents=True)
-    bench_result = result_dir / "agentic_power_concurrency_8.json"
-    bench_result.write_text(json.dumps({"max_concurrency": 8}))
-    agg_result = tmp_path / "agg_agentx_conc8.json"
-    agg_result.write_text(
-        json.dumps(
-            {"disagg": False, "num_prefill_gpu": 8, "num_decode_gpu": 0}
-        ),
-        encoding="utf-8",
-    )
-    power_dir = logs_root / "power"
-    power_dir.mkdir(parents=True)
-    calls: list[dict] = []
-
-    def fake_run(**kwargs) -> int:
-        calls.append(kwargs)
-        return 0
-
-    monkeypatch.setattr(power_adapter, "run_multinode_power", fake_run)
-
-    assert power_adapter.run_multinode_agentic_power(
-        result_dir=result_dir,
-        agg_result=agg_result,
-        power_dir=power_dir,
-        logs_root=logs_root,
-        expected_producer_sha="a" * 40,
-        require_power=True,
-    ) == 0
-    assert calls == [
-        {
-            "power_dir": power_dir,
-            "bench_result": bench_result,
-            "agg_result": agg_result,
-            "prefill_gpus": 0,
-            "decode_gpus": 0,
-            "aggregate_gpus": 8,
-            "expected_producer_sha": "a" * 40,
-            "logs_root": logs_root,
-            "validation_result": result_dir / "power_validation.json",
-            "require_power": True,
-        }
-    ]
-
-
 @pytest.mark.parametrize(
     "payload",
     [
@@ -471,7 +432,7 @@ def test_multinode_aggregation_rejects_invalid_aggregate_topology(
     tmp_path: Path,
     payload: dict,
 ):
-    from infx.results.agentic.power_adapter import run_multinode_agentic_power
+    from infx.results.agentic.power_adapter import run_native_agentic_power
 
     logs_root = tmp_path / "logs"
     result_dir = logs_root / "agentic" / "conc_8"
@@ -489,7 +450,7 @@ def test_multinode_aggregation_rejects_invalid_aggregate_topology(
     }
     agg_result.write_text(json.dumps({**stale_metrics, **payload}))
 
-    assert run_multinode_agentic_power(
+    assert run_native_agentic_power(
         result_dir=result_dir,
         agg_result=agg_result,
         power_dir=logs_root / "power",
@@ -504,10 +465,11 @@ def test_multinode_aggregation_rejects_invalid_aggregate_topology(
 
 
 @pytest.mark.parametrize("payload", [None, "{", "[]"])
+@pytest.mark.parametrize("require_power", [False, True])
 def test_multinode_invalid_aggregate_retains_failure_verdict(
-    tmp_path: Path, payload: str | None,
+    tmp_path: Path, payload: str | None, require_power: bool,
 ) -> None:
-    from infx.results.agentic.power_adapter import run_multinode_agentic_power
+    from infx.results.agentic.power_adapter import run_native_agentic_power
 
     logs_root = tmp_path / "logs"
     result_dir = logs_root / "agentic/conc_8"
@@ -515,14 +477,15 @@ def test_multinode_invalid_aggregate_retains_failure_verdict(
     if payload is not None:
         agg_result.write_text(payload)
 
-    assert run_multinode_agentic_power(
+    assert run_native_agentic_power(
         result_dir=result_dir,
         agg_result=agg_result,
         power_dir=logs_root / "power",
         logs_root=logs_root,
         expected_producer_sha="a" * 40,
-        require_power=True,
-    ) == 1
+        require_power=require_power,
+        audit_source="results/power_validation.json",
+    ) == int(require_power)
     verdict = json.loads((result_dir / "power_validation.json").read_text())
     assert verdict["power_valid"] is False
     assert "agentic_aggregate_invalid" in verdict["reasons"]
@@ -544,7 +507,7 @@ def fail_verdict(*args):
         raise OSError("audit directory unavailable")
 
     monkeypatch.setattr(power_adapter, "_write_multinode_failure_validation", fail_verdict)
-    assert power_adapter.run_multinode_agentic_power(
+    assert power_adapter.run_native_agentic_power(
         result_dir=tmp_path / "logs/agentic/conc_8",
         agg_result=aggregate_path,
         power_dir=tmp_path / "logs/power",
diff --git a/inferencex-e2e/infx/tests/results/power/test_aggregate_power_multinode.py b/inferencex-e2e/infx/tests/results/power/test_aggregate_power_multinode.py
index 9ab3ffd466..f3d959881c 100644
--- a/inferencex-e2e/infx/tests/results/power/test_aggregate_power_multinode.py
+++ b/inferencex-e2e/infx/tests/results/power/test_aggregate_power_multinode.py
@@ -425,7 +425,7 @@ def test_aggregate_topology_emits_only_whole_deployment_metrics(self, tmp_path):
         assert set(pkg.sidecar()["per_gpu_role"].values()) == {"agg"}
 
     def test_agentx_adapter_consumes_a_real_custom_benchmark_package(self, tmp_path):
-        from infx.results.agentic.power_adapter import run_multinode_agentic_power
+        from infx.results.agentic.power_adapter import run_native_agentic_power
 
         pkg = build_package(tmp_path)
         result_dir = pkg.logs_root / "agentic" / "conc_4"
@@ -469,7 +469,7 @@ def test_agentx_adapter_consumes_a_real_custom_benchmark_package(self, tmp_path)
             )
         )
 
-        assert run_multinode_agentic_power(
+        assert run_native_agentic_power(
             result_dir=result_dir,
             agg_result=pkg.agg_result,
             power_dir=pkg.power_dir,
@@ -707,7 +707,7 @@ def test_incomplete_status_rejected(self, tmp_path):
 
 
 @pytest.mark.parametrize("utilization", [("", ""), ("75.5", "0.9")])
-@pytest.mark.parametrize("temperature", [None, "", "0", "65.5"])
+@pytest.mark.parametrize("temperature", [None, "", "0", "65.5", "200"])
 def test_optional_samples_preserve_energy(tmp_path, utilization, temperature):
     """Optional utilization and temperature columns preserve board energy."""
     pkg = build_package(tmp_path)
@@ -744,7 +744,7 @@ def test_v2_samples_reject_mixed_versions_and_invalid_utilization(tmp_path, row)
     assert reasons == ("samples_csv_malformed",)
 
 
-@pytest.mark.parametrize("temperature", ["nan", "inf", "bad", "-300", "9223372036854775794"])
+@pytest.mark.parametrize("temperature", ["nan", "inf", "bad", "-300", "200.5", "9223372036854775794"])
 def test_v3_samples_reject_invalid_temperature(tmp_path, temperature):
     path = tmp_path / "samples.csv"
     path.write_text(
diff --git a/inferencex-e2e/infx/tests/results/power/test_process_result.py b/inferencex-e2e/infx/tests/results/power/test_process_result.py
index c0a8335ad2..b812e38c4b 100644
--- a/inferencex-e2e/infx/tests/results/power/test_process_result.py
+++ b/inferencex-e2e/infx/tests/results/power/test_process_result.py
@@ -868,26 +868,48 @@ def test_request_outcome_cannot_disagree_with_raw_counts(single_node_env_vars, s
         build_result(raw, single_node_env_vars)
 
 
-def test_multinode_aggregate_role_through_result_processor(tmp_path, multinode_env_vars):
+@pytest.mark.parametrize("provenance", [
+    {},
+    {"power_profile": "amd-device-metrics", "source_metric": "gpu_power_usage",
+     "power_scope": "gpu_device_power_as_reported_by_amd_device_metrics_exporter"},
+], ids=["dcgm", "fork-amd"])
+@pytest.mark.parametrize('multinode', [True, False])
+def test_native_aggregate_role_through_result_processor(
+    tmp_path, multinode_env_vars, single_node_env_vars, multinode, provenance,
+):
     pkg = build_package(tmp_path, bench_extra=TestMultinodePower.BENCH_EXTRA)
     manifest_path = pkg.power_dir / 'manifest.json'
     manifest = json.loads(manifest_path.read_text())
+    manifest.update(provenance)
     for device in manifest['expected_devices']:
         for assignment in device['assignments']:
             assignment.update(worker_role='agg', het_group=None)
     manifest_path.write_text(json.dumps(manifest))
-    env = {**multinode_env_vars, 'DISAGG': 'false', 'PREFILL_GPUS': '0',
+    env = {**(multinode_env_vars if multinode else single_node_env_vars),
+           'DISAGG': 'false', 'PREFILL_GPUS': '0',
            'DECODE_GPUS': '0', 'AGGREGATE_GPUS': '4', 'POWER_PRODUCER_SHA': PRODUCER_SHA,
+           'TP': '4', 'GPU_COUNT': '4', 'POWER_ARTIFACT_DIR': str(pkg.power_dir),
            'REQUIRE_POWER': '1'}
     result = run_script(tmp_path, env, json.loads(pkg.original_result.read_text()))
     assert result.returncode == 0, result.stderr
     aggregate = json.loads((tmp_path / 'agg_benchmark_result.json').read_text())
     assert aggregate['power_valid'] == 1
-    assert aggregate['num_aggregate_gpu'] == 4
+    assert aggregate['is_multinode'] is multinode
+    assert aggregate['num_aggregate_gpu' if multinode else 'tp'] == 4
+    assert aggregate['power_audit']['expected_gpu_count'] == 4
     assert aggregate['avg_power_w'] == 350
+    assert aggregate['total_gpu_energy_j'] == 84_000
     assert aggregate['power_audit']['producer_sha'] == PRODUCER_SHA
     assert set(ROLE_METRIC_KEYS).isdisjoint(aggregate)
 
+    manifest['source_metric'] = ''
+    manifest_path.write_text(json.dumps(manifest))
+    result = run_script(tmp_path, env, json.loads(pkg.original_result.read_text()))
+    assert result.returncode == 1
+    invalid = json.loads((tmp_path / 'agg_benchmark_result.json').read_text())
+    assert invalid['power_valid'] == 0
+    assert 'avg_power_w' not in invalid
+
 
 @pytest.mark.parametrize('conc_token,rate_suffix', [
     ('c', ''), ('conc', ''),
diff --git a/inferencex-e2e/infx/tests/srt_recipes.py b/inferencex-e2e/infx/tests/srt_recipes.py
index 9d5e20360b..982251f9fb 100644
--- a/inferencex-e2e/infx/tests/srt_recipes.py
+++ b/inferencex-e2e/infx/tests/srt_recipes.py
@@ -4,7 +4,7 @@
 
 import yaml
 
-from infx.srt_slurm.workload import SHARED_BLOCKS, TELEMETRY_BLOCK
+from infx.srt_slurm.workload import NATIVE_TELEMETRY_BLOCK, SHARED_BLOCKS, TELEMETRY_BLOCK
 
 
 def shared_blocks() -> dict[str, str]:
@@ -18,6 +18,9 @@ def shared_blocks() -> dict[str, str]:
     blocks[TELEMETRY_BLOCK.as_posix()] = yaml.safe_dump(
         {"telemetry": {"enabled": True, "dcgm_exporter": {"container_image": "dcgm"}}}
     )
+    blocks[NATIVE_TELEMETRY_BLOCK.as_posix()] = yaml.safe_dump(
+        {"telemetry": {"enabled": True, "required": False}}
+    )
     return blocks
 
 
diff --git a/inferencex-e2e/infx/tests/srt_slurm/test_generate.py b/inferencex-e2e/infx/tests/srt_slurm/test_generate.py
index 8dde8eeb3c..200015fb41 100644
--- a/inferencex-e2e/infx/tests/srt_slurm/test_generate.py
+++ b/inferencex-e2e/infx/tests/srt_slurm/test_generate.py
@@ -53,6 +53,7 @@
     },
 }  # fmt: skip
 SHARED = {
+    "telemetry-native.yaml": {"telemetry": {"enabled": True, "required": False}},
     "fixed-sequence-single.yaml": {"benchmark": {"type": "custom", "command": "bash client.sh"}},
     "agentic.yaml": {"benchmark": {"type": "custom", "command": "bash srt_agentic.sh"}},
     "telemetry-dcgm.yaml": {"telemetry": {"enabled": True, "dcgm_exporter": {
@@ -74,6 +75,7 @@ def project(tmp_path):
             "volumes": {"hf-hub-cache": {"path": "/srv/hf"}, "aiperf-cache": {"path": "/srv/aiperf"}},
             "srt-slurm": {
                 "network-interface": "eth0", "power-exporter-port": 9555,
+                "extra": {"default_gpu_exporter": {"container_image": "exporter:test", "port": 9499}},
                 "volume-mounts": {"hf-hub-cache": "/hf"},
                 "agentic-volume-mounts": {"aiperf-cache": "/aiperf"},
                 "fabric": {"socket-ifname": ["eth7"]},
@@ -142,8 +144,8 @@ def test_each_point_gets_its_bound_variant_and_a_manifest_entry(project, tmp_pat
     assert recipe["model"] == {"path": "hf:org/model", "container": "org/image:1", "precision": "fp8"}
     assert recipe["benchmark"] == {"type": "custom", "command": "bash client.sh", "env": {
         "CONC": "4", "ISL": "1024", "OSL": "128", "MODEL": "org/model",
-        "RANDOM_RANGE_RATIO": "0.8", "USE_CHAT_TEMPLATE": "true",
-    }}  # fmt: skip
+        "RANDOM_RANGE_RATIO": "0.8", "USE_CHAT_TEMPLATE": "true", "REQUIRE_POWER": "0",
+    }, "concurrencies": [4]}  # fmt: skip
     assert recipe["roles"]["agg"]["env"] == {"NCCL_SOCKET_IFNAME": "eth7"}
 
 
@@ -173,7 +175,8 @@ def test_a_single_node_agentx_point_gets_the_agentic_client_and_no_sequence_leng
     assert (record["variant"], record["cluster"]) == (None, "fixture")
     assert recipe["model"] == {"path": "hf:org/model", "container": "org/image:1", "precision": "fp8"}
     assert recipe["benchmark"] == {
-        "type": "custom", "command": "bash srt_agentic.sh", "env": {"MODEL": "org/model", "CONC": "2"},
+        "type": "custom", "command": "bash srt_agentic.sh", "env": {"MODEL": "org/model", "CONC": "2", "REQUIRE_POWER": "0", "ENABLE_AGENTX_POWER": "1"},
+        "concurrencies": [2],
     }  # fmt: skip
 
 
diff --git a/inferencex-e2e/infx/tests/srt_slurm/test_srt_single_node.py b/inferencex-e2e/infx/tests/srt_slurm/test_srt_single_node.py
index 41ebe13a2c..4d88d9c86f 100644
--- a/inferencex-e2e/infx/tests/srt_slurm/test_srt_single_node.py
+++ b/inferencex-e2e/infx/tests/srt_slurm/test_srt_single_node.py
@@ -23,6 +23,9 @@ def point(tmp_path, monkeypatch):
         shared = tmp_path / f"configs/srt-recipes/{block}.yaml"
         shared.parent.mkdir(parents=True, exist_ok=True)
         shared.write_text(yaml.safe_dump({"benchmark": {"type": "custom", "command": f"bash {client}"}}))
+    (tmp_path / "configs/srt-recipes/telemetry-native.yaml").write_text(
+        yaml.safe_dump({"telemetry": {"enabled": True, "required": False}})
+    )
     monkeypatch.setenv("INFERENCEX_REPOSITORY_ROOT", str(tmp_path))
     recipe = {
         "engine": "sglang",
@@ -59,8 +62,8 @@ def test_native_binding_submits_one_point_and_keeps_server_settings(point):
         "USE_CHAT_TEMPLATE": "false",
         "CONC": "2", "RESULT_FILENAME": "point-identity",
         "RUN_EVAL": "false", "EVAL_ONLY": "false", "RESULT_DIR": "/logs",
-        "FRAMEWORK": "sglang",
-    }}
+        "FRAMEWORK": "sglang", "REQUIRE_POWER": "0",
+    }, "concurrencies": [2]}
     assert actual["roles"]["agg"]["args"] == {
         "tensor-parallel-size": 4, "data-parallel-size": 1, "max-running-requests": 32,
     }
@@ -85,7 +88,8 @@ def test_agentx_fragments_are_composed_and_bound_to_the_point(point):
     assert selected == f"{path}:override_c2"
     assert bound["model"] == {"path": "hf:test/model", "container": "other:tag", "precision": "fp8"}
     assert bound["benchmark"] == {
-        "type": "custom", "command": "bash srt_agentic.sh", "env": {"CONC": "2", "MODEL": "test/model"},
+        "type": "custom", "command": "bash srt_agentic.sh", "env": {"CONC": "2", "MODEL": "test/model", "REQUIRE_POWER": "0", "ENABLE_AGENTX_POWER": "1"},
+        "concurrencies": [2],
     }
     path.write_text(yaml.safe_dump({"base": {**recipe, "model": {"container": "stale:tag"}}}))
     with pytest.raises(ValueError, match=r"remove base\.model\.container"):
@@ -274,3 +278,31 @@ def test_runtime_container_options_remain_native_mapping(point):
     }
     with pytest.raises(ValueError, match='must map option names to string values'):
         runtime_arguments(f"{path}:base", {**env, 'SRT_SRUN_OPTIONS': '{"container-remap-root": true}'})
+
+
+@pytest.mark.parametrize("requested", ["0", "1"])
+def test_binding_requires_power_from_the_workflow(point, requested):
+    path, _, env = point
+    _, actual = select_recipe(f"{path}:base", {**env, "REQUIRE_POWER": requested})
+    assert actual["telemetry"]["required"] is (requested == "1")
+    assert actual["benchmark"]["concurrencies"] == [2]
+
+
+@pytest.mark.parametrize("requested,expected", [(None, "0"), ("1", "1")])
+def test_agentic_binding_derives_require_power_from_the_workflow(point, requested, expected):
+    path, _, env = point
+    agentic_env = {**env, "IS_AGENTIC": "1", "DURATION": "20"}
+    if requested is not None:
+        agentic_env["REQUIRE_POWER"] = requested
+    _, actual = select_recipe(f"{path}:base", agentic_env)
+    assert actual["benchmark"]["env"]["REQUIRE_POWER"] == expected
+    assert actual["benchmark"]["env"]["ENABLE_AGENTX_POWER"] == "1"
+    assert actual["telemetry"]["required"] is (expected == "1")
+
+
+def test_fragment_cannot_require_single_node_power(point):
+    path, recipe, env = point
+    recipe["telemetry"] = {"required": True}
+    path.write_text(yaml.safe_dump({"base": recipe}))
+    with pytest.raises(ValueError, match="telemetry.required"):
+        select_recipe(f"{path}:base", env)
diff --git a/inferencex-e2e/runners/srt-slurm/exporters/amd-power.json b/inferencex-e2e/runners/srt-slurm/exporters/amd-power.json
new file mode 100644
index 0000000000..878d0c238e
--- /dev/null
+++ b/inferencex-e2e/runners/srt-slurm/exporters/amd-power.json
@@ -0,0 +1,12 @@
+{
+  "ServerPort": 19500,
+  "CommonConfig": {
+    "MetricsFieldPrefix": "",
+    "HealthService": {"Enable": false},
+    "HighResolution": {"Enable": true, "FastPeriodSecs": 1, "SlowPeriodSecs": 5}
+  },
+  "GPUConfig": {
+    "Fields": ["GPU_POWER_USAGE", "GPU_GFX_ACTIVITY", "GPU_JUNCTION_TEMPERATURE"],
+    "Labels": ["GPU_ID", "SERIAL_NUMBER", "GPU_COMPUTE_PARTITION_TYPE", "GPU_MEMORY_PARTITION_TYPE"]
+  }
+}
diff --git a/inferencex-e2e/runners/srt-slurm/patches/573-participating-gpus.patch b/inferencex-e2e/runners/srt-slurm/patches/573-participating-gpus.patch
new file mode 100644
index 0000000000..c01eb7b72f
--- /dev/null
+++ b/inferencex-e2e/runners/srt-slurm/patches/573-participating-gpus.patch
@@ -0,0 +1,21 @@
+diff --git a/src/srtctl/core/power/session.py b/src/srtctl/core/power/session.py
+--- a/src/srtctl/core/power/session.py
++++ b/src/srtctl/core/power/session.py
+@@ -149,6 +149,7 @@ class PowerTelemetrySession:
+         self._mutation_disabled = False
+         expected_device_list = list(expected_devices)
+         self._expected_device_keys = frozenset(device.key for device in expected_device_list)
++        self._worker_hosts = frozenset(hostname for hostname, _ in self._expected_device_keys)
+
+         self._manifest = PowerManifest(
+             job_id=settings.job_id,
+@@ -433,6 +434,9 @@ class PowerTelemetrySession:
+                 temperature_c=reading.temperature_c,
+             )
+             for reading in (scrape.readings if scrape is not None else ())
++            # A worker node's exporter also reports the GPUs no worker uses; pool nodes keep every GPU.
++            if endpoint.hostname not in self._worker_hosts
++            or (endpoint.hostname, reading.gpu_index) in self._expected_device_keys
+         ]
+         return _EndpointResult(
+             hostname=endpoint.hostname,
diff --git a/inferencex-e2e/runners/srt-slurm/patches/README.md b/inferencex-e2e/runners/srt-slurm/patches/README.md
index fcadc7bf88..7b81c6c0d5 100644
--- a/inferencex-e2e/runners/srt-slurm/patches/README.md
+++ b/inferencex-e2e/runners/srt-slurm/patches/README.md
@@ -8,3 +8,4 @@ Each patch is a temporary fix for an open upstream PR. When the PR merges and th
 
 | Patch | Upstream PR | Fix |
 |-------|-------------|-----|
+| `573-participating-gpus.patch` | [NVIDIA/srt-slurm#573](https://github.com/NVIDIA/srt-slurm/pull/573) | Record only the GPUs workers occupy on a worker node; an exporter such as AMD's reports every GPU, which the collector otherwise flags as `unexpected_device`. |