diff --git a/app/igneum-app/src/detect.rs b/app/igneum-app/src/detect.rs
index 5af1581d0..c6c300dc1 100644
--- a/app/igneum-app/src/detect.rs
+++ b/app/igneum-app/src/detect.rs
@@ -104,7 +104,7 @@ pub fn apply_defaults(c: &mut CardState) {
 /// Marks whether the efficiency sweep (src/sweep.rs) can run on a card, with the reason when it cannot. Called
 /// once the power limits are known.
 pub fn mark_sweep_support(c: &mut CardState) {
-    match crate::sweep::unsupported_reason(&c.vendor, c.power_default_w, &c.device) {
+    match crate::sweep::unsupported_reason_for(&c.vendor, c.power_default_w, &c.device, c.amd_tunable) {
         None => {
             c.sweep_supported = true;
             if c.sweep_state.is_empty() || c.sweep_state == "unsupported" {
diff --git a/app/igneum-app/src/engine.rs b/app/igneum-app/src/engine.rs
index 480a8b7b9..fb12ffbf9 100644
--- a/app/igneum-app/src/engine.rs
+++ b/app/igneum-app/src/engine.rs
@@ -962,7 +962,12 @@ impl Engine {
                 }
             }
             Cmd::SweepCapSet(text) => {
-                if !text.contains("All done") {
+                if text.starts_with("adlx ") {
+                    self.shared.log(&format!("sweep: {}", short(&text, 220)));
+                    if text.contains(" error ") {
+                        self.sweep_abort(&format!("ADLX refused the setting ({})", short(&text, 160)));
+                    }
+                } else if !text.contains("All done") {
                     self.shared.log(&format!("sweep: nvidia-smi -pl answered: {}", short(&text.replace('\n', " "), 200)));
                 }
             }
@@ -1552,6 +1557,14 @@ impl Engine {
             }
         }
         if self.amd_telemetry.is_none() && now >= self.amd_telemetry_retry_at {
+            // what the cards' manual tuning allows, once per child start (the sweep's ranges and the stock max clock)
+            if let Some(out) = crate::detect::run_timeout(std::process::Command::new(&exe).arg("--tune"), None, Duration::from_secs(20)) {
+                for line in out.lines() {
+                    if let Some(tu) = parse_amd_tune(line) {
+                        self.amd_tune_line(&tu);
+                    }
+                }
+            }
             let args: Vec<String> = vec!["-l".into(), "5".into()];
             let log = self.shared.runtime.log_dir.join(format!("gpu-amd-{}.log", self.stamp));
             match procs::spawn(Source::AmdTelemetry, &exe, &args, None, &log, &self.lines_tx, &[]) {
@@ -1582,6 +1595,9 @@ impl Engine {
         }
         let Some(idx) = target else { return };
         let Some(c) = st.mining.cards.iter_mut().find(|c| c.index == idx) else { return };
+        c.amd_ordinal = s.ordinal as i32;
+        c.amd_plimit_pct = s.plimit_pct.max(0.0);
+        c.amd_gmax_mhz = s.gmax_mhz.max(0.0);
         if s.watts > 0.0 {
             c.power_w = s.watts;
         }
@@ -1593,6 +1609,49 @@ impl Engine {
         c.mclk_mhz = s.mclk_mhz.max(0.0);
         c.util_pct = s.util_pct.max(0.0);
         c.telemetry_at = crate::platform::unix_now_f();
+        let draw = c.power_w;
+        drop(st);
+        // the sweep's draw samples, as the NVIDIA line feeds them
+        if let Some(run) = self.sweep.as_mut() {
+            if run.card == idx && draw > 0.0 {
+                run.sample_draw(draw);
+            }
+        }
+    }
+
+    /// One `tune` line of igneum-gpu-telemetry --tune: the card it describes (matched as the sample lines are, by
+    /// the ordinal among the discrete AMD cards; integrated ones have no manual tuning) learns its ranges and whether
+    /// the sweep can run on it.
+    fn amd_tune_line(&mut self, tu: &AmdTune) {
+        let mut st = self.st();
+        let mut nth = 0usize;
+        let mut target: Option<usize> = None;
+        for c in st.mining.cards.iter() {
+            if c.vendor != "amd" || c.kind != "discrete" {
+                continue;
+            }
+            if nth == tu.ordinal_in_kind {
+                target = Some(c.index);
+                break;
+            }
+            nth += 1;
+        }
+        let Some(idx) = target else { return };
+        let Some(c) = st.mining.cards.iter_mut().find(|c| c.index == idx) else { return };
+        c.amd_ordinal = tu.ordinal as i32;
+        c.amd_tunable = tu.plimit_range.is_some();
+        if let Some((lo, hi)) = tu.plimit_range {
+            c.amd_plimit_min = lo;
+            c.amd_plimit_max = hi;
+        }
+        if let Some((lo, hi)) = tu.gmax_range {
+            c.amd_gmax_min = lo;
+            c.amd_gmax_max = hi;
+        }
+        if tu.gmax > 0.0 && c.amd_gmax_stock <= 0.0 {
+            c.amd_gmax_stock = tu.gmax;
+        }
+        crate::detect::mark_sweep_support(c);
     }
 
     /// "index, draw, gpu temp, mem temp, limit" every 5 s.
@@ -1711,7 +1770,7 @@ impl Engine {
         let cards = self.st().mining.cards.clone();
         let mut pick: Option<(usize, bool)> = None;
         for c in cards.iter() {
-            if !(c.enabled && c.sweep_supported && c.vendor == "nvidia") {
+            if !(c.enabled && c.sweep_supported && (c.vendor == "nvidia" || (c.vendor == "amd" && c.amd_tunable))) {
                 continue;
             }
             let forced = self.sweep_queue.contains(&c.key);
@@ -1764,6 +1823,11 @@ impl Engine {
             cc.sweep_state = "running".into();
             cc.sweep_note = "sweep: checking how the cap is set".into();
         }
+        if c.vendor == "amd" {
+            // ADLX sets the limit from this process with no elevation (igneum-gpu-telemetry --card N --set-plimit)
+            self.sweep_mode_known(Ok(true));
+            return;
+        }
         if let Some(direct) = self.sweep_direct {
             self.sweep_mode_known(Ok(direct));
             return;
@@ -1791,36 +1855,41 @@ impl Engine {
                 return;
             }
         };
-        self.sweep_direct = Some(direct);
         let Some(c) = self.st().mining.cards.get(idx).cloned() else {
             self.sweep_pending = None;
             return;
         };
-        if !direct && !self.sweep_helper {
+        let amd = c.vendor == "amd";
+        if !amd {
+            self.sweep_direct = Some(direct);
+        }
+        if !amd && !direct && !self.sweep_helper {
             if let Err(e) = self.sweep_helper_start(&c) {
                 self.sweep_abort(&format!("the elevated helper could not start: {e}"));
                 return;
             }
         }
-        let steps = crate::sweep::plan_steps(c.power_default_w, c.power_min_w, c.power_max_w);
+        let lever = if amd { crate::sweep::Lever::AmdPowerPct } else { crate::sweep::Lever::NvidiaWatts };
+        let steps = if amd { crate::sweep::plan_amd_power_steps(c.amd_plimit_min, c.amd_plimit_max) } else { crate::sweep::plan_steps(c.power_default_w, c.power_min_w, c.power_max_w) };
         if steps.is_empty() {
             self.sweep_abort("no steps: the card reported no default power limit");
             return;
         }
         let label = self.miners.iter().find(|m| m.card == idx).map(|m| m.label.clone()).unwrap_or_else(|| format!("card-{idx}"));
-        let before_w = if c.power_limit_w > 0.0 { c.power_limit_w } else { requested_watts(&c) };
+        let before_w = if amd { if c.amd_plimit_pct > 0.0 { c.amd_plimit_pct } else { 100.0 } } else if c.power_limit_w > 0.0 { c.power_limit_w } else { requested_watts(&c) };
         let now = Instant::now();
-        let run = crate::sweep::Run::new(idx, &c.key, &c.device, &label, steps.clone(), c.power_pct, before_w, forced, crate::sweep::Timing::from_env(), now);
+        let run = crate::sweep::Run::new(idx, &c.key, &c.device, &label, steps.clone(), c.power_pct, before_w, forced, crate::sweep::Timing::from_env(), now).with_lever(lever);
         self.sweep_pending = None;
         self.sweep_say(&format!(
-            "SWEEP start card={label} name={} steps={} default={:.0} min={:.0} max={:.0} before={:.0} mode={}",
+            "SWEEP start card={label} name={} lever={} steps={} default={:.0} min={:.0} max={:.0} before={:.0} mode={}",
             c.name.replace(' ', "_"),
+            lever.name(),
             steps.iter().map(|s| s.pct.to_string()).collect::<Vec<_>>().join(","),
-            c.power_default_w,
-            c.power_min_w,
-            c.power_max_w,
+            if amd { 100.0 } else { c.power_default_w },
+            if amd { 100.0 + c.amd_plimit_min } else { c.power_min_w },
+            if amd { 100.0 + c.amd_plimit_max } else { c.power_max_w },
             before_w,
-            if direct { "direct" } else { "helper" }
+            if amd { "adlx" } else if direct { "direct" } else { "helper" }
         ));
         self.shared.event("info", &format!("{}: efficiency sweep started: {} caps from {}% down, {} s each on the live program", c.name, steps.len(), steps[0].pct, (run.timing.settle + run.timing.hold).as_secs()));
         self.sweep = Some(run);
@@ -1864,6 +1933,25 @@ impl Engine {
     fn sweep_set_cap(&mut self, device: &str, watts: f64) {
         self.sweep_seq += 1;
         let w = watts.round() as u64;
+        let amd = self.sweep.as_ref().map(|r| r.lever != crate::sweep::Lever::NvidiaWatts).unwrap_or(false);
+        if amd {
+            // igneum-gpu-telemetry --card <ordinal> --set-plimit <offset> (or --set-gmax); the readback comes with the
+            // next sample line (plimit_pct / gmax_mhz, 5 s)
+            let (lever, idx) = self.sweep.as_ref().map(|r| (r.lever, r.card)).unwrap();
+            let ordinal = self.st().mining.cards.get(idx).map(|c| c.amd_ordinal).unwrap_or(-1);
+            let Some(exe) = self.bins.telemetry.clone() else { return };
+            let args: Vec<String> = match lever {
+                crate::sweep::Lever::AmdPowerPct => vec!["--card".into(), ordinal.to_string(), "--set-plimit".into(), (watts.round() as i64 - 100).to_string()],
+                _ => vec!["--card".into(), ordinal.to_string(), "--set-gmax".into(), w.to_string()],
+            };
+            let shared = self.shared.clone();
+            std::thread::spawn(move || {
+                let out = crate::detect::run_timeout(std::process::Command::new(&exe).args(&args), None, Duration::from_secs(20)).unwrap_or_else(|| "igneum-gpu-telemetry did not answer".into());
+                shared.send(Cmd::SweepCapSet(format!("adlx {}: {}", args.join(" "), out.lines().find(|l| l.starts_with("tune ")).unwrap_or("no tune line"))));
+            });
+            self.shared.log(&format!("sweep: {} {} requested on AMD card {} (ordinal {ordinal})", lever.name(), if lever == crate::sweep::Lever::AmdPowerPct { format!("{w}%") } else { format!("{w} MHz") }, device));
+            return;
+        }
         if self.sweep_direct == Some(true) {
             let smi = crate::platform::tool("nvidia-smi");
             let device = device.to_string();
@@ -1906,13 +1994,18 @@ impl Engine {
             self.sweep_abort(&why);
             return;
         }
-        let outs = self.sweep.as_mut().map(|r| r.tick(now, c.power_limit_w)).unwrap_or_default();
-        let label = self.sweep.as_ref().map(|r| r.label.clone()).unwrap_or_default();
+        let readback = match self.sweep.as_ref().map(|r| r.lever).unwrap_or(crate::sweep::Lever::NvidiaWatts) {
+            crate::sweep::Lever::NvidiaWatts => c.power_limit_w,
+            crate::sweep::Lever::AmdPowerPct => c.amd_plimit_pct,
+            crate::sweep::Lever::AmdMaxClockMhz => c.amd_gmax_mhz,
+        };
+        let outs = self.sweep.as_mut().map(|r| r.tick(now, readback)).unwrap_or_default();
+        let (label, lever) = self.sweep.as_ref().map(|r| (r.label.clone(), r.lever)).unwrap_or((String::new(), crate::sweep::Lever::NvidiaWatts));
         for o in outs {
             match o {
                 crate::sweep::Out::Apply(w) => self.sweep_set_cap(&device, w),
                 crate::sweep::Out::Row(row) => {
-                    self.sweep_say(&row.line(&label));
+                    self.sweep_say(&row.line_for(&label, lever));
                     if let Some(cc) = self.st().mining.cards.get_mut(idx) {
                         if row.usable() {
                             cc.sweep_note = format!("sweep: {}% done · {:.3} MH/W", row.pct, row.eff);
@@ -3371,11 +3464,15 @@ pub struct AmdTelemetry {
     pub mclk_mhz: f64,
     pub gclk_mhz: f64,
     pub util_pct: f64,
+    /// the limits in force (5 October 2026 tuning lines): the power limit as percent of default, the max GPU clock;
+    /// -1 when the line has no such field (an older helper) or the card has no manual tuning
+    pub plimit_pct: f64,
+    pub gmax_mhz: f64,
     pub source: String,
 }
 
 /// Parses `amd <n> bus <b> kind <k> name "<name>" watts <w> temp_c <t> fan_rpm <r> fan_pct <p> mclk_mhz <m>
-/// gclk_mhz <g> util_pct <u> source <s>`; a `-` value reads as -1.0. Anything else (info, end) gives None.
+/// gclk_mhz <g> util_pct <u> [plimit_pct <l> gmax_mhz <x>] source <s>`; a `-` value reads as -1.0. Anything else (info, end) gives None.
 /// With one card per kind (the common case) `ordinal_in_kind` is 0 for the discrete card and 0 for the integrated
 /// one whatever their `amd N`; with several discrete cards the helper's order within the kind is kept: the rank is
 /// the number of earlier lines of the same kind, which the helper encodes by listing kinds contiguously (ADLX lists
@@ -3405,12 +3502,14 @@ pub fn parse_amd_telemetry(line: &str) -> Option<AmdTelemetry> {
     let mclk_mhz = num("mclk_mhz")?;
     let gclk_mhz = num("gclk_mhz")?;
     let util_pct = num("util_pct")?;
+    let plimit_pct = num("plimit_pct").unwrap_or(-1.0);
+    let gmax_mhz = num("gmax_mhz").unwrap_or(-1.0);
     let source = tp.iter().position(|p| *p == "source").and_then(|i| tp.get(i + 1)).map(|s| s.to_string()).unwrap_or_default();
     let kind = hp[5].to_string();
     // the rank within the kind: the helper lists one integrated card at most and it comes first when present
     // (ADLX order on every PC seen so far), so a discrete card's rank is its ordinal minus the integrated ones before it
     let ordinal_in_kind = if kind == "discrete" && ordinal > 0 { ordinal - 1 } else if kind == "discrete" { 0 } else { 0 };
-    Some(AmdTelemetry { ordinal, ordinal_in_kind, bus: hp[3].to_string(), kind, name: name.to_string(), watts, temp_c, fan_rpm, fan_pct, mclk_mhz, gclk_mhz, util_pct, source })
+    Some(AmdTelemetry { ordinal, ordinal_in_kind, bus: hp[3].to_string(), kind, name: name.to_string(), watts, temp_c, fan_rpm, fan_pct, mclk_mhz, gclk_mhz, util_pct, plimit_pct, gmax_mhz, source })
 }
 
 #[cfg(test)]
@@ -3420,8 +3519,9 @@ mod amd_telemetry_tests {
     #[test]
     fn a_sysfs_line_from_the_fixture_parses() {
         // proto-opencl/gpu-telemetry.c on the Mac against a fixture tree, 5 October 2026
-        let l = "amd 0 bus 0000:0c:00.0 kind discrete name \"AMD Radeon RX 9070 XT\" watts 287.0 temp_c 61.0 fan_rpm 1180 fan_pct 30 mclk_mhz 1258 gclk_mhz 2450 util_pct 90 source sysfs";
+        let l = "amd 0 bus 0000:0c:00.0 kind discrete name \"AMD Radeon RX 9070 XT\" watts 287.0 temp_c 61.0 fan_rpm 1180 fan_pct 30 mclk_mhz 1258 gclk_mhz 2450 util_pct 90 plimit_pct 80 gmax_mhz 2450 source sysfs";
         let s = parse_amd_telemetry(l).unwrap();
+        assert_eq!((s.plimit_pct, s.gmax_mhz), (80.0, 2450.0));
         assert_eq!((s.ordinal, s.ordinal_in_kind, s.bus.as_str(), s.kind.as_str(), s.name.as_str()), (0, 0, "0000:0c:00.0", "discrete", "AMD Radeon RX 9070 XT"));
         assert_eq!((s.watts, s.temp_c, s.fan_rpm, s.fan_pct, s.mclk_mhz, s.gclk_mhz, s.util_pct), (287.0, 61.0, 1180.0, 30.0, 1258.0, 2450.0, 90.0));
         assert_eq!(s.source, "sysfs");
@@ -3429,9 +3529,11 @@ mod amd_telemetry_tests {
 
     #[test]
     fn a_dash_reads_as_unknown_and_other_lines_give_none() {
-        let l = "amd 1 bus 98 kind discrete name \"AMD Radeon RX 9070 XT\" watts 250.3 temp_c 58.0 fan_rpm 900 fan_pct - mclk_mhz 1258 gclk_mhz 2460 util_pct 97.5 source adlx";
+        // PC 1, 20:27 UTC, the first helper build (no plimit_pct / gmax_mhz fields yet): they read as -1
+        let l = "amd 1 bus 98 kind discrete name \"AMD Radeon RX 9070 XT\" watts 214.0 temp_c 64.0 fan_rpm 659 fan_pct - mclk_mhz 2505 gclk_mhz 3289 util_pct 100 source adlx";
         let s = parse_amd_telemetry(l).unwrap();
         assert_eq!(s.fan_pct, -1.0);
+        assert_eq!((s.plimit_pct, s.gmax_mhz, s.watts, s.mclk_mhz), (-1.0, -1.0, 214.0, 2505.0));
         assert_eq!(s.ordinal_in_kind, 0, "the second line overall but the first discrete card after the integrated one");
         assert!(parse_amd_telemetry("end 3.2 ms 2 card(s)").is_none());
         assert!(parse_amd_telemetry("info adlx: ADLXHelper_Initialize returned 1").is_none());
@@ -3445,3 +3547,73 @@ mod amd_telemetry_tests {
         assert_eq!((s.watts, s.util_pct, s.source.as_str()), (-1.0, 100.0, "perfcounter"));
     }
 }
+
+/// One `tune` line of igneum-gpu-telemetry --tune: `tune N name "..." gmax X gmax_range MIN MAX plimit OFF
+/// plimit_range MIN MAX factory 0|1 ok|error ...`; a `-` means the card has no such tuning.
+#[derive(Debug, Clone, PartialEq)]
+pub struct AmdTune {
+    pub ordinal: usize,
+    pub ordinal_in_kind: usize,
+    pub name: String,
+    pub gmax: f64,
+    pub gmax_range: Option<(f64, f64)>,
+    pub plimit: f64,
+    pub plimit_range: Option<(f64, f64)>,
+    pub factory: Option<bool>,
+    pub ok: bool,
+}
+
+pub fn parse_amd_tune(line: &str) -> Option<AmdTune> {
+    let line = line.trim();
+    let rest = line.strip_prefix("tune ")?;
+    let (ord_s, rest) = rest.split_once(" name \"")?;
+    let ordinal: usize = ord_s.trim().parse().ok()?;
+    let (name, tail) = rest.split_once('"')?;
+    let tp: Vec<&str> = tail.split_whitespace().collect();
+    let at = |key: &str| tp.iter().position(|p| *p == key);
+    let f = |s: Option<&&str>| -> Option<f64> { let v = *s?; if v == "-" { None } else { v.parse::<f64>().ok() } };
+    let gi = at("gmax")?;
+    let gri = at("gmax_range")?;
+    let pi = at("plimit")?;
+    let pri = at("plimit_range")?;
+    let gmax = f(tp.get(gi + 1)).unwrap_or(-1.0);
+    let gmax_range = match (f(tp.get(gri + 1)), f(tp.get(gri + 2))) { (Some(a), Some(b)) => Some((a, b)), _ => None };
+    let plimit = f(tp.get(pi + 1)).unwrap_or(0.0);
+    let plimit_range = match (f(tp.get(pri + 1)), f(tp.get(pri + 2))) { (Some(a), Some(b)) => Some((a, b)), _ => None };
+    let factory = at("factory").and_then(|i| tp.get(i + 1)).and_then(|v| match *v { "1" => Some(true), "0" => Some(false), _ => None });
+    let ok = tp.last().map(|v| *v == "ok").unwrap_or(false);
+    // integrated cards come first in ADLX order and carry no manual tuning: the rank among discrete cards is the
+    // ordinal minus the integrated ones before it; a tune line with no ranges at all is taken as integrated
+    let integrated_before = if ordinal > 0 && gmax_range.is_none() && plimit_range.is_none() { 0 } else { ordinal.min(1) };
+    let _ = integrated_before;
+    let ordinal_in_kind = if ordinal > 0 { ordinal - 1 } else { 0 };
+    Some(AmdTune { ordinal, ordinal_in_kind, name: name.to_string(), gmax, gmax_range, plimit, plimit_range, factory, ok })
+}
+
+#[cfg(test)]
+mod amd_tune_tests {
+    use super::*;
+
+    #[test]
+    fn a_tune_line_with_ranges_parses() {
+        // the shape igneum-gpu-telemetry --tune prints (ranges are the card's; a 9070 XT's own are owed, it left the bus)
+        let l = "tune 1 name \"AMD Radeon RX 9070 XT\" gmax 3300 gmax_range 500 3450 plimit 0 plimit_range -30 10 factory 1 ok";
+        let tu = parse_amd_tune(l).unwrap();
+        assert_eq!((tu.ordinal, tu.ordinal_in_kind, tu.name.as_str(), tu.gmax, tu.plimit), (1, 0, "AMD Radeon RX 9070 XT", 3300.0, 0.0));
+        assert_eq!(tu.gmax_range, Some((500.0, 3450.0)));
+        assert_eq!(tu.plimit_range, Some((-30.0, 10.0)));
+        assert_eq!(tu.factory, Some(true));
+        assert!(tu.ok);
+    }
+
+    #[test]
+    fn an_integrated_card_without_tuning_and_an_error_verdict() {
+        let l = "tune 0 name \"AMD Radeon(TM) Graphics\" gmax - gmax_range - - plimit - plimit_range - - factory 1 ok";
+        let tu = parse_amd_tune(l).unwrap();
+        assert!(tu.gmax_range.is_none() && tu.plimit_range.is_none());
+        let e = parse_amd_tune("tune 1 name \"x\" gmax 2800 gmax_range 500 3450 plimit -20 plimit_range -30 10 factory 0 error SetPowerLimit(-50) returned 1").unwrap();
+        assert!(!e.ok);
+        assert_eq!(e.factory, Some(false));
+        assert!(parse_amd_tune("end 1.0 ms 2 card(s)").is_none());
+    }
+}
diff --git a/app/igneum-app/src/state.rs b/app/igneum-app/src/state.rs
index 49bd09240..b11458d0e 100644
--- a/app/igneum-app/src/state.rs
+++ b/app/igneum-app/src/state.rs
@@ -79,6 +79,18 @@ pub struct CardState {
     pub fan_rpm: f64,
     pub mclk_mhz: f64,
     pub util_pct: f64,
+    /// the AMD card's line in the helper's output (`amd N`), -1 until a line matched; what --card N addresses
+    pub amd_ordinal: i32,
+    /// the AMD limits in force from the helper's line: the power limit as percent of default (100 = default), the max GPU clock
+    pub amd_plimit_pct: f64,
+    pub amd_gmax_mhz: f64,
+    /// from the helper's `tune` line: manual tuning present, the power offset range (percent) and the max clock range and stock
+    pub amd_tunable: bool,
+    pub amd_plimit_min: f64,
+    pub amd_plimit_max: f64,
+    pub amd_gmax_min: f64,
+    pub amd_gmax_max: f64,
+    pub amd_gmax_stock: f64,
     // hash per watt (src/sweep.rs)
     pub eff_mhw: f64,          // live: hash_now over power_w, MH per watt; 0 = unknown
     pub sweep_supported: bool, // NVIDIA with readable limits; the note says why not otherwise
diff --git a/app/igneum-app/src/sweep.rs b/app/igneum-app/src/sweep.rs
index 52c0adbbf..99dbf97f7 100644
--- a/app/igneum-app/src/sweep.rs
+++ b/app/igneum-app/src/sweep.rs
@@ -16,8 +16,14 @@
 //!   SWEEP card=<label> cap=<pct> limit=<set W> watts=<mean draw W> mhs=<MH/s> eff=<MH per W>
 //!   SWEEP chosen card=<label> cap=<pct> limit=<W> watts=<W> mhs=<x> eff=<MH per W>
 //!   SWEEP aborted card=<label> reason=<text>
-//! Apple silicon and AMD are reported unsupported with the reason (no cap to set; powermetrics needs root; no AMD
-//! power reading in this app).
+//! Apple silicon is reported unsupported with the reason (no cap to set; powermetrics needs root).
+//!
+//! AMD (5 October 2026): the same machine with another lever. igneum-gpu-telemetry (proto-opencl/gpu-telemetry.c)
+//! sets the ADLX power limit (a percent offset from the card's default, 0 = 100%) or the max GPU clock, with no
+//! elevation, and its sample lines carry the limit in force (plimit_pct, gmax_mhz) as the readback. A Step's
+//! `watts` then holds the percent (or the MHz), `Row.limit` prints it, and `Row.watts` stays the measured draw.
+//! The lever a card sweeps is `Lever`; the AMD default is the power limit (the clock lever is for the card test
+//! playbook until a measured sweep says which lever gives the better MH per watt: owed, the 9070 XT left the bus).
 
 use std::collections::HashMap;
 use std::time::{Duration, Instant};
@@ -32,6 +38,89 @@ pub const PERIOD_S: u64 = 7 * 86_400;
 pub const NEEDS_S: i64 = 600;
 /// The worker must have been mining this long before a sweep starts (the first status lines are warm-up).
 pub const STABLE_S: u64 = 120;
+/// The AMD core-clock steps, MHz, highest first; the stock max clock is put in front when it is above the first.
+pub const AMD_CLOCK_STEPS: [u32; 5] = [2800, 2400, 2000, 1600, 1200];
+
+/// What a sweep turns: the value a Step carries, how it is set and read back, and how close the readback must be.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Lever {
+    /// NVIDIA: nvidia-smi -pl, watts; readback power.limit
+    NvidiaWatts,
+    /// AMD: the ADLX power limit, as percent of the default (100 = default); readback plimit_pct
+    AmdPowerPct,
+    /// AMD: the ADLX max GPU clock, MHz; readback gmax_mhz (the card-test playbook's lever; the app sweeps the
+    /// power limit until a measured sweep says the clock lever gives more MH per watt)
+    #[allow(dead_code)]
+    AmdMaxClockMhz,
+}
+
+impl Lever {
+    /// How far the readback may sit from the value set and still count as applied.
+    pub fn tolerance(self) -> f64 {
+        match self {
+            Lever::NvidiaWatts => 1.5,
+            Lever::AmdPowerPct => 0.5,
+            Lever::AmdMaxClockMhz => 5.0,
+        }
+    }
+    pub fn unit(self) -> &'static str {
+        match self {
+            Lever::NvidiaWatts => "W",
+            Lever::AmdPowerPct => "%",
+            Lever::AmdMaxClockMhz => "MHz",
+        }
+    }
+    pub fn name(self) -> &'static str {
+        match self {
+            Lever::NvidiaWatts => "watts",
+            Lever::AmdPowerPct => "amd_power_pct",
+            Lever::AmdMaxClockMhz => "amd_max_clock",
+        }
+    }
+}
+
+/// The AMD power-limit steps: STEPS_PCT clamped to what ADLX allows (the offset range is `min_off..max_off`
+/// percent around 0; a 9070 XT range is read at run time), duplicates from the clamp dropped. `watts` holds the
+/// percent of default.
+pub fn plan_amd_power_steps(min_off: f64, max_off: f64) -> Vec<Step> {
+    let mut out: Vec<Step> = Vec::new();
+    let lo = 100.0 + min_off.min(0.0);
+    let hi = 100.0 + max_off.max(0.0);
+    for pct in STEPS_PCT {
+        let v = (pct as f64).clamp(lo, hi).round();
+        if out.last().map(|s| (s.watts - v).abs() < 0.5).unwrap_or(false) {
+            continue;
+        }
+        out.push(Step { pct, watts: v });
+    }
+    out
+}
+
+/// The AMD max-clock steps: the stock max clock first, then AMD_CLOCK_STEPS below it, each clamped to the card's
+/// range, duplicates dropped. `pct` is the step's share of the stock clock, for the lines and the pinned setting.
+pub fn plan_amd_clock_steps(stock: f64, min: f64, max: f64) -> Vec<Step> {
+    let mut out: Vec<Step> = Vec::new();
+    if stock <= 0.0 {
+        return out;
+    }
+    let mut want: Vec<f64> = vec![stock];
+    want.extend(AMD_CLOCK_STEPS.iter().map(|m| *m as f64).filter(|m| *m < stock));
+    for mhz in want {
+        let mut v = mhz;
+        if min > 0.0 {
+            v = v.max(min);
+        }
+        if max > 0.0 {
+            v = v.min(max);
+        }
+        let v = v.round();
+        if out.last().map(|s| (s.watts - v).abs() < 0.5).unwrap_or(false) {
+            continue;
+        }
+        out.push(Step { pct: (100.0 * v / stock).round() as u32, watts: v });
+    }
+    out
+}
 
 #[derive(Clone, Copy, Debug)]
 pub struct Timing {
@@ -113,10 +202,15 @@ impl Row {
     }
     /// `SWEEP card=<label> cap=<pct> limit=<W> watts=<W> mhs=<x> eff=<MH/W>`; a step without readings says so.
     pub fn line(&self, card: &str) -> String {
+        self.line_for(card, Lever::NvidiaWatts)
+    }
+    /// The same line with the lever named when it is not the NVIDIA cap (`lever=amd_power_pct limit=80`).
+    pub fn line_for(&self, card: &str, lever: Lever) -> String {
+        let lv = if lever == Lever::NvidiaWatts { String::new() } else { format!(" lever={}", lever.name()) };
         if self.usable() {
-            format!("SWEEP card={card} cap={} limit={:.0} watts={:.1} mhs={:.2} eff={:.4}", self.pct, self.limit, self.watts, self.mhs, self.eff)
+            format!("SWEEP card={card}{lv} cap={} limit={:.0} watts={:.1} mhs={:.2} eff={:.4}", self.pct, self.limit, self.watts, self.mhs, self.eff)
         } else {
-            format!("SWEEP card={card} cap={} limit={:.0} watts={:.1} mhs={:.2} eff=0 reason=no_readings draws={} rates={}", self.pct, self.limit, self.watts, self.mhs, self.draws, self.rates)
+            format!("SWEEP card={card}{lv} cap={} limit={:.0} watts={:.1} mhs={:.2} eff=0 reason=no_readings draws={} rates={}", self.pct, self.limit, self.watts, self.mhs, self.draws, self.rates)
         }
     }
 }
@@ -209,6 +303,7 @@ pub struct Run {
     pub started: Instant,
     pub forced: bool,
     pub timing: Timing,
+    pub lever: Lever,
     draws: Vec<f64>,
     rates: Vec<f64>,
 }
@@ -230,11 +325,18 @@ impl Run {
             started: now,
             forced,
             timing,
+            lever: Lever::NvidiaWatts,
             draws: Vec::new(),
             rates: Vec::new(),
         }
     }
 
+    /// The same run on another lever (AMD).
+    pub fn with_lever(mut self, lever: Lever) -> Run {
+        self.lever = lever;
+        self
+    }
+
     pub fn current(&self) -> Option<&Step> {
         self.steps.get(self.i)
     }
@@ -265,12 +367,15 @@ impl Run {
         }
     }
 
-    /// Drives the state machine. `limit_w` is the limit the card reports now (the telemetry readback; 0 = unknown).
+    /// Drives the state machine. `limit_w` is the limit the card reports now in the lever's unit (the telemetry
+    /// readback; 0 = unknown).
     pub fn tick(&mut self, now: Instant, limit_w: f64) -> Vec<Out> {
         let mut out = Vec::new();
         let settle = self.timing.settle;
         let hold = self.timing.hold;
         let apply = self.timing.apply;
+        let tol = self.lever.tolerance();
+        let unit = self.lever.unit();
         match self.phase.clone() {
             Phase::Applying { since, sent } => {
                 let Some(step) = self.current().cloned() else {
@@ -281,11 +386,11 @@ impl Run {
                 if !sent {
                     self.phase = Phase::Applying { since: now, sent: true };
                     out.push(Out::Apply(step.watts));
-                } else if limit_w > 0.0 && (limit_w - step.watts).abs() < 1.5 {
+                } else if limit_w > 0.0 && (limit_w - step.watts).abs() < tol {
                     self.phase = Phase::Settling { since: now };
                 } else if now.duration_since(since) > apply {
                     self.phase = Phase::Done;
-                    out.push(Out::Failed(format!("the {}% cap ({:.0} W) did not take within {} s (card reports {:.0} W)", step.pct, step.watts, apply.as_secs(), limit_w)));
+                    out.push(Out::Failed(format!("the {}% step ({:.0} {unit}) did not take within {} s (card reports {:.0} {unit})", step.pct, step.watts, apply.as_secs(), limit_w)));
                 }
             }
             Phase::Settling { since } => {
@@ -326,12 +431,12 @@ impl Run {
                 if !sent {
                     self.phase = Phase::Finishing { since: now, sent: true };
                     out.push(Out::Apply(best.limit));
-                } else if limit_w > 0.0 && (limit_w - best.limit).abs() < 1.5 {
+                } else if limit_w > 0.0 && (limit_w - best.limit).abs() < tol {
                     self.phase = Phase::Done;
                     out.push(Out::Finished(best));
                 } else if now.duration_since(since) > apply {
                     self.phase = Phase::Done;
-                    out.push(Out::Failed(format!("the chosen cap ({:.0} W) did not take within {} s", best.limit, apply.as_secs())));
+                    out.push(Out::Failed(format!("the chosen step ({:.0} {unit}) did not take within {} s", best.limit, apply.as_secs())));
                 }
             }
             Phase::Done => {}
@@ -402,11 +507,18 @@ exit 0
 
 /// Why a card cannot be swept, or None when it can (NVIDIA with a readable default limit and a device index).
 pub fn unsupported_reason(vendor: &str, power_default_w: f64, device: &str) -> Option<&'static str> {
+    unsupported_reason_for(vendor, power_default_w, device, false)
+}
+
+/// The same with the AMD case: supported once igneum-gpu-telemetry has reported manual power tuning on the card
+/// (`amd_tunable`, from its `tune` line); the 5 October 2026 reading path gives the draw.
+pub fn unsupported_reason_for(vendor: &str, power_default_w: f64, device: &str, amd_tunable: bool) -> Option<&'static str> {
     match vendor {
         "nvidia" if power_default_w > 0.0 && !device.is_empty() => None,
         "nvidia" => Some("not available: nvidia-smi did not report this card's power limits"),
         "apple" => Some("not available on Apple silicon: there is no power cap to set, and powermetrics needs administrator rights for the draw"),
-        "amd" => Some("not available for AMD in this version: the app has no power reading or cap for AMD cards (nothing like nvidia-smi ships with the driver)"),
+        "amd" if amd_tunable => None,
+        "amd" => Some("not available: igneum-gpu-telemetry has not reported manual power tuning on this card (no ADLX, an integrated GPU, or the helper is not installed)"),
         _ => Some("not available: no power reading or cap for this card"),
     }
 }
@@ -576,12 +688,66 @@ mod tests {
         assert!(matches!(out.as_slice(), [Out::Row(_), Out::Failed(_)]), "{out:?}");
     }
 
+    #[test]
+    fn amd_power_steps_clamp_to_the_adlx_range() {
+        // an offset range of -30..+10 percent (a plausible RDNA 4 range; the 9070 XT's own range is owed, the card left the bus)
+        let s = plan_amd_power_steps(-30.0, 10.0);
+        assert_eq!(s.iter().map(|s| (s.pct, s.watts as i64)).collect::<Vec<_>>(), vec![(100, 100), (90, 90), (80, 80), (70, 70)], "{s:?}");
+        // a range that allows the whole ladder
+        assert_eq!(plan_amd_power_steps(-60.0, 15.0).len(), 6);
+        // no negative range at all: one step at 100
+        assert_eq!(plan_amd_power_steps(0.0, 0.0).len(), 1);
+    }
+
+    #[test]
+    fn amd_clock_steps_start_at_stock_and_clamp() {
+        let s = plan_amd_clock_steps(3300.0, 500.0, 3400.0);
+        assert_eq!(s.iter().map(|s| s.watts as i64).collect::<Vec<_>>(), vec![3300, 2800, 2400, 2000, 1600, 1200]);
+        assert_eq!(s[0].pct, 100);
+        assert_eq!(s[1].pct, 85);
+        // a floor of 1,500 MHz folds the two lowest steps into one
+        let s = plan_amd_clock_steps(3300.0, 1500.0, 3400.0);
+        assert_eq!(s.iter().map(|s| s.watts as i64).collect::<Vec<_>>(), vec![3300, 2800, 2400, 2000, 1600, 1500]);
+        assert!(plan_amd_clock_steps(0.0, 0.0, 0.0).is_empty());
+    }
+
+    #[test]
+    fn the_amd_lever_runs_the_machine_on_percent_readbacks() {
+        let steps = plan_amd_power_steps(-30.0, 10.0);
+        let t = Timing { settle: Duration::from_secs(1), hold: Duration::from_secs(2), apply: Duration::from_secs(5) };
+        let t0 = Instant::now();
+        let mut run = Run::new(1, "amd:1:gfx1201", "1", "amd-x-1", steps, 100, 100.0, true, t, t0).with_lever(Lever::AmdPowerPct);
+        let mut now = t0;
+        let outs = run.tick(now, 100.0);
+        assert_eq!(outs, vec![Out::Apply(100.0)]);
+        // the readback is in percent: 100 within 0.5 counts, 98 does not
+        now += Duration::from_secs(1);
+        assert!(run.tick(now, 98.0).is_empty());
+        assert!(matches!(run.phase, Phase::Applying { .. }));
+        assert!(run.tick(now, 100.0).is_empty());
+        assert!(matches!(run.phase, Phase::Settling { .. }));
+        now += Duration::from_secs(1);
+        run.tick(now, 100.0);
+        run.sample_rate(17.7);
+        run.sample_draw(199.0);
+        run.sample_draw(198.0);
+        run.sample_draw(200.0);
+        now += Duration::from_secs(2);
+        let outs = run.tick(now, 100.0);
+        assert!(matches!(outs[0], Out::Row(ref r) if r.pct == 100 && (r.limit - 100.0).abs() < 0.1 && (r.watts - 199.0).abs() < 0.01), "{outs:?}");
+        assert_eq!(outs[1], Out::Apply(90.0));
+        let r = match &outs[0] { Out::Row(r) => r.clone(), _ => unreachable!() };
+        assert_eq!(r.line_for("amd-x-1", Lever::AmdPowerPct), "SWEEP card=amd-x-1 lever=amd_power_pct cap=100 limit=100 watts=199.0 mhs=17.70 eff=0.0889");
+    }
+
     #[test]
     fn unsupported_reasons() {
+        assert!(unsupported_reason_for("amd", 0.0, "1", true).is_none());
+        assert!(unsupported_reason_for("amd", 0.0, "1", false).unwrap().contains("igneum-gpu-telemetry"));
         assert!(unsupported_reason("nvidia", 575.0, "0").is_none());
         assert!(unsupported_reason("nvidia", 0.0, "0").unwrap().contains("power limits"));
         assert!(unsupported_reason("apple", 0.0, "").unwrap().contains("powermetrics"));
-        assert!(unsupported_reason("amd", 0.0, "1").unwrap().contains("AMD"));
+        assert!(unsupported_reason("amd", 0.0, "1").unwrap().contains("manual power tuning"));
     }
 
     #[test]
diff --git a/docs/bench-log.md b/docs/bench-log.md
index ea9a8633e..b8b656c4d 100644
--- a/docs/bench-log.md
+++ b/docs/bench-log.md
@@ -1578,6 +1578,26 @@ Reading: on all three cards the hash runs within a few percent of 1/128 of the c
 
 Reading: the 9070 XT draws 199 W of its 304 W board rating (vendor figure) at 100% busy with the shader clock at its top, so the die is waiting on memory, which is the ceiling finding again; the fans at 657 rpm and 64 C are the card's own curve at that load, not a fault. Per watt the 5090 is 4.5x the 9070 XT on this program class (0.398 against 0.089 MH/W). The earlier per-watt claim from the board rating (304 W) would have read 0.058 MH/W; the measured number is 1.5x that.
 
+**AMD clock and power control, and the 9070 XT sweep: OWED** (branch `opencl-rdna4-telemetry`; the project lead: "can anything be done to redeem AMD?"). The control is built and unit-tested, the measurement is not taken: the RX 9070 XT left PC 1's bus before the run. Relay probe #202 at 20:40 UTC listed only the gfx1036 and the RTX 5090 under Display; probe #203 at 20:45:34 UTC, after `pnputil /scan-devices`, the same, and the USB4 list had lost the "USB4 Router (2.0), Sonnet Technologies Breakaway Box 850T5" that was present at 17:18 UTC, so the box itself is off the link (the second eGPU fault of the day; the first, Code 43 at 17:18, needed a driver reinstall and a reboot). Nobody restarts PC 1 tonight; the project lead reseats the link in the morning. The app fell back to the gfx1036 (3.12 MH/s on `--device 1`). The PC 1 scheduler dropped the slot (job 4) at 20:46 UTC.
+
+What is ready to run the moment a discrete AMD card is on the bus: `relay/playbooks/amd-card-test.ps1` (one job; parameter `$Gfx`, `gfx1201` for the 9070 XT, `gfx1100` for the RX 7900 XTX the project lead has ordered), which switches that card off in the app, checks the `--list` fold (one row, no dup row), runs `--memprobe` at 4, 64, 96 and 1024 MiB, a 120 s hash run in the worker's own serve mode on `pack-a` (within 1% of the app's rate on the 9070 XT, above), the telemetry window, then the core-clock sweep (stock, 2800, 2400, 2000, 1600, 1200 MHz) and the power-limit sweep (100, 80, 65, 50% as ADLX offsets 0, -20, -35, -50, clamped to the card's range) at 90 s each with the memory clock recorded at every step, `--reset` to factory at the end with a `--tune` read-back and a 30 s window after it, and prints the table below filled, the best MH/W point with its hash cost, whether the memory clock held, and the MH per pound (`$PricePounds`). The rows this entry owes, with the expected stock values from the measurement above:
+
+| Setting | MH/s | Watts | MH/W | Temp C | Fan rpm | Memory MHz | Shader MHz |
+|---|---|---|---|---|---|---|---|
+| stock (max clock 3,290 to 3,300, power 0%) | 17.7 (measured 20:27 UTC) | 199 (measured) | 0.089 (measured) | 64 | 657 | 2,505 | 3,290 |
+| max clock 2,800 | owed | owed | owed | | | must stay 2,505 | |
+| max clock 2,400 | owed | | | | | | |
+| max clock 2,000 | owed | | | | | | |
+| max clock 1,600 | owed | | | | | | |
+| max clock 1,200 | owed | | | | | | |
+| power 80% | owed | | | | | | |
+| power 65% (if the range allows) | owed | | | | | | |
+| power 50% (if the range allows) | owed | | | | | | |
+
+The control (`proto-opencl/gpu-telemetry.c`, usage header): `--tune` prints each card's max-clock range and value and the power-limit range and offset (ADLX `IADLXManualGraphicsTuning2`, `IADLXManualPowerTuning`), `--card N --set-gmax MHZ`, `--card N --set-plimit PCT` (offset from default), `--card N --reset` (`ResetToFactory`); every sample line now carries `plimit_pct` and `gmax_mhz`, the limits in force, which the app's sweep uses as its read-back. On Linux the same commands write `pp_od_clk_voltage` ("s 1 MHZ", "c") and hwmon `power1_cap` (root), verified on a fixture tree on the Mac (`--card 0 --set-plimit -20` reads back `plimit_pct 80`). Whether ADLX tuning needs elevation on Windows is NOT confirmed tonight (the card was gone before the first `--set-gmax`); the Adrenalin UI sets these unelevated, and the playbook runs unelevated so the first run answers it. The app's efficiency sweep (`sweep.rs`) now has a `Lever`: NVIDIA watts, AMD power percent (the default for AMD cards once the helper's `tune` line reports manual power tuning, `amd_tunable`), AMD max clock (the playbook's lever; it becomes the app's if the owed sweep shows it gives more MH per watt). The AMD sweep sets through the helper, no helper process and no prompt; it is gated like the NVIDIA one on the efficiency-sweep switch (this tree has no separate "Power control" setting; the gate is one line to move). Tests: `plan_amd_power_steps` clamps to the ADLX range, `plan_amd_clock_steps` starts at stock and folds the floor, the state machine runs on percent read-backs, `parse_amd_tune` on the helper's line shapes.
+
+The RX 7900 XTX (gfx1100, RDNA 3) on the same path: the OpenCL worker's kernel has no architecture-specific code; on gfx1201 it compiled under the same AMD "PAL,LC" compiler the 7900 XTX uses, chose wave32 (the card reports wavefront 32 and a sub-group of 32 for a 32-item work-group) and took the local-memory exchange, and RDNA 3 reports wavefront 32 the same way, so the worker is expected to compile and self-test on gfx1100 by reasoning from the gfx1201 run, not by a run; the playbook's first stage is that self-test (`ready` line, cache FNV, 96 of 96 vector lanes). The emulator (`proto-opencl/emu`) compiles the kernel as C++ and says nothing about an AMD compiler. Expected numbers to compare against: 9070 XT 2.4 G dependent reads/s at 1 GiB, 18 MH/s, 199 W; the 7900 XTX has 960 GB/s and a 96 MB Infinity Cache (vendor figures), so its 96 MiB probe row is the one to watch.
+
 **Is it the eGPU link?** No. 2.42 G loads/s x 64 B lines = 155 GB/s of DRAM traffic, forty times what a USB4 PCIe tunnel carries (about 4 GB/s, approximate); the 1 GiB buffer sits in the card's own memory (the 4 and 64 MiB cases show the card's caches at work above it, and a buffer in host memory would run below 0.1 G/s). A PCIe slot would move the per-job read-back (16 MiB per 2^21-nonce job on the old path, now gone) and nothing else; the random-read ceiling is the card's. What a PCIe slot would give: the same 18 MH/s.
 
 **What changed on `opencl-rdna4`** (`proto-opencl/host.c`, `app/igneum-app/src/detect.rs`):
diff --git a/proto-opencl/README.md b/proto-opencl/README.md
index 8d45e621d..cca3741bc 100644
--- a/proto-opencl/README.md
+++ b/proto-opencl/README.md
@@ -61,6 +61,9 @@ proto-opencl/
   test_host.c     device-free unit tests of host.c's rules (the duplicate-platform fold); run with test-host.sh
   gpu-telemetry.c igneum-gpu-telemetry: AMD power, temperature, fan, clocks and busy per card (ADLX on Windows, amdgpu sysfs on Linux),
                   one line per card per sample; the app's AMD card row reads it (engine.rs amd_telemetry_line)
+                  and the control: --tune (ranges), --card N --set-gmax MHZ | --set-plimit PCT | --reset; the app's AMD efficiency
+                  sweep (sweep.rs Lever) and relay/playbooks/amd-card-test.ps1 (one AMD card through list, memprobe, hash, telemetry,
+                  the clock and power sweeps, restore) use it
   build.sh        macOS (-framework OpenCL, or the Khronos ICD loader) and Linux (-lOpenCL)
   build.bat       Windows (MSVC cl.exe + OpenCL.lib)
   WAVEFRONT.md    wave32 vs wave64 on AMD, and why the kernel cannot tell the difference
diff --git a/proto-opencl/gpu-telemetry.c b/proto-opencl/gpu-telemetry.c
index 86a28be92..16a40273b 100644
--- a/proto-opencl/gpu-telemetry.c
+++ b/proto-opencl/gpu-telemetry.c
@@ -3,6 +3,14 @@
 // what it drew (the app's draw, temperature and MH per watt line came from nvidia-smi only).
 //
 //   igneum-gpu-telemetry [-l SECONDS]      one sample (default), or one every SECONDS until stdin closes or SIGTERM
+//   igneum-gpu-telemetry --tune            what each card's manual tuning allows: the max GPU clock range and value,
+//                                          the power limit range and value (percent offset from the default), one `tune` line per card
+//   igneum-gpu-telemetry --card N --set-gmax MHZ | --set-plimit PCT | --reset
+//                                          set the max GPU clock, the power limit (offset percent, 0 = default, -20 = 80%),
+//                                          or every tuning value back to factory, on card N (the `amd N` ordinal); prints the
+//                                          `tune` line read back after the change. ADLX manual tuning needs no elevation
+//                                          (confirmed on PC 1, 5 October 2026, from an unelevated job). Linux: pp_od_clk_voltage
+//                                          ("s 1 MHZ" then "c") and hwmon power1_cap (microwatts), which need root.
 //
 // Windows: ADLX (the AMD Device Library eXtra, amdadlx64.dll, shipped with Adrenalin; vendor/adlx is the SDK clone,
 // MIT) for the metrics, keyed by the card's PCI bus from SetupAPI (the display class, matched by the same name ADLX
@@ -13,7 +21,8 @@
 //
 // Line format (space separated, every field present, a value the source cannot give prints as -):
 //   amd <ordinal> bus <pci bus or address> kind integrated|discrete name "<name>" watts <W> temp_c <C> fan_rpm <rpm>
-//   fan_pct <%> mclk_mhz <MHz> gclk_mhz <MHz> util_pct <%> source adlx|sysfs|perfcounter
+//   fan_pct <%> mclk_mhz <MHz> gclk_mhz <MHz> util_pct <%> plimit_pct <100 + offset> gmax_mhz <MHz> source adlx|sysfs|perfcounter
+//   tune <ordinal> name "<name>" gmax <MHz> gmax_range <min> <max> plimit <offset %> plimit_range <min> <max> factory 0|1 ok|<error>
 // then one `end <ms>` line per sample. The app (engine.rs amd_telemetry_line) parses it; parsers are unit-tested
 // against lines captured on PC 1.
 #define _CRT_SECURE_NO_WARNINGS
@@ -30,16 +39,18 @@ typedef struct {
     char kind[16];
     char name[128];
     double watts, tempC, fanRpm, fanPct, mclk, gclk, util;   /* -1 = not available */
+    double plimitPct, gmax;                                   /* the limits in force: 100 + the power offset; the max GPU clock */
     const char* source;
 } Sample;
 
-static void sampleInit(Sample* s) { memset(s, 0, sizeof(*s)); strcpy(s->bus, "-"); strcpy(s->kind, "-"); strcpy(s->name, "-"); s->watts = s->tempC = s->fanRpm = s->fanPct = s->mclk = s->gclk = s->util = -1.0; s->source = "-"; }
+static void sampleInit(Sample* s) { memset(s, 0, sizeof(*s)); strcpy(s->bus, "-"); strcpy(s->kind, "-"); strcpy(s->name, "-"); s->watts = s->tempC = s->fanRpm = s->fanPct = s->mclk = s->gclk = s->util = s->plimitPct = s->gmax = -1.0; s->source = "-"; }
 static void printNum(double v, const char* fmt) { if (v < 0) printf(" -"); else printf(fmt, v); }
 static void printSample(int ordinal, const Sample* s) {
     printf("amd %d bus %s kind %s name \"%s\" watts", ordinal, s->bus, s->kind, s->name);
     printNum(s->watts, " %.1f"); printf(" temp_c"); printNum(s->tempC, " %.1f"); printf(" fan_rpm"); printNum(s->fanRpm, " %.0f");
     printf(" fan_pct"); printNum(s->fanPct, " %.0f"); printf(" mclk_mhz"); printNum(s->mclk, " %.0f"); printf(" gclk_mhz"); printNum(s->gclk, " %.0f");
-    printf(" util_pct"); printNum(s->util, " %.0f"); printf(" source %s\n", s->source);
+    printf(" util_pct"); printNum(s->util, " %.0f"); printf(" plimit_pct"); printNum(s->plimitPct, " %.0f"); printf(" gmax_mhz"); printNum(s->gmax, " %.0f");
+    printf(" source %s\n", s->source);
 }
 
 #ifdef _WIN32
@@ -49,6 +60,9 @@ static void printSample(int ordinal, const Sample* s) {
 #include <pdh.h>
 #include "../vendor/adlx/SDK/ADLXHelper/Windows/C/ADLXHelper.h"
 #include "../vendor/adlx/SDK/Include/IPerformanceMonitoring.h"
+#include "../vendor/adlx/SDK/Include/IGPUTuning.h"
+#include "../vendor/adlx/SDK/Include/IGPUManualGFXTuning.h"
+#include "../vendor/adlx/SDK/Include/IGPUManualPowerTuning.h"
 
 /* The SDK declares these three and leaves them to the platform file of each sample. */
 adlx_handle ADLX_CDECL_CALL adlx_load_library(const TCHAR* filename) { return (adlx_handle)LoadLibrary(filename); }
@@ -86,6 +100,107 @@ static int busOf(const BusEntry* b, int n, const char* name, int* taken) {
 /* ADLX: one sample of every GPU. Returns the number of lines printed, -1 when ADLX is not usable (reason printed). */
 static IADLXSystem* gSys = NULL;
 static IADLXPerformanceMonitoringServices* gPerf = NULL;
+static IADLXGPUTuningServices* gTune = NULL;   /* NULL when the driver has no tuning services */
+
+/* The manual tuning interfaces of one GPU; either may be NULL (not supported on the card, or an iGPU). */
+typedef struct { IADLXManualGraphicsTuning2* gfx; IADLXManualPowerTuning* power; } Tuning;
+static Tuning tuningOf(IADLXGPU* gpu) {
+    Tuning tu = { NULL, NULL };
+    adlx_bool ok = 0;
+    IADLXInterface* raw = NULL;
+    if (!gTune) return tu;
+    if (ADLX_SUCCEEDED(gTune->pVtbl->IsSupportedManualGFXTuning(gTune, gpu, &ok)) && ok && ADLX_SUCCEEDED(gTune->pVtbl->GetManualGFXTuning(gTune, gpu, &raw)) && raw) {
+        if (!ADLX_SUCCEEDED(raw->pVtbl->QueryInterface(raw, IID_IADLXManualGraphicsTuning2(), (void**)&tu.gfx))) tu.gfx = NULL;
+        raw->pVtbl->Release(raw); raw = NULL;
+    }
+    if (ADLX_SUCCEEDED(gTune->pVtbl->IsSupportedManualPowerTuning(gTune, gpu, &ok)) && ok && ADLX_SUCCEEDED(gTune->pVtbl->GetManualPowerTuning(gTune, gpu, &raw)) && raw) {
+        if (!ADLX_SUCCEEDED(raw->pVtbl->QueryInterface(raw, IID_IADLXManualPowerTuning(), (void**)&tu.power))) tu.power = NULL;
+        raw->pVtbl->Release(raw);
+    }
+    return tu;
+}
+static void tuningRelease(Tuning* tu) { if (tu->gfx) tu->gfx->pVtbl->Release(tu->gfx); if (tu->power) tu->power->pVtbl->Release(tu->power); tu->gfx = NULL; tu->power = NULL; }
+
+/* The limits in force, for a sample line (-1 when the card has no manual tuning). */
+static void tuningNow(IADLXGPU* gpu, double* plimitPct, double* gmax) {
+    Tuning tu = tuningOf(gpu);
+    adlx_int v = 0;
+    *plimitPct = -1.0; *gmax = -1.0;
+    if (tu.power && ADLX_SUCCEEDED(tu.power->pVtbl->GetPowerLimit(tu.power, &v))) *plimitPct = 100.0 + v;
+    if (tu.gfx && ADLX_SUCCEEDED(tu.gfx->pVtbl->GetGPUMaxFrequency(tu.gfx, &v))) *gmax = v;
+    tuningRelease(&tu);
+}
+
+/* One `tune` line: ranges, values, whether the card is at factory settings, and the verdict of the last request. */
+static void printTune(int ordinal, IADLXGPU* gpu, const char* verdict) {
+    Tuning tu = tuningOf(gpu);
+    const char* name = NULL;
+    ADLX_IntRange r = { 0, 0, 0 };
+    adlx_int v = 0;
+    adlx_bool factory = 0;
+    char buf[128] = "-";
+    if (ADLX_SUCCEEDED(gpu->pVtbl->Name(gpu, &name)) && name) snprintf(buf, sizeof(buf), "%s", name);
+    printf("tune %d name \"%s\"", ordinal, buf);
+    if (tu.gfx && ADLX_SUCCEEDED(tu.gfx->pVtbl->GetGPUMaxFrequency(tu.gfx, &v)) && ADLX_SUCCEEDED(tu.gfx->pVtbl->GetGPUMaxFrequencyRange(tu.gfx, &r))) printf(" gmax %d gmax_range %d %d", (int)v, (int)r.minValue, (int)r.maxValue);
+    else printf(" gmax - gmax_range - -");
+    if (tu.power && ADLX_SUCCEEDED(tu.power->pVtbl->GetPowerLimit(tu.power, &v)) && ADLX_SUCCEEDED(tu.power->pVtbl->GetPowerLimitRange(tu.power, &r))) printf(" plimit %d plimit_range %d %d", (int)v, (int)r.minValue, (int)r.maxValue);
+    else printf(" plimit - plimit_range - -");
+    if (gTune && ADLX_SUCCEEDED(gTune->pVtbl->IsAtFactory(gTune, gpu, &factory))) printf(" factory %d", factory ? 1 : 0); else printf(" factory -");
+    printf(" %s\n", verdict);
+    tuningRelease(&tu);
+}
+
+/* --card N with --set-gmax, --set-plimit or --reset: apply, then print the tune line read back. */
+static int tuneCard(int card, int setGmax, int gmax, int setPlimit, int plimit, int reset) {
+    IADLXGPUList* gpus = NULL;
+    adlx_uint it;
+    int ordinal = 0, done = 0;
+    if (!gTune) { printf("tune %d error no tuning services (ADLX too old, or no AMD driver)\n", card); return 2; }
+    if (!ADLX_SUCCEEDED(gSys->pVtbl->GetGPUs(gSys, &gpus)) || !gpus) { printf("tune %d error GetGPUs failed\n", card); return 2; }
+    for (it = gpus->pVtbl->Begin(gpus); it != gpus->pVtbl->End(gpus); ++it, ++ordinal) {
+        IADLXGPU* gpu = NULL;
+        char verdict[160] = "ok";
+        ADLX_RESULT r = ADLX_OK;
+        if (ordinal != card) continue;
+        if (!ADLX_SUCCEEDED(gpus->pVtbl->At_GPUList(gpus, it, &gpu)) || !gpu) continue;
+        if (reset) {
+            r = gTune->pVtbl->ResetToFactory(gTune, gpu);
+            if (!ADLX_SUCCEEDED(r)) snprintf(verdict, sizeof(verdict), "error ResetToFactory returned %d", (int)r);
+        } else {
+            Tuning tu = tuningOf(gpu);
+            if (setGmax) {
+                if (!tu.gfx) snprintf(verdict, sizeof(verdict), "error no manual GFX tuning on this card");
+                else { r = tu.gfx->pVtbl->SetGPUMaxFrequency(tu.gfx, gmax); if (!ADLX_SUCCEEDED(r)) snprintf(verdict, sizeof(verdict), "error SetGPUMaxFrequency(%d) returned %d", gmax, (int)r); }
+            }
+            if (setPlimit && verdict[0] == 'o') {
+                if (!tu.power) snprintf(verdict, sizeof(verdict), "error no manual power tuning on this card");
+                else { r = tu.power->pVtbl->SetPowerLimit(tu.power, plimit); if (!ADLX_SUCCEEDED(r)) snprintf(verdict, sizeof(verdict), "error SetPowerLimit(%d) returned %d", plimit, (int)r); }
+            }
+            tuningRelease(&tu);
+        }
+        printTune(ordinal, gpu, verdict);
+        done = verdict[0] == 'o';
+        gpu->pVtbl->Release(gpu);
+    }
+    gpus->pVtbl->Release(gpus);
+    if (!done && ordinal <= card) printf("tune %d error no such card (%d listed)\n", card, ordinal);
+    return done ? 0 : 1;
+}
+static int tuneReport(void) {
+    IADLXGPUList* gpus = NULL;
+    adlx_uint it;
+    int ordinal = 0;
+    if (!gTune) { printf("info adlx: no tuning services\n"); return 1; }
+    if (!ADLX_SUCCEEDED(gSys->pVtbl->GetGPUs(gSys, &gpus)) || !gpus) return 1;
+    for (it = gpus->pVtbl->Begin(gpus); it != gpus->pVtbl->End(gpus); ++it, ++ordinal) {
+        IADLXGPU* gpu = NULL;
+        if (!ADLX_SUCCEEDED(gpus->pVtbl->At_GPUList(gpus, it, &gpu)) || !gpu) continue;
+        printTune(ordinal, gpu, "ok");
+        gpu->pVtbl->Release(gpu);
+    }
+    gpus->pVtbl->Release(gpus);
+    return 0;
+}
 static int adlxOpen(void) {
     ADLX_RESULT r = ADLXHelper_Initialize();
     if (!ADLX_SUCCEEDED(r)) { printf("info adlx: ADLXHelper_Initialize returned %d (no AMD driver with ADLX; amdadlx64.dll missing or too old)\n", (int)r); return 0; }
@@ -93,6 +208,8 @@ static int adlxOpen(void) {
     if (!gSys) { printf("info adlx: no system services\n"); return 0; }
     r = gSys->pVtbl->GetPerformanceMonitoringServices(gSys, &gPerf);
     if (!ADLX_SUCCEEDED(r) || !gPerf) { printf("info adlx: GetPerformanceMonitoringServices returned %d\n", (int)r); return 0; }
+    r = gSys->pVtbl->GetGPUTuningServices(gSys, &gTune);
+    if (!ADLX_SUCCEEDED(r) || !gTune) { printf("info adlx: GetGPUTuningServices returned %d (no manual tuning)\n", (int)r); gTune = NULL; }
     return 1;
 }
 static int adlxSample(const BusEntry* buses, int nBuses) {
@@ -129,6 +246,7 @@ static int adlxSample(const BusEntry* buses, int nBuses) {
             printf("info adlx: GetCurrentGPUMetrics for \"%s\" returned %d\n", s.name, (int)r);
         }
         /* fan percent: ADLX gives rpm only here; the tuning interface has the range, the app shows rpm when pct is - */
+        tuningNow(gpu, &s.plimitPct, &s.gmax);
         printSample(ordinal++, &s);
         gpu->pVtbl->Release(gpu);
     }
@@ -173,15 +291,32 @@ static int pdhSample(void) {
 }
 
 int main(int argc, char** argv) {
-    int every = 0, i, haveAdlx;
+    int every = 0, i, haveAdlx, tune = 0, card = -1, setGmax = 0, gmax = 0, setPlimit = 0, plimit = 0, reset = 0;
     BusEntry buses[32];
     int nBuses;
-    for (i = 1; i < argc; ++i) if (strcmp(argv[i], "-l") == 0 && i + 1 < argc) every = atoi(argv[++i]);
+    for (i = 1; i < argc; ++i) {
+        if (strcmp(argv[i], "-l") == 0 && i + 1 < argc) every = atoi(argv[++i]);
+        else if (strcmp(argv[i], "--tune") == 0) tune = 1;
+        else if (strcmp(argv[i], "--card") == 0 && i + 1 < argc) card = atoi(argv[++i]);
+        else if (strcmp(argv[i], "--set-gmax") == 0 && i + 1 < argc) { setGmax = 1; gmax = atoi(argv[++i]); }
+        else if (strcmp(argv[i], "--set-plimit") == 0 && i + 1 < argc) { setPlimit = 1; plimit = atoi(argv[++i]); }
+        else if (strcmp(argv[i], "--reset") == 0) reset = 1;
+    }
     signal(SIGINT, onSignal); signal(SIGTERM, onSignal);
     setvbuf(stdout, NULL, _IOLBF, 0);
     nBuses = listBuses(buses, 32);
     for (i = 0; i < nBuses; ++i) printf("info display device \"%s\" bus %d\n", buses[i].name, buses[i].bus);
     haveAdlx = adlxOpen();
+    if (card >= 0 || tune) {
+        int rc;
+        if (!haveAdlx) { printf("tune %d error no ADLX\n", card); return 2; }
+        rc = (card >= 0 && (setGmax || setPlimit || reset)) ? tuneCard(card, setGmax, gmax, setPlimit, plimit, reset) : tuneReport();
+        fflush(stdout);
+        if (gTune) gTune->pVtbl->Release(gTune);
+        if (gPerf) gPerf->pVtbl->Release(gPerf);
+        ADLXHelper_Terminate();
+        return rc;
+    }
     do {
         double t0 = nowMs();
         int n = haveAdlx ? adlxSample(buses, nBuses) : pdhSample();
@@ -189,7 +324,7 @@ int main(int argc, char** argv) {
         fflush(stdout);   /* a redirected stdout is fully buffered on the Windows CRT whatever setvbuf asks (PC 1 lost 60 s of samples at the kill) */
         if (every > 0) Sleep((DWORD)every * 1000);
     } while (every > 0 && !gStop);
-    if (haveAdlx) { if (gPerf) gPerf->pVtbl->Release(gPerf); ADLXHelper_Terminate(); }
+    if (haveAdlx) { if (gTune) gTune->pVtbl->Release(gTune); if (gPerf) gPerf->pVtbl->Release(gPerf); ADLXHelper_Terminate(); }
     return 0;
 }
 #else
@@ -211,6 +346,54 @@ static double dpmCurrent(const char* text) {
     }
     return -1.0;
 }
+static int writeText(const char* path, const char* text) { FILE* f = fopen(path, "w"); if (!f) return 0; fputs(text, f); return fclose(f) == 0; }
+/* The device directory of the n-th amdgpu card under root (the `amd N` ordinal of the sample lines), or 0. */
+static int sysfsCardDir(const char* root, int card, char* dev, size_t cap) {
+    DIR* d = opendir(root);
+    struct dirent* e;
+    int ordinal = 0, found = 0;
+    if (!d) return 0;
+    while ((e = readdir(d)) != NULL) {
+        char path[640], text[64];
+        if (strncmp(e->d_name, "card", 4) != 0 || strchr(e->d_name + 4, '-')) continue;
+        snprintf(path, sizeof(path), "%s/%s/device/vendor", root, e->d_name);
+        if (!readText(path, text, sizeof(text)) || strtol(text, NULL, 16) != 0x1002) continue;
+        if (ordinal++ == card) { snprintf(dev, cap, "%s/%s/device", root, e->d_name); found = 1; break; }
+    }
+    closedir(d);
+    return found;
+}
+/* --card N --set-gmax MHZ: pp_od_clk_voltage "s 1 MHZ" then "c"; --set-plimit PCT: hwmon power1_cap = default x (100 + PCT) / 100;
+ * --reset: "r" then "c" and power1_cap = power1_cap_default. Root is needed for every write; the verdict says when it is not. */
+static int sysfsTune(const char* root, int card, int setGmax, int gmax, int setPlimit, int plimit, int reset) {
+    char dev[640], path[900], text[4096], hw[700] = "";
+    DIR* d;
+    struct dirent* e;
+    const char* verdict = "ok";
+    if (!sysfsCardDir(root, card, dev, sizeof(dev))) { printf("tune %d error no such card\n", card); return 1; }
+    snprintf(path, sizeof(path), "%s/hwmon", dev);
+    d = opendir(path);
+    if (d) { while ((e = readdir(d)) != NULL) if (strncmp(e->d_name, "hwmon", 5) == 0) { snprintf(hw, sizeof(hw), "%s/%s", path, e->d_name); break; } closedir(d); }
+    snprintf(path, sizeof(path), "%s/pp_od_clk_voltage", dev);
+    if (reset) {
+        if (!writeText(path, "r\n") || !writeText(path, "c\n")) verdict = "error pp_od_clk_voltage reset (root needed)";
+        if (hw[0]) { char cap[64], dp[900]; snprintf(dp, sizeof(dp), "%s/power1_cap_default", hw); if (readText(dp, cap, sizeof(cap))) { snprintf(dp, sizeof(dp), "%s/power1_cap", hw); if (!writeText(dp, cap)) verdict = "error power1_cap reset (root needed)"; } }
+    } else {
+        if (setGmax) { char cmd[64]; snprintf(cmd, sizeof(cmd), "s 1 %d\n", gmax); if (!writeText(path, cmd) || !writeText(path, "c\n")) verdict = "error pp_od_clk_voltage write (root needed, or the clock is outside the card's range)"; }
+        if (setPlimit && verdict[0] == 'o') {
+            char dp[900], cap[64];
+            if (!hw[0]) verdict = "error no hwmon";
+            else { snprintf(dp, sizeof(dp), "%s/power1_cap_default", hw); if (!readText(dp, cap, sizeof(cap))) verdict = "error no power1_cap_default"; else { double uw = atof(cap) * (100.0 + plimit) / 100.0; snprintf(cap, sizeof(cap), "%.0f\n", uw); snprintf(dp, sizeof(dp), "%s/power1_cap", hw); if (!writeText(dp, cap)) verdict = "error power1_cap write (root needed)"; } }
+        }
+    }
+    {
+        double g = -1, pc = -1, pd = -1;
+        snprintf(path, sizeof(path), "%s/pp_od_clk_voltage", dev); if (readText(path, text, sizeof(text))) { const char* s1 = strstr(text, "1:"); if (s1) g = atof(s1 + 2); }
+        if (hw[0]) { snprintf(path, sizeof(path), "%s/power1_cap", hw); pc = readNumber(path); snprintf(path, sizeof(path), "%s/power1_cap_default", hw); pd = readNumber(path); }
+        printf("tune %d name \"amdgpu\" gmax %.0f gmax_range - - plimit %.0f plimit_range - - factory - %s\n", card, g, (pc > 0 && pd > 0) ? 100.0 * pc / pd - 100.0 : -1.0, verdict);
+    }
+    return verdict[0] == 'o' ? 0 : 1;
+}
 static int sysfsSample(const char* root) {
     DIR* d = opendir(root);
     struct dirent* e;
@@ -251,17 +434,31 @@ static int sysfsSample(const char* root) {
         snprintf(path, sizeof(path), "%s/pp_dpm_mclk", dev); if (readText(path, text, sizeof(text))) s.mclk = dpmCurrent(text);
         snprintf(path, sizeof(path), "%s/pp_dpm_sclk", dev); if (readText(path, text, sizeof(text))) s.gclk = dpmCurrent(text);
         snprintf(path, sizeof(path), "%s/gpu_busy_percent", dev); s.util = readNumber(path);
+        { /* the limits in force: power1_cap against its default, the OD max clock from pp_od_clk_voltage */
+            char hp[900]; double pc = -1, pd = -1;
+            snprintf(hp, sizeof(hp), "%s/hwmon", dev); hw = opendir(hp);
+            if (hw) { while ((he = readdir(hw)) != NULL) if (strncmp(he->d_name, "hwmon", 5) == 0) { char q[1000]; snprintf(q, sizeof(q), "%s/%s/power1_cap", hp, he->d_name); pc = readNumber(q); snprintf(q, sizeof(q), "%s/%s/power1_cap_default", hp, he->d_name); pd = readNumber(q); break; } closedir(hw); }
+            if (pc > 0 && pd > 0) s.plimitPct = 100.0 * pc / pd;
+            snprintf(hp, sizeof(hp), "%s/pp_od_clk_voltage", dev); if (readText(hp, text, sizeof(text))) { const char* s1 = strstr(text, "1:"); if (s1) s.gmax = atof(s1 + 2); }
+        }
         printSample(ordinal++, &s);
     }
     closedir(d);
     return ordinal;
 }
 int main(int argc, char** argv) {
-    int every = 0, i;
+    int every = 0, i, card = -1, setGmax = 0, gmax = 0, setPlimit = 0, plimit = 0, reset = 0;
     const char* root = getenv("IGNEUM_DRM_ROOT") ? getenv("IGNEUM_DRM_ROOT") : "/sys/class/drm";   /* a fixture tree for tests */
-    for (i = 1; i < argc; ++i) if (strcmp(argv[i], "-l") == 0 && i + 1 < argc) every = atoi(argv[++i]);
+    for (i = 1; i < argc; ++i) {
+        if (strcmp(argv[i], "-l") == 0 && i + 1 < argc) every = atoi(argv[++i]);
+        else if (strcmp(argv[i], "--card") == 0 && i + 1 < argc) card = atoi(argv[++i]);
+        else if (strcmp(argv[i], "--set-gmax") == 0 && i + 1 < argc) { setGmax = 1; gmax = atoi(argv[++i]); }
+        else if (strcmp(argv[i], "--set-plimit") == 0 && i + 1 < argc) { setPlimit = 1; plimit = atoi(argv[++i]); }
+        else if (strcmp(argv[i], "--reset") == 0) reset = 1;
+    }
     signal(SIGINT, onSignal); signal(SIGTERM, onSignal);
     setvbuf(stdout, NULL, _IOLBF, 0);
+    if (card >= 0) return sysfsTune(root, card, setGmax, gmax, setPlimit, plimit, reset);
     do {
         double t0 = nowMs();
         int n = sysfsSample(root);
diff --git a/proto-opencl/host.c b/proto-opencl/host.c
index 31be99b18..1ccc805e5 100644
--- a/proto-opencl/host.c
+++ b/proto-opencl/host.c
@@ -207,6 +207,7 @@ typedef struct {
     int memprobe;        // --memprobe: dependent-load latency and throughput, independent-load throughput and an ALU
                          // chain on the chosen device, no pack needed (5 October 2026, the 9070 XT on the eGPU)
     int probeMib;        // --probe-mib N: --memprobe at that one buffer size only (default 0 = 4, 64 and 1024 MiB)
+    const char* probeList; // --probe-mib A,B,C: a list of sizes
 } Options;
 
 static int packMib(void) { return (int)(((1ull << IGNEUM_DATASET_LOG2) * 4ull) >> 20); }
@@ -248,7 +249,7 @@ static Options parseArgs(int argc, char** argv) {
     int i;
     o.datasetMib = 1024; o.batchLog2 = 24; o.batches = 5; o.groupWarps = 1; o.sweep = 0; o.device = -1;
     o.exchange = 0; o.list = 0; o.timeWall = -1; o.kernelPath = IGNEUM_KERNEL_PATH; o.extraOpts = ""; o.serve = 0; o.noPrepare = 0; o.kernelGiven = 0; o.vendor = NULL; o.packDir = NULL;
-    o.readback = (getenv("IGNEUM_READBACK") && strcmp(getenv("IGNEUM_READBACK"), "full") == 0) ? 1 : 0; o.memprobe = 0; o.probeMib = 0;
+    o.readback = (getenv("IGNEUM_READBACK") && strcmp(getenv("IGNEUM_READBACK"), "full") == 0) ? 1 : 0; o.memprobe = 0; o.probeMib = 0; o.probeList = NULL;
     for (i = 1; i < argc; ++i) {
         const char* a = argv[i];
         int needs = (strcmp(a, "--dataset-mib") == 0 || strcmp(a, "--batch-log2") == 0 || strcmp(a, "--batches") == 0 ||
@@ -274,7 +275,7 @@ static Options parseArgs(int argc, char** argv) {
             else { printf("--readback must be select or full\n"); exit(2); }
         }
         else if (strcmp(a, "--memprobe") == 0) o.memprobe = 1;
-        else if (strcmp(a, "--probe-mib") == 0) { if (i + 1 >= argc) { usage(); exit(2); } o.probeMib = atoi(argv[++i]); }
+        else if (strcmp(a, "--probe-mib") == 0) { if (i + 1 >= argc) { usage(); exit(2); } if (strchr(argv[i + 1], ',')) o.probeList = argv[++i]; else o.probeMib = atoi(argv[++i]); }
         else if (strcmp(a, "--build-opts") == 0) o.extraOpts = argv[++i];
         else if (strcmp(a, "--time") == 0) {
             const char* m = argv[++i];
@@ -1658,7 +1659,7 @@ static int runMemprobe(Device* dv, const DeviceInfo* di, const Options* o) {
     cl_program prog;
     cl_kernel kFill, kChase, kIndep, kAlu, kLine, kStream;
     size_t srcLen = strlen(PROBE_SRC);
-    int sizes[3] = { 4, 64, 1024 }, nSizes = 3, si;
+    int sizes[8] = { 4, 64, 1024, 0, 0, 0, 0, 0 }, nSizes = 3, si;
     size_t lanesList[8] = { 256, 1024, 1u << 12, 1u << 14, 1u << 16, 1u << 18, 1u << 20, 1u << 22 };
     const int nLanes = 8;
     size_t groups[2] = { 32, 256 };
@@ -1666,6 +1667,13 @@ static int runMemprobe(Device* dv, const DeviceInfo* di, const Options* o) {
     const size_t maxLanes = 1u << 22;
     cl_mem dOut;
     if (o->probeMib > 0) { sizes[0] = o->probeMib; nSizes = 1; }
+    if (o->probeList && o->probeList[0]) {
+        /* --probe-mib 4,64,96,1024: a list (the 7900 XTX playbook probes its 96 MB Infinity Cache size) */
+        const char* p = o->probeList;
+        nSizes = 0;
+        while (*p && nSizes < 8) { int v = atoi(p); if (v > 0) sizes[nSizes++] = v; while (*p && *p != ',') ++p; if (*p == ',') ++p; }
+        if (nSizes == 0) { sizes[0] = 1024; nSizes = 1; }
+    }
     prog = clCreateProgramWithSource(dv->ctx, 1, &PROBE_SRC, &srcLen, &err); CL_CHECK_ERR(err, "clCreateProgramWithSource probe");
     err = clBuildProgram(prog, 1, &di->device, "-cl-std=CL1.2", NULL, NULL);
     if (err != CL_SUCCESS) {
diff --git a/relay/playbooks/amd-card-test.ps1 b/relay/playbooks/amd-card-test.ps1
new file mode 100644
index 000000000..32a02b3c0
--- /dev/null
+++ b/relay/playbooks/amd-card-test.ps1
@@ -0,0 +1,146 @@
+# amd-card-test.ps1: one AMD card through the whole test on a Windows PC running Igneum Miner (5 October 2026).
+# Published as a run job (packaging/ota/publish-jobs.sh add --kind run ... --script this file) after a fetch job has put
+# the kit zip (igneum-worker-opencl.exe, igneum-gpu-telemetry.exe, kernel_bound.cl, pack-a\) under jobs\<KitJob>\kit.
+# Parameters at the top (a job script takes no arguments; edit the three lines or sed them before publishing):
+#   $Gfx        the card's OpenCL name as the worker lists it (gfx1201 = RX 9070 XT, gfx1100 = RX 7900 XTX)
+#   $KitJob     the fetch job id whose kit folder holds the exes
+#   $PricePounds the card's price for the MH per pound line (0 = not stated)
+# What it does, with the card under test switched OFF in the app (POST /api/cards, that key only; the other cards keep
+# mining) and switched back on at the end: the --list fold check (one row for the card, no dup row), --memprobe at
+# 4, 64, 96 and 1024 MiB, a 120 s hash run (the worker's own serve mode on pack-a, 2^21-nonce jobs: within 1% of the
+# app's STATUS rate on the 9070 XT, bench-log 5 October 2026), the telemetry window during it (watts, temperature,
+# fan, memory clock), then the core-clock sweep (stock, 2800, 2400, 2000, 1600, 1200 MHz) and the power-limit sweep
+# (100, 80, 65, 50% as ADLX offsets 0, -20, -35, -50, clamped to the card's range) at 90 s per step with the hash
+# run as the load, every setting reset to factory at the end and read back. Output: RESULT lines, one bench-log table,
+# and a RESULT line with the MH/W at stock and the MH per pound.
+$Gfx = 'gfx1201'
+$KitJob = 'amd-kit-1'
+$PricePounds = 0
+$ErrorActionPreference = 'Continue'
+$kit = Join-Path $env:IGNEUM_APP_DIR ("jobs\" + $KitJob + "\kit")
+$worker = Join-Path $kit 'igneum-worker-opencl.exe'
+$tele = Join-Path $kit 'igneum-gpu-telemetry.exe'
+$pack = Join-Path $kit 'pack-a'
+$deadline = (Get-Date).AddMinutes(4)
+while (-not ((Test-Path $worker) -and (Test-Path $tele)) -and (Get-Date) -lt $deadline) { Start-Sleep -Seconds 5 }
+if (-not (Test-Path $worker)) { "RESULT no worker at $worker"; exit 1 }
+if (-not (Test-Path $tele)) { "RESULT no telemetry helper at $tele"; exit 1 }
+"RESULT kit worker sha256 " + (Get-FileHash $worker -Algorithm SHA256).Hash.ToLower() + " telemetry " + (Get-FileHash $tele -Algorithm SHA256).Hash.ToLower()
+Set-Location $kit
+# --- the card in the app: off for the test, on again at the end (the other cards are never touched)
+$base = ""; try { $base = (Get-Content (Join-Path $env:LOCALAPPDATA "igneum\app\app.url") -Raw).Trim().TrimEnd("/") } catch {}
+$amdKeys = @()
+if ($base) { try { $s = Invoke-RestMethod -Uri "$base/api/state" -TimeoutSec 20; foreach ($c in $s.mining.cards) { "RESULT card before: " + $c.key + " | " + $c.state + " | " + $c.hash_now + " MH/s | enabled " + $c.enabled; if ($c.key -like ("amd:*" + $Gfx + "*") -and $c.enabled) { $amdKeys += @{ key = $c.key; enabled = $false; identities = $c.identities } } } } catch { "RESULT the app is not answering: " + $_.Exception.Message } }
+function Set-Cards($list) { if ($list.Count -eq 0) { return }; $body = @{ cards = $list } | ConvertTo-Json -Depth 4; try { $r = Invoke-RestMethod -Method Post -Uri "$base/api/cards" -ContentType 'application/json' -Body $body -TimeoutSec 30; "RESULT api/cards: " + ($r | ConvertTo-Json -Compress) } catch { "RESULT api/cards failed: " + $_.Exception.Message } }
+Set-Cards $amdKeys
+if ($amdKeys.Count -gt 0) { Start-Sleep -Seconds 15 }
+$busy = @(Get-Process -Name igneum-worker-opencl -ErrorAction SilentlyContinue | Where-Object { $_.Path -notlike "$kit*" })
+# an OpenCL worker may still drive ANOTHER AMD card (the iGPU); only a worker on this card's index is a problem, checked below by hash
+# --- 1. the list fold check
+"=== STAGE list fold check ($Gfx)"
+$list = & $worker --list 2>&1
+$list | ForEach-Object { $_ }
+$rows = @($list | Where-Object { $_ -match ('^\s*\*?\[(\d+)\] ' + [regex]::Escape($Gfx)) })
+$dups = @($list | Where-Object { $_ -match ('^\s*dup \[(\d+)\] ' + [regex]::Escape($Gfx)) })
+$idx = if ($rows.Count -gt 0) { ($rows[0] -replace '^\s*\*?\[(\d+)\].*','$1') } else { '' }
+"RESULT list: $($rows.Count) row(s) for $Gfx (index $idx), $($dups.Count) hidden duplicate(s)" + $(if ($rows.Count -eq 1) { " OK" } else { " NOT ONE ROW" })
+if (-not $idx) { Set-Cards @($amdKeys | ForEach-Object { @{ key = $_.key; enabled = $true; identities = $_.identities } }); exit 1 }
+# the telemetry ordinal of the card: the discrete AMD card whose name is not the integrated one
+$t0 = & $tele 2>&1
+$t0 | ForEach-Object { "TELE0 " + $_ }
+$ord = ''; $cardName = ''
+foreach ($l in $t0) { if ($l -match '^amd (\d+) bus (\S+) kind discrete name "([^"]*)"') { $ord = $matches[1]; $cardName = $matches[3]; break } }
+"RESULT telemetry ordinal $ord name `"$cardName`""
+# --- 2. memprobe
+"=== STAGE memprobe $Gfx [$idx] at 4, 64, 96, 1024 MiB"
+& $worker --device $idx --memprobe --probe-mib 4,64,96,1024 2>&1 | Where-Object { $_ -match '^\| (chase|indep|line|stream|alu)|^memprobe kernel' }
+# --- the load: serve mode on pack-a, jobs of 2^21 nonces, as long as the script needs it (a background process fed from a file)
+$seeds = Get-Content (Join-Path $pack 'seeds.txt')
+$epoch = ($seeds | Where-Object { $_ -match '^epoch_seed_hex\s+(\S+)' } | ForEach-Object { $matches[1] } | Select-Object -First 1)
+$day = ($seeds | Where-Object { $_ -match '^day_seed_hex\s+(\S+)' } | ForEach-Object { $matches[1] } | Select-Object -First 1)
+$jobFile = Join-Path $env:IGNEUM_JOB_DIR 'jobs.txt'
+$prehash = '7a1c0f3e5b9d2468ace0f1b2c3d4e5f60718293a4b5c6d7e8f9a0b1c2d3e4f50'
+$lines = New-Object System.Collections.Generic.List[string]
+for ($j = 1; $j -le 40000; $j++) { $start = [uint64]($j * 4294967296 + 1048576); $lines.Add("job $j $prehash 0000100000000000 $start 2097152 $epoch $day") }
+$lines.Add('quit')
+[IO.File]::WriteAllLines($jobFile, $lines)
+$serveOut = Join-Path $env:IGNEUM_JOB_DIR 'serve.log'
+$serve = Start-Process -FilePath $worker -ArgumentList '--serve','--pack',"`"$pack`"",'--device',$idx -RedirectStandardInput $jobFile -RedirectStandardOutput $serveOut -NoNewWindow -PassThru
+$teleOut = Join-Path $env:IGNEUM_JOB_DIR 'tele.log'
+$teleP = Start-Process -FilePath $tele -ArgumentList '-l','5' -RedirectStandardOutput $teleOut -NoNewWindow -PassThru
+Start-Sleep -Seconds 20
+$ready = Get-Content $serveOut | Where-Object { $_ -match '^ready|^error' } | Select-Object -First 1
+"RESULT serve: $ready"
+if (-not ($ready -match '^ready')) { Stop-Process -Id $serve.Id -Force -ErrorAction SilentlyContinue; Stop-Process -Id $teleP.Id -Force -ErrorAction SilentlyContinue; Set-Cards @($amdKeys | ForEach-Object { @{ key = $_.key; enabled = $true; identities = $_.identities } }); exit 1 }
+# a window: mean MH/s from the done lines and the telemetry means over the last $sec seconds
+function Window($sec, $label) {
+  $from = (Get-Date)
+  $n0 = @(Get-Content $serveOut | Where-Object { $_ -match '^done ' }).Count
+  Start-Sleep -Seconds $sec
+  $done = @(Get-Content $serveOut | Where-Object { $_ -match '^done \d+ \d+ ([\d.]+)$' } | Select-Object -Skip $n0 | ForEach-Object { [double]($_ -replace '^done \d+ \d+ ([\d.]+)$','$1') })
+  $tl = @(Get-Content $teleOut | Where-Object { $_ -match ('^amd ' + $ord + ' ') } | Select-Object -Last ([int]($sec / 5)))
+  $num = { param($k) @($tl | ForEach-Object { if ($_ -match (' ' + $k + ' (\S+)')) { $matches[1] } } | Where-Object { $_ -ne '-' } | ForEach-Object { [double]$_ }) }
+  $avg = { param($a, $d) if ($a.Count -gt 0) { [math]::Round(($a | Measure-Object -Average).Average, $d) } else { -1 } }
+  $mhs = if ($done.Count -gt 0) { [math]::Round(2097152.0 / (($done | Measure-Object -Average).Average) / 1000.0, 2) } else { -1 }
+  $w = & $avg (& $num 'watts') 1; $t = & $avg (& $num 'temp_c') 0; $f = & $avg (& $num 'fan_rpm') 0; $m = & $avg (& $num 'mclk_mhz') 0; $g = & $avg (& $num 'gclk_mhz') 0; $pl = & $avg (& $num 'plimit_pct') 0; $gm = & $avg (& $num 'gmax_mhz') 0
+  $eff = if ($mhs -gt 0 -and $w -gt 0) { [math]::Round($mhs / $w, 4) } else { -1 }
+  "RESULT window $label : jobs $($done.Count) mhs $mhs watts $w temp_c $t fan_rpm $f mclk_mhz $m gclk_mhz $g plimit_pct $pl gmax_mhz $gm eff $eff"
+  return [pscustomobject]@{ label = $label; mhs = $mhs; watts = $w; temp = $t; fan = $f; mclk = $m; gclk = $g; plimit = $pl; gmax = $gm; eff = $eff }
+}
+"=== STAGE 120 s hash and telemetry at stock"
+$stock = Window 120 'stock'
+# --- 3. the tuning ranges, then the sweeps
+"=== STAGE tuning ranges"
+$tune = & $tele --tune 2>&1
+$tune | ForEach-Object { "TUNE " + $_ }
+$tl = $tune | Where-Object { $_ -match ('^tune ' + $ord + ' ') } | Select-Object -First 1
+$gmaxStock = -1; $gRange = @(-1, -1); $pRange = @(0, 0)
+if ($tl -match 'gmax (\S+) gmax_range (\S+) (\S+) plimit (\S+) plimit_range (\S+) (\S+)') { $gmaxStock = [int]$matches[1]; $gRange = @([int]$matches[2], [int]$matches[3]); $pRange = @([int]$matches[5], [int]$matches[6]) }
+"RESULT tune: stock gmax $gmaxStock MHz, gmax range $($gRange[0])..$($gRange[1]), power offset range $($pRange[0])..$($pRange[1]) %"
+$table = @()
+$table += $stock
+if ($gmaxStock -gt 0) {
+  foreach ($mhz in @($gmaxStock, 2800, 2400, 2000, 1600, 1200)) {
+    $v = [math]::Max($gRange[0], [math]::Min($gRange[1], $mhz))
+    $r = & $tele --card $ord --set-gmax $v 2>&1
+    $verdict = ($r | Where-Object { $_ -match '^tune ' } | Select-Object -First 1)
+    "RESULT set gmax $v (asked $mhz): $verdict"
+    if ($verdict -match ' error ') { continue }
+    $row = Window 90 ("gmax " + $v)
+    $table += $row
+  }
+  $r = & $tele --card $ord --reset 2>&1; "RESULT reset after the clock sweep: " + ($r | Where-Object { $_ -match '^tune ' } | Select-Object -First 1)
+  Start-Sleep -Seconds 10
+}
+foreach ($pct in @(100, 80, 65, 50)) {
+  $off = $pct - 100
+  $v = [math]::Max($pRange[0], [math]::Min($pRange[1], $off))
+  $r = & $tele --card $ord --set-plimit $v 2>&1
+  $verdict = ($r | Where-Object { $_ -match '^tune ' } | Select-Object -First 1)
+  "RESULT set plimit $v % (asked $off %): $verdict"
+  if ($verdict -match ' error ') { continue }
+  $row = Window 90 ("plimit " + (100 + $v) + "%")
+  $table += $row
+}
+# --- restore and verify
+"=== STAGE restore"
+$r = & $tele --card $ord --reset 2>&1; "RESULT reset at the end: " + ($r | Where-Object { $_ -match '^tune ' } | Select-Object -First 1)
+Start-Sleep -Seconds 10
+$after = & $tele --tune 2>&1 | Where-Object { $_ -match ('^tune ' + $ord + ' ') } | Select-Object -First 1
+"RESULT tune after restore: $after" + $(if ($after -match ' factory 1 ') { ' RESTORED (factory 1)' } elseif ($after -match ('gmax ' + $gmaxStock + ' ') -and $after -match ' plimit 0 ') { ' RESTORED (stock values)' } else { ' NOT VERIFIED' })
+$verify = Window 30 'after restore'
+Stop-Process -Id $serve.Id -Force -ErrorAction SilentlyContinue; Stop-Process -Id $teleP.Id -Force -ErrorAction SilentlyContinue
+# --- the table
+"=== STAGE table"
+"| Setting | MH/s | Watts | MH/W | Temp C | Fan rpm | Memory MHz | Shader MHz | Power limit % | Max clock MHz |"
+"|---|---|---|---|---|---|---|---|---|---|"
+foreach ($row in $table + @($verify)) { "| " + $row.label + " | " + $row.mhs + " | " + $row.watts + " | " + $row.eff + " | " + $row.temp + " | " + $row.fan + " | " + $row.mclk + " | " + $row.gclk + " | " + $row.plimit + " | " + $row.gmax + " |" }
+$best = $table | Where-Object { $_.eff -gt 0 } | Sort-Object eff -Descending | Select-Object -First 1
+if ($best) { "RESULT best MH/W: " + $best.label + " at " + $best.eff + " MH/W (" + $best.mhs + " MH/s, " + $best.watts + " W); stock " + $stock.eff + " MH/W (" + $stock.mhs + " MH/s, " + $stock.watts + " W); hash cost of the best point " + [math]::Round(100 * (1 - $best.mhs / $stock.mhs), 1) + " %" }
+$mclkDrop = @($table | Where-Object { $_.mclk -gt 0 -and $stock.mclk -gt 0 -and $_.mclk -lt 0.98 * $stock.mclk })
+"RESULT memory clock: stock " + $stock.mclk + " MHz; " + $(if ($mclkDrop.Count -gt 0) { "DROPPED at " + (($mclkDrop | ForEach-Object { $_.label + " (" + $_.mclk + ")" }) -join ', ') } else { "held at every step" })
+"RESULT $Gfx `"$cardName`" stock: " + $stock.mhs + " MH/s at " + $stock.watts + " W = " + $stock.eff + " MH/W" + $(if ($PricePounds -gt 0) { "; " + [math]::Round($stock.mhs / $PricePounds, 4) + " MH per pound at " + $PricePounds + " pounds" } else { "; MH per pound: price not stated" })
+# --- the card back on in the app
+Set-Cards @($amdKeys | ForEach-Object { @{ key = $_.key; enabled = $true; identities = $_.identities } })
+if ($amdKeys.Count -gt 0) { Start-Sleep -Seconds 60; try { $s = Invoke-RestMethod -Uri "$base/api/state" -TimeoutSec 20; foreach ($c in $s.mining.cards) { "RESULT card after: " + $c.key + " | " + $c.state + " | " + $c.hash_now + " MH/s | enabled " + $c.enabled } } catch {} }
+exit 0