From e4f7519ef3309bf6fb5a3ef12fbf79b584a8ff44 Mon Sep 17 00:00:00 2001
From: Mikhail Chusavitin <mchusavitin@mchusmbp.local>
Date: Fri, 4 Sep 2026 10:04:47 +0300
Subject: [PATCH 1/9] feat(webui): show GPU serial in NVIDIA selection pickers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Every GPU-selection picker (Load/SAT, Burn, Benchmark) now renders the
card serial: "GPU N — <model> · <mem> MiB · sn: <serial>". The serial is
monospace and the digits that differ across the listed GPUs (common
prefix/suffix stripped) are emphasised so operators can tell cards apart.

Row markup was duplicated across three pages (and twice within
page_validate.go). Consolidated into a single module,
internal/webui/gpu_picker.go: beeGpuPicker.render({...}) builds every row;
gpuPickerCSS/gpuPickerJS are injected once by layoutHead/renderPage. Pages
keep their own selection-note text and multi-GPU toggles but no longer
hand-build <label> markup.

ListNvidiaGPUs() adds the serial via nvidia-smi --query-gpu=...,serial;
N/A is normalised to empty. Serial flows to the client unchanged through
the existing /api/gpu/nvidia JSON response.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AudE3Q2nd9kxxVuxPKcTho
---
 audit/internal/platform/sat_gpu_packs.go  | 15 ++++-
 audit/internal/webui/gpu_picker.go        | 71 +++++++++++++++++++++++
 audit/internal/webui/layout.go            |  1 +
 audit/internal/webui/page_benchmark.go    | 22 ++-----
 audit/internal/webui/page_burn.go         | 22 ++-----
 audit/internal/webui/page_validate.go     | 40 ++++---------
 audit/internal/webui/pages.go             |  1 +
 bible-local/docs/gpu-model-propagation.md |  8 ++-
 8 files changed, 112 insertions(+), 68 deletions(-)
 create mode 100644 audit/internal/webui/gpu_picker.go

diff --git a/audit/internal/platform/sat_gpu_packs.go b/audit/internal/platform/sat_gpu_packs.go
index cf9e64f..ef0acae 100644
--- a/audit/internal/platform/sat_gpu_packs.go
+++ b/audit/internal/platform/sat_gpu_packs.go
@@ -14,6 +14,7 @@ type NvidiaGPU struct {
 	Index    int    `json:"index"`
 	Name     string `json:"name"`
 	MemoryMB int    `json:"memory_mb"`
+	Serial   string `json:"serial,omitempty"`
 }
 
 type NvidiaGPUStatus struct {
@@ -226,7 +227,7 @@ func amdStressJobs(seconds int, cfgFile string) []satJob {
 // ListNvidiaGPUs returns GPUs visible to nvidia-smi.
 func (s *System) ListNvidiaGPUs() ([]NvidiaGPU, error) {
 	out, err := exec.Command("nvidia-smi",
-		"--query-gpu=index,name,memory.total",
+		"--query-gpu=index,name,memory.total,serial",
 		"--format=csv,noheader,nounits").Output()
 	if err != nil {
 		return nil, fmt.Errorf("nvidia-smi: %w", err)
@@ -237,8 +238,8 @@ func (s *System) ListNvidiaGPUs() ([]NvidiaGPU, error) {
 		if line == "" {
 			continue
 		}
-		parts := strings.SplitN(line, ", ", 3)
-		if len(parts) != 3 {
+		parts := strings.SplitN(line, ", ", 4)
+		if len(parts) < 3 {
 			continue
 		}
 		idx, err := strconv.Atoi(strings.TrimSpace(parts[0]))
@@ -246,10 +247,18 @@ func (s *System) ListNvidiaGPUs() ([]NvidiaGPU, error) {
 			continue
 		}
 		memMB, _ := strconv.Atoi(strings.TrimSpace(parts[2]))
+		serial := ""
+		if len(parts) == 4 {
+			serial = strings.TrimSpace(parts[3])
+			if strings.EqualFold(serial, "N/A") || strings.EqualFold(serial, "[N/A]") {
+				serial = ""
+			}
+		}
 		gpus = append(gpus, NvidiaGPU{
 			Index:    idx,
 			Name:     strings.TrimSpace(parts[1]),
 			MemoryMB: memMB,
+			Serial:   serial,
 		})
 	}
 	sort.Slice(gpus, func(i, j int) bool {
diff --git a/audit/internal/webui/gpu_picker.go b/audit/internal/webui/gpu_picker.go
new file mode 100644
index 0000000..7f382ce
--- /dev/null
+++ b/audit/internal/webui/gpu_picker.go
@@ -0,0 +1,71 @@
+package webui
+
+// Shared NVIDIA GPU selection picker.
+//
+// Every page that lets the operator pick GPUs (Load, Burn, Benchmark) renders
+// the same row markup: "GPU N — <model> · <memory> MiB · sn: <serial>". That
+// markup lives here once. Pages keep their own selection-note text, multi-GPU
+// mode toggles and CSS-class prefixes, but call beeGpuPicker.render({...}) from
+// their *RenderGPUList wrapper instead of hand-building each <label>.
+//
+// The serial number is rendered monospace, with the digits that differ across
+// the listed GPUs (usually a run at the end, sometimes the middle or start)
+// emphasised so operators can tell cards apart at a glance.
+//
+// gpuPickerCSS is injected once by layoutHead; gpuPickerJS once by renderPage.
+
+const gpuPickerCSS = `.bee-gpu-row{display:flex;align-items:flex-start;gap:8px;padding:6px 0;cursor:pointer;font-size:13px}
+.bee-gpu-row input[type=checkbox]{width:16px;height:16px;margin-top:2px;flex-shrink:0}
+.bee-gpu-sn{font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:12px}
+.bee-gpu-sn b{font-weight:700;color:var(--accent)}`
+
+const gpuPickerJS = `window.beeGpuPicker={
+  _esc:function(s){return String(s).replace(/[&<>"]/g,function(c){return {'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c];});},
+  _commonPrefix:function(arr){
+    arr=arr.filter(Boolean);
+    if(arr.length<2)return 0;
+    var n=0,a=arr[0];
+    while(n<a.length&&arr.every(function(s){return s.charAt(n)===a.charAt(n);}))n++;
+    return n;
+  },
+  _commonSuffix:function(arr,capLeft){
+    arr=arr.filter(Boolean);
+    if(arr.length<2)return 0;
+    var minLen=Math.min.apply(null,arr.map(function(s){return s.length;}));
+    var n=0,a=arr[0];
+    while(n<a.length&&capLeft+n<minLen&&arr.every(function(s){return s.charAt(s.length-1-n)===a.charAt(a.length-1-n);}))n++;
+    return n;
+  },
+  _fmtSerial:function(s,p,q){
+    s=String(s);
+    if(p+q>=s.length){p=0;q=0;}
+    if(p===0&&q===0)return this._esc(s); // nothing distinguishing to highlight
+    return this._esc(s.slice(0,p))+'<b>'+this._esc(s.slice(p,s.length-q))+'</b>'+this._esc(s.slice(s.length-q));
+  },
+  row:function(gpu,checkboxClass,onToggle,prefixLen,suffixLen){
+    var mem=gpu.memory_mb>0?' · '+gpu.memory_mb+' MiB':'';
+    var name=this._esc(gpu.name||('GPU '+gpu.index));
+    var sn=gpu.serial?' · <span class="bee-gpu-sn">sn: '+this._fmtSerial(gpu.serial,prefixLen||0,suffixLen||0)+'</span>':'';
+    return '<label class="bee-gpu-row">'
+      +'<input class="'+checkboxClass+'" type="checkbox" value="'+gpu.index+'" checked'
+      +(onToggle?' onchange="'+onToggle+'"':'')+'>'
+      +'<span><strong>GPU '+gpu.index+'</strong> — '+name+mem+sn+'</span>'
+      +'</label>';
+  },
+  render:function(opts){
+    var root=document.getElementById(opts.rootId);
+    if(!root)return;
+    var gpus=opts.gpus||[];
+    if(!gpus.length){
+      root.innerHTML=opts.emptyHTML||'<p style="color:var(--muted);font-size:13px">No NVIDIA GPUs detected.</p>';
+      if(opts.after)opts.after(0);
+      return;
+    }
+    var serials=gpus.map(function(g){return g.serial||'';});
+    var p=this._commonPrefix(serials);
+    var q=this._commonSuffix(serials,p);
+    var self=this;
+    root.innerHTML=gpus.map(function(g){return self.row(g,opts.checkboxClass,opts.onToggle,p,q);}).join('');
+    if(opts.after)opts.after(gpus.length);
+  }
+};`
diff --git a/audit/internal/webui/layout.go b/audit/internal/webui/layout.go
index a7ec1ce..6e98c84 100644
--- a/audit/internal/webui/layout.go
+++ b/audit/internal/webui/layout.go
@@ -91,6 +91,7 @@ tbody tr:hover td{background:rgba(0,0,0,.03)}
 .alert-info{background:#dff0ff;border:1px solid #a9d4f5;color:#1e3a5f}
 .alert-warn{background:var(--warn-bg);border:1px solid #c9ba9b;color:var(--warn-fg)}
 .alert-crit{background:var(--crit-bg);border:1px solid var(--crit-border);color:var(--crit-fg);font-weight:700}
+` + gpuPickerCSS + `
 </style>
 </head>
 <body>
diff --git a/audit/internal/webui/page_benchmark.go b/audit/internal/webui/page_benchmark.go
index f8b876d..bbdf77f 100644
--- a/audit/internal/webui/page_benchmark.go
+++ b/audit/internal/webui/page_benchmark.go
@@ -97,8 +97,6 @@ func renderBenchmark(opts HandlerOptions) string {
 <style>
 .benchmark-cb-row { display:flex; align-items:flex-start; gap:8px; cursor:pointer; font-size:13px; }
 .benchmark-cb-row input[type=checkbox] { width:16px; height:16px; margin-top:2px; flex-shrink:0; }
-.benchmark-gpu-row { display:flex; align-items:flex-start; gap:8px; padding:6px 0; cursor:pointer; font-size:13px; }
-.benchmark-gpu-row input[type=checkbox] { width:16px; height:16px; margin-top:2px; flex-shrink:0; }
 </style>
 
 <script>
@@ -142,21 +140,11 @@ function benchmarkUpdateSelectionNote() {
   }
 }
 function benchmarkRenderGPUList(gpus) {
-  const root = document.getElementById('benchmark-gpu-list');
-  if (!gpus || !gpus.length) {
-    root.innerHTML = '<p style="color:var(--muted);font-size:13px">No NVIDIA GPUs detected.</p>';
-    benchmarkUpdateSelectionNote();
-    return;
-  }
-  root.innerHTML = gpus.map(function(gpu) {
-    const mem = gpu.memory_mb > 0 ? ' · ' + gpu.memory_mb + ' MiB' : '';
-    return '<label class="benchmark-gpu-row">'
-      + '<input class="benchmark-gpu-checkbox" type="checkbox" value="' + gpu.index + '" checked onchange="benchmarkUpdateSelectionNote()">'
-      + '<span><strong>GPU ' + gpu.index + '</strong> — ' + gpu.name + mem + '</span>'
-      + '</label>';
-  }).join('');
-  benchmarkApplyMultiGPUState(gpus.length);
-  benchmarkUpdateSelectionNote();
+  beeGpuPicker.render({
+    rootId: 'benchmark-gpu-list', gpus: gpus,
+    checkboxClass: 'benchmark-gpu-checkbox', onToggle: 'benchmarkUpdateSelectionNote()',
+    after: function(n) { benchmarkApplyMultiGPUState(n); benchmarkUpdateSelectionNote(); },
+  });
 }
 function benchmarkApplyMultiGPUState(gpuCount) {
   var multiValues = ['parallel', 'ramp-up'];
diff --git a/audit/internal/webui/page_burn.go b/audit/internal/webui/page_burn.go
index fac65d4..59e050f 100644
--- a/audit/internal/webui/page_burn.go
+++ b/audit/internal/webui/page_burn.go
@@ -92,8 +92,6 @@ func renderBurn() string {
 .cb-row input[type=checkbox]:disabled { opacity:0.4; cursor:not-allowed; }
 .cb-row input[type=checkbox]:disabled ~ span { opacity:0.45; cursor:not-allowed; }
 .cb-note { font-size:11px; color:var(--muted); font-style:italic; }
-.burn-gpu-row { display:flex; align-items:flex-start; gap:8px; padding:6px 0; cursor:pointer; font-size:13px; }
-.burn-gpu-row input[type=checkbox] { width:16px; height:16px; margin-top:2px; flex-shrink:0; }
 .burn-profile-body { display:grid; grid-template-columns:1fr 1fr 1fr; gap:24px; align-items:stretch; }
 .burn-profile-col { min-width:0; }
 .burn-profile-action { display:flex; flex-direction:column; align-items:center; justify-content:flex-start; gap:8px; }
@@ -159,21 +157,11 @@ function burnUpdateSelectionNote() {
   note.textContent = 'Selected NVIDIA GPUs: ' + selected.join(', ') + '. Official and custom NVIDIA tasks will use only these GPUs.';
 }
 function burnRenderGPUList(gpus) {
-  const root = document.getElementById('burn-gpu-list');
-  if (!gpus || !gpus.length) {
-    root.innerHTML = '<p style="color:var(--muted);font-size:13px">No NVIDIA GPUs detected.</p>';
-    burnUpdateSelectionNote();
-    return;
-  }
-  root.innerHTML = gpus.map(function(gpu) {
-    const mem = gpu.memory_mb > 0 ? ' · ' + gpu.memory_mb + ' MiB' : '';
-    return '<label class="burn-gpu-row">'
-      + '<input class="burn-gpu-checkbox" type="checkbox" value="' + gpu.index + '" checked onchange="burnUpdateSelectionNote()">'
-      + '<span><strong>GPU ' + gpu.index + '</strong> — ' + gpu.name + mem + '</span>'
-      + '</label>';
-  }).join('');
-  burnApplyMultiGPUState(gpus.length);
-  burnUpdateSelectionNote();
+  beeGpuPicker.render({
+    rootId: 'burn-gpu-list', gpus: gpus,
+    checkboxClass: 'burn-gpu-checkbox', onToggle: 'burnUpdateSelectionNote()',
+    after: function(n) { burnApplyMultiGPUState(n); burnUpdateSelectionNote(); },
+  });
 }
 function burnSelectAll() {
   document.querySelectorAll('.burn-gpu-checkbox').forEach(function(el) { el.checked = true; });
diff --git a/audit/internal/webui/page_validate.go b/audit/internal/webui/page_validate.go
index dd7f5f3..53b184d 100644
--- a/audit/internal/webui/page_validate.go
+++ b/audit/internal/webui/page_validate.go
@@ -212,8 +212,6 @@ func renderValidateMode(opts HandlerOptions, stressDefault bool) string {
 .validate-card-body { padding:0; }
 .validate-card-section { padding:12px 16px 0; }
 .validate-card-section:last-child { padding-bottom:16px; }
-.sat-gpu-row { display:flex; align-items:flex-start; gap:8px; padding:6px 0; cursor:pointer; font-size:13px; }
-.sat-gpu-row input[type=checkbox] { width:16px; height:16px; margin-top:2px; flex-shrink:0; }
 </style>
 <script>
 let satES = null;
@@ -251,21 +249,11 @@ function satUpdateGPUSelectionNote() {
   note.textContent = 'Selected GPUs: ' + selected.join(', ') + '. Multi-GPU tests will use all selected GPUs.';
 }
 function satRenderGPUList(gpus) {
-  const root = document.getElementById('sat-gpu-list');
-  if (!root) return;
-  if (!gpus || !gpus.length) {
-    root.innerHTML = '<p style="color:var(--muted);font-size:13px">No NVIDIA GPUs detected.</p>';
-    satUpdateGPUSelectionNote();
-    return;
-  }
-  root.innerHTML = gpus.map(function(gpu) {
-    const mem = gpu.memory_mb > 0 ? ' · ' + gpu.memory_mb + ' MiB' : '';
-    return '<label class="sat-gpu-row">'
-      + '<input class="sat-nvidia-checkbox" type="checkbox" value="' + gpu.index + '" checked onchange="satUpdateGPUSelectionNote()">'
-      + '<span><strong>GPU ' + gpu.index + '</strong> — ' + gpu.name + mem + '</span>'
-      + '</label>';
-  }).join('');
-  satUpdateGPUSelectionNote();
+  beeGpuPicker.render({
+    rootId: 'sat-gpu-list', gpus: gpus,
+    checkboxClass: 'sat-nvidia-checkbox', onToggle: 'satUpdateGPUSelectionNote()',
+    after: function() { satUpdateGPUSelectionNote(); },
+  });
 }
 function satSelectAllGPUs() {
   document.querySelectorAll('.sat-nvidia-checkbox').forEach(function(el) { el.checked = true; });
@@ -729,8 +717,6 @@ func renderCheck(opts HandlerOptions) string {
 .validate-card-body { padding:0; }
 .validate-card-section { padding:12px 16px 0; }
 .validate-card-section:last-child { padding-bottom:16px; }
-.sat-gpu-row { display:flex; align-items:flex-start; gap:8px; padding:6px 0; cursor:pointer; font-size:13px; }
-.sat-gpu-row input[type=checkbox] { width:16px; height:16px; margin-top:2px; flex-shrink:0; }
 .cb-row { display:flex; align-items:flex-start; gap:8px; padding:4px 0; cursor:pointer; font-size:13px; }
 .cb-row input[type=checkbox] { width:16px; height:16px; margin-top:2px; flex-shrink:0; }
 </style>
@@ -765,17 +751,11 @@ function satUpdateGPUSelectionNote() {
     : 'Select at least one NVIDIA GPU to enable NVIDIA check tasks.';
 }
 function satRenderGPUList(gpus) {
-  const root = document.getElementById('sat-gpu-list');
-  if (!root) return;
-  if (!gpus || !gpus.length) {
-    root.innerHTML = '<p style="color:var(--muted);font-size:13px">No NVIDIA GPUs detected.</p>';
-    satUpdateGPUSelectionNote(); return;
-  }
-  root.innerHTML = gpus.map(gpu => {
-    const mem = gpu.memory_mb > 0 ? ' · ' + gpu.memory_mb + ' MiB' : '';
-    return '<label class="sat-gpu-row"><input class="sat-nvidia-checkbox" type="checkbox" value="' + gpu.index + '" checked onchange="satUpdateGPUSelectionNote()"><span><strong>GPU ' + gpu.index + '</strong> — ' + gpu.name + mem + '</span></label>';
-  }).join('');
-  satUpdateGPUSelectionNote();
+  beeGpuPicker.render({
+    rootId: 'sat-gpu-list', gpus: gpus,
+    checkboxClass: 'sat-nvidia-checkbox', onToggle: 'satUpdateGPUSelectionNote()',
+    after: function() { satUpdateGPUSelectionNote(); },
+  });
 }
 function satSelectAllGPUs() { document.querySelectorAll('.sat-nvidia-checkbox').forEach(el => { el.checked = true; }); satUpdateGPUSelectionNote(); }
 function satSelectNoGPUs() { document.querySelectorAll('.sat-nvidia-checkbox').forEach(el => { el.checked = false; }); satUpdateGPUSelectionNote(); }
diff --git a/audit/internal/webui/pages.go b/audit/internal/webui/pages.go
index eaec203..66a8854 100644
--- a/audit/internal/webui/pages.go
+++ b/audit/internal/webui/pages.go
@@ -126,6 +126,7 @@ function openComponentDetail(type) {
     body.innerHTML = '<div style="padding:20px;color:var(--crit-fg)">Error loading details.</div>';
   });
 }
+` + gpuPickerJS + `
 </script>` +
 		`</body></html>`
 }
diff --git a/bible-local/docs/gpu-model-propagation.md b/bible-local/docs/gpu-model-propagation.md
index f53f451..06b2449 100644
--- a/bible-local/docs/gpu-model-propagation.md
+++ b/bible-local/docs/gpu-model-propagation.md
@@ -81,7 +81,13 @@ This happens for:
 **File:** `audit/internal/webui/pages.go`
 
 - Source: `GET /api/gpus` → `api.go` → `ListNvidiaGPUs()` → live nvidia-smi
-- Render: `'GPU ' + gpu.index + ' — ' + gpu.name + ' · ' + mem`
+- Render: `'GPU N — <model> · <mem> MiB · sn: <serial>'`
+  (serial from `nvidia-smi --query-gpu=...,serial`; omitted when N/A)
+- **Single source:** `audit/internal/webui/gpu_picker.go` — `beeGpuPicker.render({...})` builds every
+  row. All three pages (Load/SAT, Burn, Benchmark) call it from their `*RenderGPUList` wrapper;
+  `gpuPickerCSS`/`gpuPickerJS` are injected once by `layoutHead`/`renderPage`.
+- Serial is rendered monospace; the digits that differ across the listed GPUs (common
+  prefix/suffix stripped) are bolded in accent colour.
 - Fallback: `gpu.name || 'GPU ' + idx` (JS, line ~1432)
 
 This always shows the correct model because it queries nvidia-smi live. It is **not** connected to benchmark result data.

From bb2a501a28853192443e16c4dd7e70c9e2784ae1 Mon Sep 17 00:00:00 2001
From: Mikhail Chusavitin <mchusavitin@mchusmbp.local>
Date: Fri, 4 Sep 2026 10:35:34 +0300
Subject: [PATCH 2/9] feat(sat): fan ceiling check + topology fan tiles

Repurpose the previously-unwired RunFanStressTest into RunFanCheck, a
Load-tier SAT test that drives stressapptest (CPU+memory) and, when a GPU
is present, a GPU burn to 100% simultaneously, then watches every fan
until none has climbed for ~60s. The observed peak RPM per fan is the
"ceiling"; it is persisted through the existing fan-observation store.

MSI G4201 / AMI MegaRAC exposes no host-side fan force (every OEM IPMI
command returns 0xc1; Redfish Thermal is GET-only), so load-driven ramp
is the closest safe equivalent. See
bible-local/decisions/2026-09-04-fan-ceiling-check.md.

- platform.ResolveFanMaxRPM: per-fan max with fallback (persisted peak ->
  peer peak -> current RPM), resolved in platform, not the view.
- platform.ErrTestNotApplicable: no load source or no fan sensors ->
  task lands as cancelled ("not applicable"), never failed, so an
  engineer never sees a false red. executeTaskWithOptions maps the
  sentinel; finalizeTaskForResult honours a pre-set TaskCancelled.
- Verdict FAIL only for a fan at 0 RPM / IPMI cr-nr under load.
- /topo: one small spinning square per fan, sized by RPM / resolved max,
  clickable through to a new "fan" component-detail type; per-fan status
  recorded to the component-status DB from the fan SAT summary.
- Wiring: /api/sat/fan/run route, "fan" task target, Load-page card,
  stress-mode Run All.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019VHG21rgTUiR1G3qFHTVmN
---
 audit/internal/app/app.go                     |   2 +-
 audit/internal/app/app_packs.go               |   7 +
 audit/internal/app/app_test.go                |   2 +-
 audit/internal/app/component_status_db.go     |  17 +
 audit/internal/platform/sat_errors.go         |  10 +
 audit/internal/platform/sat_fan_stress.go     | 560 +++++++++++-------
 .../internal/platform/sat_fan_stress_test.go  |  57 ++
 audit/internal/webui/api.go                   |   2 +-
 audit/internal/webui/api_metrics_network.go   |   5 +-
 audit/internal/webui/api_sat_runall.go        |   5 +
 audit/internal/webui/api_sat_runall_test.go   |   2 +-
 audit/internal/webui/kmsg_watcher.go          |   2 +-
 audit/internal/webui/page_topo_diagram.go     | 141 ++++-
 audit/internal/webui/page_topo_test.go        |  65 ++
 audit/internal/webui/page_validate.go         |   6 +
 audit/internal/webui/server.go                |   1 +
 audit/internal/webui/task_runner.go           |  26 +-
 audit/internal/webui/tasks.go                 |   6 +-
 audit/internal/webui/tasks_test.go            |  29 +
 bible-local/README.md                         |   6 +
 bible-local/architecture/api-surface.md       |   1 +
 .../decisions/2026-09-04-fan-ceiling-check.md |  68 +++
 22 files changed, 798 insertions(+), 222 deletions(-)
 create mode 100644 audit/internal/platform/sat_errors.go
 create mode 100644 bible-local/decisions/2026-09-04-fan-ceiling-check.md

diff --git a/audit/internal/app/app.go b/audit/internal/app/app.go
index 2d4d7ab..90ac626 100644
--- a/audit/internal/app/app.go
+++ b/audit/internal/app/app.go
@@ -173,7 +173,7 @@ type satRunner interface {
 	RunAMDStressPack(ctx context.Context, baseDir string, durationSec int, logFunc func(string)) (string, error)
 	RunMemoryStressPack(ctx context.Context, baseDir string, durationSec int, logFunc func(string)) (string, error)
 	RunSATStressPack(ctx context.Context, baseDir string, durationSec int, logFunc func(string)) (string, error)
-	RunFanStressTest(ctx context.Context, baseDir string, opts platform.FanStressOptions) (string, error)
+	RunFanCheck(ctx context.Context, baseDir string, opts platform.FanCheckOptions, logFunc func(string)) (string, error)
 	RunPlatformStress(ctx context.Context, baseDir string, opts platform.PlatformStressOptions, logFunc func(string)) (string, error)
 	RunNCCLTests(ctx context.Context, baseDir string, gpuIndices []int, logFunc func(string)) (string, error)
 	RunScenario(ctx context.Context, baseDir string, spec platform.ScenarioSpec, logFunc func(string)) (string, error)
diff --git a/audit/internal/app/app_packs.go b/audit/internal/app/app_packs.go
index 4f88355..b57ab26 100644
--- a/audit/internal/app/app_packs.go
+++ b/audit/internal/app/app_packs.go
@@ -298,6 +298,13 @@ func (a *App) RunPlatformStress(ctx context.Context, baseDir string, opts platfo
 	return a.sat.RunPlatformStress(ctx, baseDir, opts, logFunc)
 }
 
+func (a *App) RunFanCheckCtx(ctx context.Context, baseDir string, opts platform.FanCheckOptions, logFunc func(string)) (string, error) {
+	if strings.TrimSpace(baseDir) == "" {
+		baseDir = DefaultSATBaseDir
+	}
+	return a.sat.RunFanCheck(ctx, baseDir, opts, logFunc)
+}
+
 func (a *App) RunNCCLTests(ctx context.Context, baseDir string, gpuIndices []int, logFunc func(string)) (string, error) {
 	if strings.TrimSpace(baseDir) == "" {
 		baseDir = DefaultSATBaseDir
diff --git a/audit/internal/app/app_test.go b/audit/internal/app/app_test.go
index a1df766..b7b6cd0 100644
--- a/audit/internal/app/app_test.go
+++ b/audit/internal/app/app_test.go
@@ -367,7 +367,7 @@ func (f fakeSAT) RunSATStressPack(_ context.Context, _ string, _ int, _ func(str
 	return "", nil
 }
 
-func (f fakeSAT) RunFanStressTest(_ context.Context, _ string, _ platform.FanStressOptions) (string, error) {
+func (f fakeSAT) RunFanCheck(_ context.Context, _ string, _ platform.FanCheckOptions, _ func(string)) (string, error) {
 	return "", nil
 }
 
diff --git a/audit/internal/app/component_status_db.go b/audit/internal/app/component_status_db.go
index 45654de..ae2c994 100644
--- a/audit/internal/app/component_status_db.go
+++ b/audit/internal/app/component_status_db.go
@@ -318,6 +318,23 @@ func ApplySATResultToDB(db *ComponentStatusDB, target, archivePath string) {
 		db.Record("memory:all", source, dbStatus, detail)
 	case "cpu", "platform-stress":
 		db.Record("cpu:all", source, dbStatus, detail)
+	case "fan":
+		// Per-fan keys: summary emits "fan_<name>_status=OK|FAILED (...)".
+		for key, val := range kv {
+			name, ok := strings.CutPrefix(key, "fan_")
+			if !ok {
+				continue
+			}
+			name, ok = strings.CutSuffix(name, "_status")
+			if !ok || name == "" {
+				continue
+			}
+			upper := strings.ToUpper(strings.TrimSpace(val))
+			if i := strings.IndexByte(upper, ' '); i > 0 {
+				upper = upper[:i] // drop the "(reason)" suffix
+			}
+			db.Record("fan:"+name, source, satStatusToDBStatus(upper), target+" SAT: "+strings.TrimSpace(val))
+		}
 	case "storage":
 		// Try to record per-device if available in summary.
 		recordedAny := false
diff --git a/audit/internal/platform/sat_errors.go b/audit/internal/platform/sat_errors.go
new file mode 100644
index 0000000..bf7f465
--- /dev/null
+++ b/audit/internal/platform/sat_errors.go
@@ -0,0 +1,10 @@
+package platform
+
+import "errors"
+
+// ErrTestNotApplicable is returned by a SAT routine when the host provides no
+// way to run that test at all (a required tool or capability is absent), as
+// opposed to the test running and finding a fault. The task layer maps it to a
+// cancelled ("not applicable") task rather than a failure, so an engineer does
+// not see a false red.
+var ErrTestNotApplicable = errors.New("test not applicable on this platform")
diff --git a/audit/internal/platform/sat_fan_stress.go b/audit/internal/platform/sat_fan_stress.go
index 5d22f8f..4648b25 100644
--- a/audit/internal/platform/sat_fan_stress.go
+++ b/audit/internal/platform/sat_fan_stress.go
@@ -15,14 +15,18 @@ import (
 	"time"
 )
 
-// FanStressOptions configures the fan-stress / thermal cycling test.
-type FanStressOptions struct {
-	BaselineSec  int   // idle monitoring before and after load (default 30)
-	Phase1DurSec int   // first load phase duration in seconds (default 300)
-	PauseSec     int   // pause between the two load phases (default 60)
-	Phase2DurSec int   // second load phase duration in seconds (default 300)
-	SizeMB       int   // GPU memory to allocate per GPU during stress (0 = auto: 95% of VRAM)
-	GPUIndices   []int // which GPU indices to stress (empty = all detected)
+// FanCheckOptions configures the fan-ceiling check: it drives CPU (+memory)
+// and, when present, GPU load to 100% simultaneously, then watches every fan
+// until none has climbed for PlateauHoldSec — at which point each fan is
+// considered to be at its physical ceiling and the observed peak is recorded.
+type FanCheckOptions struct {
+	PlateauHoldSec  int   // a fan must not rise > PlateauDeltaRPM for this long to count as plateaued (default 60)
+	PlateauDeltaRPM int   // RPM increase that still counts as "climbing" (default 50)
+	MinLoadSec      int   // never declare a plateau before this many seconds of load (default 90)
+	MaxLoadSec      int   // hard cap on the load phase; finish (success) even if not every fan plateaued (default 900)
+	RampConfirmRPM  int   // at least one fan must exceed baseline by this before a plateau is "real" (default 150)
+	SizeMB          int   // GPU memory to allocate per GPU (0 = auto)
+	GPUIndices      []int // which GPU indices to load (empty = all detected)
 }
 
 // FanReading holds one fan sensor reading.
@@ -93,128 +97,217 @@ func normalizeObservedFanMaxRPM(rpm float64) float64 {
 	return math.Ceil(rpm/1000.0) * 1000.0
 }
 
-// RunFanStressTest runs a two-phase GPU stress test while monitoring fan speeds,
-// temperatures, and power draw every second. Exports metrics.csv and fan-sensors.csv.
-// Designed to reproduce case-04 fan-speed lag and detect GPU thermal throttling.
-func (s *System) RunFanStressTest(ctx context.Context, baseDir string, opts FanStressOptions) (string, error) {
+// RunFanCheck drives CPU (+memory) and, when a GPU is present, GPU load to
+// 100% simultaneously and watches every fan until none has climbed for
+// PlateauHoldSec. At that point each fan is taken to be at its physical
+// ceiling; the observed peak RPM is persisted (fanObservationStatePath, the
+// same store ObservedFanMaxRPM reads) so the topology view can size each fan
+// tile against a real maximum.
+//
+// Outcome:
+//   - success ("ceiling found") once every fan plateaus, or when MaxLoadSec is
+//     hit — a run that simply ran out of time still recorded the highest RPM
+//     seen and is not a failure.
+//   - a fan reading 0 RPM, or an IPMI status of cr/nr, while under full load is
+//     a real defect → FAILED.
+//   - if there is no way to load this box (no stressapptest/stress-ng and no
+//     GPU burn tool) or no fan sensors are readable, the test cannot say
+//     anything about the hardware and returns ErrTestNotApplicable so the task
+//     is cancelled, not failed.
+//
+// No GPU is not an error: CPU/memory load alone is enough to exercise the
+// cooling loop on most platforms.
+func (s *System) RunFanCheck(ctx context.Context, baseDir string, opts FanCheckOptions, logFunc func(string)) (string, error) {
+	if logFunc == nil {
+		logFunc = func(string) {}
+	}
 	if baseDir == "" {
 		baseDir = "/var/log/bee-sat"
 	}
-	applyFanStressDefaults(&opts)
+	applyFanCheckDefaults(&opts)
+
+	baseFans, fanErr := sampleFanSpeeds()
+	if len(baseFans) == 0 {
+		return "", fmt.Errorf("no fan sensors readable via ipmitool or lm-sensors (%v): %w", fanErr, ErrTestNotApplicable)
+	}
+	baselineRPM := make(map[string]float64, len(baseFans))
+	for _, f := range baseFans {
+		baselineRPM[f.Name] = f.RPM
+	}
+
+	vendor := s.DetectGPUVendor()
+	haveGPU := vendor == "nvidia" || vendor == "amd"
+	_, cpuPathErr := satLookPath("stressapptest")
+	if cpuPathErr != nil {
+		_, cpuPathErr = satLookPath("stress-ng")
+	}
+	haveCPU := cpuPathErr == nil
+	if !haveCPU && !haveGPU {
+		return "", fmt.Errorf("no load source: stressapptest/stress-ng missing and no NVIDIA/AMD GPU stress tool available: %w", ErrTestNotApplicable)
+	}
 
 	ts := time.Now().UTC().Format("20060102-150405")
-	runDir := filepath.Join(baseDir, "fan-stress-"+ts)
+	runDir := filepath.Join(baseDir, "fan-check-"+ts)
 	if err := os.MkdirAll(runDir, 0755); err != nil {
 		return "", err
 	}
 	verboseLog := filepath.Join(runDir, "verbose.log")
+	appendSATVerboseLog(verboseLog, fmt.Sprintf("[%s] fan check start: %d fans, gpu=%s cpu=%v",
+		time.Now().UTC().Format(time.RFC3339), len(baseFans), vendor, haveCPU))
+	logFunc(fmt.Sprintf("Fan check: %d fans; load = CPU/mem:%v + GPU:%s", len(baseFans), haveCPU, orNone(haveGPU, vendor)))
 
-	// Phase name shared between sampler goroutine and main goroutine.
-	var phaseMu sync.Mutex
-	currentPhase := "init"
-	setPhase := func(name string) {
-		phaseMu.Lock()
-		currentPhase = name
-		phaseMu.Unlock()
+	// ── Load: every source runs at the same time, each in its own goroutine.
+	// Sources can take different amounts of time to actually reach full load
+	// (stressapptest is near-instant; a GPU burn kernel needs to compile and
+	// ramp), so the plateau clock does not start until every launched source
+	// has reported its process running, plus a fixed GPU ramp grace.
+	loadCtx, loadCancel := context.WithTimeout(ctx, time.Duration(opts.MaxLoadSec)*time.Second)
+	defer loadCancel()
+
+	var loadWG sync.WaitGroup
+	started := make(chan bool, 2) // true = source is running, false = failed to launch
+	launched := 0
+
+	if haveCPU {
+		launched++
+		loadWG.Add(1)
+		go func() {
+			defer loadWG.Done()
+			cmd, err := buildCPUStressCmd(loadCtx)
+			if err != nil {
+				logFunc("CPU/memory load failed to start: " + err.Error())
+				appendSATVerboseLog(verboseLog, "cpu load start error: "+err.Error())
+				started <- false
+				return
+			}
+			logFunc("CPU/memory load running (stressapptest)")
+			started <- true
+			_ = cmd.Wait()
+		}()
 	}
-	getPhase := func() string {
-		phaseMu.Lock()
-		defer phaseMu.Unlock()
-		return currentPhase
+	if haveGPU {
+		launched++
+		loadWG.Add(1)
+		go func() {
+			defer loadWG.Done()
+			cmd := buildGPUStressCmd(loadCtx, vendor, opts.MaxLoadSec)
+			if cmd == nil {
+				logFunc("GPU load unavailable (no burn tool for " + vendor + ")")
+				appendSATVerboseLog(verboseLog, "gpu load: no burn tool")
+				started <- false
+				return
+			}
+			logFunc("GPU load running (" + vendor + ")")
+			started <- true
+			_ = cmd.Wait()
+		}()
 	}
 
 	start := time.Now()
-	var rowsMu sync.Mutex
-	var allRows []FanStressRow
-
-	// Start background sampler (every second).
-	stopCh := make(chan struct{})
-	doneCh := make(chan struct{})
-	go func() {
-		defer close(doneCh)
-		ticker := time.NewTicker(time.Second)
-		defer ticker.Stop()
-		for {
-			select {
-			case <-stopCh:
-				return
-			case <-ticker.C:
-				row := sampleFanStressRow(opts.GPUIndices, getPhase(), time.Since(start).Seconds())
-				rowsMu.Lock()
-				allRows = append(allRows, row)
-				rowsMu.Unlock()
+	activeLoads := 0
+	for i := 0; i < launched; i++ {
+		select {
+		case ok := <-started:
+			if ok {
+				activeLoads++
 			}
+		case <-ctx.Done():
 		}
-	}()
+	}
+	if activeLoads == 0 {
+		loadCancel()
+		loadWG.Wait()
+		return "", fmt.Errorf("every load source failed to start: %w", ErrTestNotApplicable)
+	}
+	readyAt := time.Now()
+	if haveGPU {
+		readyAt = readyAt.Add(20 * time.Second) // GPU kernel ramp grace
+	}
+	appendSATVerboseLog(verboseLog, fmt.Sprintf("%d load source(s) active; plateau clock effective from +%.0fs",
+		activeLoads, readyAt.Sub(start).Seconds()))
 
-	var summary strings.Builder
-	fmt.Fprintf(&summary, "run_at_utc=%s\n", time.Now().UTC().Format(time.RFC3339))
+	// ── Sample loop: one row/second, per-fan plateau tracking.
+	type fanState struct {
+		peak        float64
+		lastRiseSec float64
+	}
+	fanBy := map[string]*fanState{}
+	var rows []FanStressRow
+	rampConfirmed := false
+	plateauReached := false
+	aborted := false
 
-	stats := satStats{}
-
-	// idlePhase sleeps for durSec while the sampler stamps phaseName on each row.
-	idlePhase := func(phaseName, stepName string, durSec int) {
-		if ctx.Err() != nil {
-			return
-		}
-		setPhase(phaseName)
-		appendSATVerboseLog(verboseLog,
-			fmt.Sprintf("[%s] start %s (idle %ds)", time.Now().UTC().Format(time.RFC3339), stepName, durSec),
-		)
+	ticker := time.NewTicker(time.Second)
+	defer ticker.Stop()
+loop:
+	for {
 		select {
 		case <-ctx.Done():
-		case <-time.After(time.Duration(durSec) * time.Second):
+			aborted = true
+			break loop
+		case <-loadCtx.Done():
+			break loop // MaxLoadSec reached
+		case <-ticker.C:
 		}
-		appendSATVerboseLog(verboseLog,
-			fmt.Sprintf("[%s] finish %s", time.Now().UTC().Format(time.RFC3339), stepName),
-		)
-		fmt.Fprintf(&summary, "%s_status=OK\n", stepName)
-		stats.OK++
-	}
+		elapsed := time.Since(start).Seconds()
+		row := sampleFanStressRow(opts.GPUIndices, "load", elapsed)
+		rows = append(rows, row)
 
-	// loadPhase runs bee-gpu-burn for durSec; sampler stamps phaseName on each row.
-	loadPhase := func(phaseName, stepName string, durSec int) {
-		if ctx.Err() != nil {
-			return
+		for _, f := range row.Fans {
+			st := fanBy[f.Name]
+			if st == nil {
+				fanBy[f.Name] = &fanState{peak: f.RPM, lastRiseSec: elapsed}
+				continue
+			}
+			if f.RPM > st.peak {
+				if f.RPM-st.peak > float64(opts.PlateauDeltaRPM) {
+					st.lastRiseSec = elapsed
+				}
+				st.peak = f.RPM
+			}
+			if f.RPM >= baselineRPM[f.Name]+float64(opts.RampConfirmRPM) {
+				rampConfirmed = true
+			}
 		}
-		setPhase(phaseName)
-		cmd := []string{
-			"bee-gpu-burn",
-			"--seconds", strconv.Itoa(durSec),
-			"--size-mb", strconv.Itoa(opts.SizeMB),
-		}
-		if len(opts.GPUIndices) > 0 {
-			cmd = append(cmd, "--devices", joinIndexList(dedupeSortedIndices(opts.GPUIndices)))
-		}
-		out, err := runSATCommandCtx(ctx, verboseLog, stepName, cmd, nil, nil)
-		_ = os.WriteFile(filepath.Join(runDir, stepName+".log"), out, 0644)
-		if err != nil && err != context.Canceled && err.Error() != "signal: killed" {
-			fmt.Fprintf(&summary, "%s_status=FAILED\n", stepName)
-			stats.Failed++
-		} else {
-			fmt.Fprintf(&summary, "%s_status=OK\n", stepName)
-			stats.OK++
+
+		if elapsed >= float64(opts.MinLoadSec) && time.Since(readyAt) >= time.Duration(opts.PlateauHoldSec)*time.Second && len(fanBy) > 0 {
+			allFlat := true
+			for _, st := range fanBy {
+				if elapsed-st.lastRiseSec < float64(opts.PlateauHoldSec) {
+					allFlat = false
+					break
+				}
+			}
+			if allFlat && rampConfirmed {
+				plateauReached = true
+				logFunc(fmt.Sprintf("All %d fans plateaued at %.0fs of load", len(fanBy), elapsed))
+				break loop
+			}
 		}
 	}
 
-	// Execute test phases.
-	idlePhase("baseline", "01-baseline", opts.BaselineSec)
-	loadPhase("load1", "02-load1", opts.Phase1DurSec)
-	idlePhase("pause", "03-pause", opts.PauseSec)
-	loadPhase("load2", "04-load2", opts.Phase2DurSec)
-	idlePhase("cooldown", "05-cooldown", opts.BaselineSec)
+	loadCancel()
+	loadWG.Wait()
 
-	// Stop sampler and collect rows.
-	close(stopCh)
-	<-doneCh
+	if aborted && ctx.Err() != nil {
+		_ = os.WriteFile(filepath.Join(runDir, "summary.txt"),
+			[]byte("run_at_utc="+time.Now().UTC().Format(time.RFC3339)+"\noverall_status=UNKNOWN\naborted=true\n"), 0644)
+		return runDir, ctx.Err()
+	}
 
-	rowsMu.Lock()
-	rows := allRows
-	rowsMu.Unlock()
-
-	// Analysis.
-	throttled := analyzeThrottling(rows)
-	maxGPUTemp := analyzeMaxTemp(rows, func(r FanStressRow) float64 {
+	// ── Verdict.
+	statuses := readFanStatuses()
+	var summary strings.Builder
+	fmt.Fprintf(&summary, "run_at_utc=%s\n", time.Now().UTC().Format(time.RFC3339))
+	fmt.Fprintf(&summary, "fans_total=%d\n", len(baseFans))
+	fmt.Fprintf(&summary, "active_load_sources=%d\n", activeLoads)
+	fmt.Fprintf(&summary, "gpu_vendor=%s\n", orNone(haveGPU, vendor))
+	fmt.Fprintf(&summary, "plateau_reached=%v\n", plateauReached)
+	fmt.Fprintf(&summary, "ramp_confirmed=%v\n", rampConfirmed)
+	if len(rows) > 0 {
+		fmt.Fprintf(&summary, "load_duration_sec=%.0f\n", rows[len(rows)-1].ElapsedSec)
+	}
+	fmt.Fprintf(&summary, "max_gpu_temp_c=%.1f\n", analyzeMaxTemp(rows, func(r FanStressRow) float64 {
 		var m float64
 		for _, g := range r.GPUs {
 			if g.TempC > m {
@@ -222,55 +315,148 @@ func (s *System) RunFanStressTest(ctx context.Context, baseDir string, opts FanS
 			}
 		}
 		return m
-	})
-	maxCPUTemp := analyzeMaxTemp(rows, func(r FanStressRow) float64 {
-		return r.CPUMaxTempC
-	})
-	fanResponseSec := analyzeFanResponse(rows)
+	}))
+	fmt.Fprintf(&summary, "max_cpu_temp_c=%.1f\n", analyzeMaxTemp(rows, func(r FanStressRow) float64 { return r.CPUMaxTempC }))
 
-	fmt.Fprintf(&summary, "throttling_detected=%v\n", throttled)
-	fmt.Fprintf(&summary, "max_gpu_temp_c=%.1f\n", maxGPUTemp)
-	fmt.Fprintf(&summary, "max_cpu_temp_c=%.1f\n", maxCPUTemp)
-	if fanResponseSec >= 0 {
-		fmt.Fprintf(&summary, "fan_response_sec=%.1f\n", fanResponseSec)
-	} else {
-		fmt.Fprintf(&summary, "fan_response_sec=N/A\n")
+	stats := satStats{}
+	names := make([]string, 0, len(baselineRPM))
+	for n := range baselineRPM {
+		names = append(names, n)
 	}
-
-	// Throttling failure counts against overall result.
-	if throttled {
-		stats.Failed++
+	sort.Strings(names)
+	for _, name := range names {
+		peak := baselineRPM[name]
+		if st := fanBy[name]; st != nil {
+			peak = st.peak
+		}
+		st := strings.ToLower(strings.TrimSpace(statuses[name]))
+		bad := peak <= 0 || st == "cr" || st == "nr"
+		key := sanitizeSummaryKey(name)
+		fmt.Fprintf(&summary, "fan_%s_baseline_rpm=%.0f\n", key, baselineRPM[name])
+		fmt.Fprintf(&summary, "fan_%s_max_rpm=%.0f\n", key, peak)
+		if bad {
+			reason := "0 RPM under load"
+			if st == "cr" || st == "nr" {
+				reason = "IPMI status " + st
+			}
+			fmt.Fprintf(&summary, "fan_%s_status=FAILED (%s)\n", key, reason)
+			logFunc(fmt.Sprintf("FAIL %s: %s", name, reason))
+			stats.Failed++
+		} else {
+			fmt.Fprintf(&summary, "fan_%s_status=OK\n", key)
+			stats.OK++
+		}
 	}
 	writeSATStats(&summary, stats)
 
-	// Write CSV outputs.
-	if err := WriteFanStressCSV(filepath.Join(runDir, "metrics.csv"), rows, opts.GPUIndices); err != nil {
-		return "", err
-	}
+	_ = WriteFanStressCSV(filepath.Join(runDir, "metrics.csv"), rows, opts.GPUIndices)
 	_ = WriteFanSensorsCSV(filepath.Join(runDir, "fan-sensors.csv"), rows)
-
 	if err := os.WriteFile(filepath.Join(runDir, "summary.txt"), []byte(summary.String()), 0644); err != nil {
 		return "", err
 	}
-
 	return runDir, nil
 }
 
-func applyFanStressDefaults(opts *FanStressOptions) {
-	if opts.BaselineSec <= 0 {
-		opts.BaselineSec = 30
+func applyFanCheckDefaults(o *FanCheckOptions) {
+	if o.PlateauHoldSec <= 0 {
+		o.PlateauHoldSec = 60
 	}
-	if opts.Phase1DurSec <= 0 {
-		opts.Phase1DurSec = 300
+	if o.PlateauDeltaRPM <= 0 {
+		o.PlateauDeltaRPM = 50
 	}
-	if opts.PauseSec <= 0 {
-		opts.PauseSec = 60
+	if o.MinLoadSec <= 0 {
+		o.MinLoadSec = 90
 	}
-	if opts.Phase2DurSec <= 0 {
-		opts.Phase2DurSec = 300
+	if o.MaxLoadSec <= 0 {
+		o.MaxLoadSec = 900
 	}
-	// SizeMB == 0 means "auto" (worker picks 95% of GPU VRAM for maximum power draw).
-	// Leave at 0 to avoid passing a too-small size that starves the tensor-core path.
+	if o.RampConfirmRPM <= 0 {
+		o.RampConfirmRPM = 150
+	}
+	if o.MinLoadSec < o.PlateauHoldSec {
+		o.MinLoadSec = o.PlateauHoldSec
+	}
+	if o.MaxLoadSec <= o.MinLoadSec {
+		o.MaxLoadSec = o.MinLoadSec + o.PlateauHoldSec
+	}
+}
+
+func orNone(present bool, v string) string {
+	if present && v != "" {
+		return v
+	}
+	return "none"
+}
+
+// sanitizeSummaryKey makes a fan sensor name safe as a summary.txt key
+// fragment (keys are parsed by splitting on '=' and whitespace).
+func sanitizeSummaryKey(name string) string {
+	var b strings.Builder
+	for _, r := range name {
+		switch {
+		case r >= 'A' && r <= 'Z', r >= 'a' && r <= 'z', r >= '0' && r <= '9', r == '-', r == '_', r == '.':
+			b.WriteRune(r)
+		default:
+			b.WriteByte('_')
+		}
+	}
+	return b.String()
+}
+
+// readFanStatuses returns the per-fan IPMI status word ("ok", "cr", "nr", ...)
+// from "ipmitool sdr type Fan". Empty map when ipmitool is unavailable.
+func readFanStatuses() map[string]string {
+	out, err := exec.Command("ipmitool", "sdr", "type", "Fan").Output()
+	if err != nil {
+		return nil
+	}
+	m := map[string]string{}
+	for _, line := range strings.Split(string(out), "\n") {
+		parts := strings.Split(line, "|")
+		if len(parts) < 3 {
+			continue
+		}
+		name := strings.TrimSpace(parts[0])
+		if name == "" {
+			continue
+		}
+		m[name] = strings.ToLower(strings.TrimSpace(parts[2]))
+	}
+	return m
+}
+
+// ResolveFanMaxRPM returns, for every fan name in current (name -> current
+// RPM), the RPM to treat as that fan's 100% reference. Preference order:
+//  1. the persisted observed peak (fanObservationStatePath), written by
+//     RunFanCheck and by live-metrics sampling under load;
+//  2. the largest peak observed on any peer fan (keeps a group visually
+//     consistent when only some fans have a recorded peak);
+//  3. the fan's own current RPM (so a tile is never sized against zero).
+//
+// The fallback lives here, not in the view, so every consumer of a fan
+// maximum applies the same rule.
+func ResolveFanMaxRPM(current map[string]float64) map[string]float64 {
+	persisted := readPersistedFanMaxRPM()
+
+	peerMax := 0.0
+	for _, v := range persisted {
+		if v > peerMax {
+			peerMax = v
+		}
+	}
+
+	out := make(map[string]float64, len(current))
+	for name, rpm := range current {
+		switch {
+		case persisted[name] > 0:
+			out[name] = persisted[name]
+		case peerMax > 0:
+			out[name] = peerMax
+		default:
+			out[name] = rpm
+		}
+	}
+	return out
 }
 
 // sampleFanStressRow collects all metrics for one telemetry sample.
@@ -355,27 +541,48 @@ func sampleFanSpeeds() ([]FanReading, error) {
 	return nil, sensorsErr
 }
 
-func loadFanObservationLocked() {
-	if fanObservationInit {
-		return
-	}
-	fanObservationInit = true
-	fanObservation.MaxRPM = make(map[string]float64)
+// readPersistedFanMaxRPM reads fanObservationStatePath and returns its
+// sanitized {fan name -> observed peak RPM} map (empty names / non-positive
+// values dropped). Returns an empty map when the file is missing or unparsable.
+func readPersistedFanMaxRPM() map[string]float64 {
+	out := map[string]float64{}
 	raw, err := os.ReadFile(fanObservationStatePath)
 	if err != nil || len(raw) == 0 {
-		return
+		return out
 	}
 	var persisted fanObservationState
 	if json.Unmarshal(raw, &persisted) != nil {
-		return
+		return out
 	}
 	for name, rpm := range persisted.MaxRPM {
 		name = strings.TrimSpace(name)
 		if name == "" || rpm <= 0 {
 			continue
 		}
-		fanObservation.MaxRPM[name] = rpm
+		out[name] = rpm
 	}
+	return out
+}
+
+// ObservedFanMaxRPM returns the per-fan observed peak RPM map persisted by
+// fan-stress SAT runs, or nil if none is recorded yet. It reads the file
+// directly without touching the in-process observation cache or its lock, so
+// read-only consumers (the /topo web view) can call it without perturbing a
+// concurrent SAT run's peak tracking.
+func ObservedFanMaxRPM() map[string]float64 {
+	out := readPersistedFanMaxRPM()
+	if len(out) == 0 {
+		return nil
+	}
+	return out
+}
+
+func loadFanObservationLocked() {
+	if fanObservationInit {
+		return
+	}
+	fanObservationInit = true
+	fanObservation.MaxRPM = readPersistedFanMaxRPM()
 }
 
 func saveFanObservationLocked() {
@@ -779,22 +986,6 @@ func effectiveSystemPowerReading(cache cachedPowerReading, current float64, sour
 	return 0, cache
 }
 
-// analyzeThrottling returns true if any GPU reported an active throttle reason
-// during either load phase.
-func analyzeThrottling(rows []FanStressRow) bool {
-	for _, row := range rows {
-		if row.Phase != "load1" && row.Phase != "load2" {
-			continue
-		}
-		for _, gpu := range row.GPUs {
-			if gpu.Throttled {
-				return true
-			}
-		}
-	}
-	return false
-}
-
 // analyzeMaxTemp returns the maximum value of the given extractor across all rows.
 func analyzeMaxTemp(rows []FanStressRow, extract func(FanStressRow) float64) float64 {
 	var max float64
@@ -806,55 +997,6 @@ func analyzeMaxTemp(rows []FanStressRow, extract func(FanStressRow) float64) flo
 	return max
 }
 
-// analyzeFanResponse returns the seconds from load1 start until fan RPM first
-// increased by more than 5% above the baseline average. Returns -1 if undetermined.
-func analyzeFanResponse(rows []FanStressRow) float64 {
-	// Compute baseline average fan RPM.
-	var baseTotal, baseCount float64
-	for _, row := range rows {
-		if row.Phase != "baseline" {
-			continue
-		}
-		for _, f := range row.Fans {
-			baseTotal += f.RPM
-			baseCount++
-		}
-	}
-	if baseCount == 0 || baseTotal == 0 {
-		return -1
-	}
-	baseAvg := baseTotal / baseCount
-	threshold := baseAvg * 1.05 // 5% increase signals fan ramp-up
-
-	// Find elapsed time when load1 started.
-	var load1Start float64 = -1
-	for _, row := range rows {
-		if row.Phase == "load1" {
-			load1Start = row.ElapsedSec
-			break
-		}
-	}
-	if load1Start < 0 {
-		return -1
-	}
-
-	// Find first load1 row where average RPM crosses the threshold.
-	for _, row := range rows {
-		if row.Phase != "load1" {
-			continue
-		}
-		var total, count float64
-		for _, f := range row.Fans {
-			total += f.RPM
-			count++
-		}
-		if count > 0 && total/count >= threshold {
-			return row.ElapsedSec - load1Start
-		}
-	}
-	return -1
-}
-
 // WriteFanStressCSV writes the wide-format metrics CSV with one row per second.
 // GPU columns are generated per index in gpuIndices order.
 func WriteFanStressCSV(path string, rows []FanStressRow, gpuIndices []int) error {
diff --git a/audit/internal/platform/sat_fan_stress_test.go b/audit/internal/platform/sat_fan_stress_test.go
index 20ac394..3d79787 100644
--- a/audit/internal/platform/sat_fan_stress_test.go
+++ b/audit/internal/platform/sat_fan_stress_test.go
@@ -1,11 +1,68 @@
 package platform
 
 import (
+	"os"
 	"path/filepath"
+	"reflect"
 	"testing"
 	"time"
 )
 
+func TestResolveFanMaxRPM(t *testing.T) {
+	oldPath := fanObservationStatePath
+	oldInit := fanObservationInit
+	fanObservationStatePath = filepath.Join(t.TempDir(), "fan-observation.json")
+	fanObservationInit = false
+	t.Cleanup(func() {
+		fanObservationStatePath = oldPath
+		fanObservationInit = oldInit
+	})
+
+	// No persisted file yet: unknown fans fall back to their own current RPM.
+	got := ResolveFanMaxRPM(map[string]float64{"A": 4000, "B": 9000})
+	if !reflect.DeepEqual(got, map[string]float64{"A": 4000, "B": 9000}) {
+		t.Fatalf("no-persist fallback: got %v", got)
+	}
+
+	if err := os.WriteFile(fanObservationStatePath, []byte(`{"max_rpm":{"A":17000}}`), 0644); err != nil {
+		t.Fatal(err)
+	}
+	got = ResolveFanMaxRPM(map[string]float64{"A": 4000, "B": 9000, "C": 5000})
+	// A: persisted peak. B/C: no own entry -> largest peer peak (A's 17000).
+	if want := map[string]float64{"A": 17000, "B": 17000, "C": 17000}; !reflect.DeepEqual(got, want) {
+		t.Fatalf("peer fallback: got %v want %v", got, want)
+	}
+}
+
+func TestApplyFanCheckDefaults(t *testing.T) {
+	var o FanCheckOptions
+	applyFanCheckDefaults(&o)
+	if o.PlateauHoldSec != 60 || o.PlateauDeltaRPM != 50 || o.MinLoadSec != 90 || o.MaxLoadSec != 900 || o.RampConfirmRPM != 150 {
+		t.Fatalf("unexpected defaults: %+v", o)
+	}
+	o = FanCheckOptions{PlateauHoldSec: 120, MinLoadSec: 30, MaxLoadSec: 40}
+	applyFanCheckDefaults(&o)
+	if o.MinLoadSec < o.PlateauHoldSec {
+		t.Fatalf("MinLoadSec must be >= PlateauHoldSec, got %d", o.MinLoadSec)
+	}
+	if o.MaxLoadSec <= o.MinLoadSec {
+		t.Fatalf("MaxLoadSec must exceed MinLoadSec, got %d", o.MaxLoadSec)
+	}
+}
+
+func TestSanitizeSummaryKey(t *testing.T) {
+	for in, want := range map[string]string{
+		"F2U-1":          "F2U-1",
+		"aspeed / fan1":  "aspeed___fan1",
+		"CPU0_DIMM":      "CPU0_DIMM",
+		"weird=key here": "weird_key_here",
+	} {
+		if got := sanitizeSummaryKey(in); got != want {
+			t.Errorf("sanitizeSummaryKey(%q)=%q want %q", in, got, want)
+		}
+	}
+}
+
 func TestParseFanSpeeds(t *testing.T) {
 	raw := "FAN1 | 2400.000 | RPM | ok\nFAN2 | 1800 RPM | ok | ok\nFAN3 | na | RPM | ns\n"
 	got := parseFanSpeeds(raw)
diff --git a/audit/internal/webui/api.go b/audit/internal/webui/api.go
index f88fed4..89a98df 100644
--- a/audit/internal/webui/api.go
+++ b/audit/internal/webui/api.go
@@ -128,7 +128,7 @@ func defaultTaskPriority(target string, params taskParams) int {
 		return taskPriorityAudit
 	case "nvidia-bench-perf", "nvidia-bench-power", "nvidia-bench-autotune":
 		return taskPriorityBenchmark
-	case "nvidia-stress", "amd-stress", "memory-stress", "sat-stress", "platform-stress", "nvidia-compute", "scenario":
+	case "nvidia-stress", "amd-stress", "memory-stress", "sat-stress", "platform-stress", "fan", "nvidia-compute", "scenario":
 		return taskPriorityBurn
 	case "nvidia", "nvidia-targeted-stress", "nvidia-targeted-power", "nvidia-pulse",
 		"nvidia-interconnect", "nvidia-bandwidth", "memory", "storage", "cpu",
diff --git a/audit/internal/webui/api_metrics_network.go b/audit/internal/webui/api_metrics_network.go
index 3ae78cc..a4cb43b 100644
--- a/audit/internal/webui/api_metrics_network.go
+++ b/audit/internal/webui/api_metrics_network.go
@@ -289,7 +289,7 @@ func (h *handler) handleAPIHardwareSummary(w http.ResponseWriter, _ *http.Reques
 }
 
 // handleAPIComponentDetail returns an HTML fragment describing the current and
-// historical status for one component type (cpu, memory, storage, gpu, psu).
+// historical status for one component type (cpu, memory, storage, gpu, psu, fan).
 func (h *handler) handleAPIComponentDetail(w http.ResponseWriter, r *http.Request) {
 	compType := r.PathValue("type")
 	var exact, prefixes []string
@@ -315,6 +315,9 @@ func (h *handler) handleAPIComponentDetail(w http.ResponseWriter, r *http.Reques
 	case "psu":
 		title = "PSU"
 		prefixes = []string{"psu:"}
+	case "fan":
+		title = "Fans"
+		prefixes = []string{"fan:"}
 	case "raid":
 		title = "RAID"
 		prefixes = []string{"pcie:raid:"}
diff --git a/audit/internal/webui/api_sat_runall.go b/audit/internal/webui/api_sat_runall.go
index 21ce3c9..4fc03af 100644
--- a/audit/internal/webui/api_sat_runall.go
+++ b/audit/internal/webui/api_sat_runall.go
@@ -109,6 +109,11 @@ func (h *handler) planSATRunAll(ctx context.Context, req satRunAllRequest) ([]sa
 		} else {
 			skip("TPM: no TPM device on this host; check skipped")
 		}
+	} else {
+		// Fan ceiling check runs on the Load tier only. It self-cancels as
+		// "not applicable" on a host with no fan sensors or no way to load
+		// the CPU/GPU, so it is safe to queue unconditionally here.
+		specs = append(specs, satRunAllSpec{target: "fan", params: taskParams{StressMode: true}})
 	}
 
 	gp := h.opts.App.DetectGPUPresence()
diff --git a/audit/internal/webui/api_sat_runall_test.go b/audit/internal/webui/api_sat_runall_test.go
index 8fcdd2b..b0b0400 100644
--- a/audit/internal/webui/api_sat_runall_test.go
+++ b/audit/internal/webui/api_sat_runall_test.go
@@ -98,7 +98,7 @@ func TestPlanSATRunAllLoadOmitsReadOnlyTPMCheck(t *testing.T) {
 	for _, s := range specs {
 		targets = append(targets, s.target)
 	}
-	if want := []string{"cpu", "memory", "storage"}; !reflect.DeepEqual(targets, want) {
+	if want := []string{"cpu", "memory", "storage", "fan"}; !reflect.DeepEqual(targets, want) {
 		t.Fatalf("targets=%v want %v", targets, want)
 	}
 	for _, note := range notes {
diff --git a/audit/internal/webui/kmsg_watcher.go b/audit/internal/webui/kmsg_watcher.go
index 214b1f2..47165d5 100644
--- a/audit/internal/webui/kmsg_watcher.go
+++ b/audit/internal/webui/kmsg_watcher.go
@@ -296,7 +296,7 @@ func isSATTarget(target string) bool {
 	case "nvidia", "nvidia-targeted-stress", "nvidia-bench-perf", "nvidia-bench-power", "nvidia-compute", "nvidia-targeted-power", "nvidia-pulse",
 		"nvidia-interconnect", "nvidia-bandwidth", "nvidia-stress", "memory", "memory-stress", "storage",
 		"cpu", "sat-stress", "amd", "amd-mem", "amd-bandwidth", "amd-stress",
-		"platform-stress":
+		"platform-stress", "fan":
 		return true
 	}
 	return false
diff --git a/audit/internal/webui/page_topo_diagram.go b/audit/internal/webui/page_topo_diagram.go
index 62e224d..9a0af7c 100644
--- a/audit/internal/webui/page_topo_diagram.go
+++ b/audit/internal/webui/page_topo_diagram.go
@@ -614,9 +614,138 @@ func renderTopoMainDiagram(hw schema.HardwareSnapshot, exportDir string) string
 		}}))
 	}
 
+	// Cooling fans — one small square per fan (no PCIe/CPU affinity, arbitrary
+	// count, so a wrapping flex row like PSUs rather than SVG boxes). Each
+	// square is sized by rpm / observed-max-rpm and carries a fan glyph that
+	// spins via CSS — faster when the fan is spinning faster.
+	if fans := dedupeFansByName(hw.Sensors); len(fans) > 0 {
+		current := map[string]float64{}
+		for _, f := range fans {
+			if f.RPM != nil {
+				current[strings.TrimSpace(f.Name)] = float64(*f.RPM)
+			}
+		}
+		b.WriteString(renderTopoFanRow(fans, platform.ResolveFanMaxRPM(current)))
+	}
+
 	return topoCard("Topology", b.String())
 }
 
+// renderTopoFanRow renders the COOLING row: one clickable square per fan,
+// side length scaled by rpm/maxRPM and a fan glyph whose spin rate tracks the
+// same ratio. maxByName comes from platform.ResolveFanMaxRPM — it already has
+// an entry for every fan (persisted peak, else peer peak, else current RPM),
+// so no fallback logic lives here.
+func renderTopoFanRow(fans []schema.HardwareFanSensor, maxByName map[string]float64) string {
+	const (
+		fanTileMin = 30 // px, a stalled / slowest fan
+		fanTileMax = 58 // px, a fan at its ceiling
+	)
+
+	var tally topoStatusTally
+	for _, f := range fans {
+		tally.add(classifyTopoSeverity(f.Status))
+	}
+
+	var b strings.Builder
+	b.WriteString(topoRowHeading("Cooling"))
+	b.WriteString(topoFanSpinStyle())
+	b.WriteString(`<div style="display:flex;flex-wrap:wrap;gap:6px;align-items:flex-end">`)
+	for _, f := range fans {
+		name := strings.TrimSpace(f.Name)
+		fill, stroke, text := topoSeverityColors(classifyTopoSeverity(f.Status))
+
+		denom := maxByName[name]
+		ratio := 0.0
+		title := name
+		if f.RPM != nil {
+			if denom > 0 {
+				ratio = float64(*f.RPM) / denom
+			}
+			if ratio < 0 {
+				ratio = 0
+			}
+			if ratio > 1 {
+				ratio = 1
+			}
+			if denom > float64(*f.RPM) {
+				title = fmt.Sprintf("%s · %d RPM (max %d)", name, *f.RPM, int(denom))
+			} else {
+				title = fmt.Sprintf("%s · %d RPM", name, *f.RPM)
+			}
+		} else {
+			title = name + " · no reading"
+		}
+
+		side := fanTileMin + int(float64(fanTileMax-fanTileMin)*ratio+0.5)
+		// Spin period: 2.6s at rest down to 0.5s at the observed peak. A fan
+		// with no reading doesn't spin.
+		spin := ""
+		if f.RPM != nil && *f.RPM > 0 {
+			period := 2.6 - 2.1*ratio
+			spin = fmt.Sprintf(`<svg class="topo-fan-spin" style="animation-duration:%.2fs" width="%d" height="%d" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">`,
+				period, side*7/16, side*7/16) + topoFanGlyphPaths() + `</svg>`
+		} else {
+			spin = fmt.Sprintf(`<svg width="%d" height="%d" viewBox="0 0 24 24" fill="currentColor" style="opacity:.4" aria-hidden="true">`,
+				side*7/16, side*7/16) + topoFanGlyphPaths() + `</svg>`
+		}
+
+		fmt.Fprintf(&b, `<div title="%s" onclick="openComponentDetail('fan')" `+
+			`style="width:%dpx;height:%dpx;display:flex;align-items:center;justify-content:center;`+
+			`border-radius:5px;background:%s;border:1px solid %s;color:%s;cursor:pointer">%s</div>`,
+			html.EscapeString(title), side, side, fill, stroke, text, spin)
+	}
+	b.WriteString(`</div>`)
+	fmt.Fprintf(&b, `<div style="font-size:11px;color:var(--muted);margin-top:6px">%d fans · %s · tile size ∝ RPM / observed max</div>`,
+		len(fans), html.EscapeString(tally.line()))
+	return b.String()
+}
+
+// topoFanSpinStyle emits the keyframes + base class for the spinning fan
+// glyph once per row. A repeated identical <style> is harmless.
+func topoFanSpinStyle() string {
+	return `<style>@keyframes topoFanSpin{to{transform:rotate(360deg)}}` +
+		`.topo-fan-spin{transform-box:fill-box;transform-origin:center;` +
+		`animation-name:topoFanSpin;animation-timing-function:linear;animation-iteration-count:infinite}` +
+		`@media (prefers-reduced-motion:reduce){.topo-fan-spin{animation:none}}</style>`
+}
+
+// topoFanGlyphPaths is the fan-blade drawing shared by every fan square,
+// designed on a 24×24 viewBox.
+func topoFanGlyphPaths() string {
+	return `<ellipse cx="12" cy="6.5" rx="3.1" ry="5.2"/>` +
+		`<ellipse cx="12" cy="6.5" rx="3.1" ry="5.2" transform="rotate(120 12 12)"/>` +
+		`<ellipse cx="12" cy="6.5" rx="3.1" ry="5.2" transform="rotate(240 12 12)"/>` +
+		`<circle cx="12" cy="12" r="2.3"/>`
+}
+
+// dedupeFansByName returns the fan sensors from a snapshot with duplicate
+// names collapsed to their first occurrence, matching the ingest contract's
+// "(sensor_type, name) — first wins" rule and skipping unnamed sensors.
+func dedupeFansByName(sensors *schema.HardwareSensors) []schema.HardwareFanSensor {
+	if sensors == nil {
+		return nil
+	}
+	seen := map[string]bool{}
+	var out []schema.HardwareFanSensor
+	for _, f := range sensors.Fans {
+		name := strings.TrimSpace(f.Name)
+		if name == "" || seen[name] {
+			continue
+		}
+		seen[name] = true
+		out = append(out, f)
+	}
+	return out
+}
+
+// topoRowHeading renders the small uppercase section label shared by the
+// flex rows below the SVG diagram (Firmware / Power Supplies / Cooling / ...).
+func topoRowHeading(title string) string {
+	return fmt.Sprintf(`<div style="font-size:11px;color:var(--muted);text-transform:uppercase;letter-spacing:.05em;margin:16px 0 6px">%s</div>`,
+		html.EscapeString(title))
+}
+
 // renderTopoFlexRow renders a labeled, wrapping row of component cards.
 // Returns "" if items is empty (e.g. no PSU data in this audit).
 func renderTopoFlexRow(title string, items []topoCardInfo) string {
@@ -624,8 +753,7 @@ func renderTopoFlexRow(title string, items []topoCardInfo) string {
 		return ""
 	}
 	var b strings.Builder
-	fmt.Fprintf(&b, `<div style="font-size:11px;color:var(--muted);text-transform:uppercase;letter-spacing:.05em;margin:16px 0 6px">%s</div>`,
-		html.EscapeString(title))
+	b.WriteString(topoRowHeading(title))
 	b.WriteString(`<div style="display:flex;flex-wrap:wrap;gap:10px">`)
 	for _, item := range items {
 		onclick := ""
@@ -1064,6 +1192,15 @@ func inventoryFallbackRecords(compType string, opts HandlerOptions) []app.Compon
 			}
 			records = append(records, app.ComponentStatusRecord{ComponentKey: key, Status: topoSeverityStatus(p.Status)})
 		}
+	case "fan":
+		for i, f := range dedupeFansByName(hw.Sensors) {
+			name := strings.TrimSpace(f.Name)
+			key := fmt.Sprintf("fan:%d", i)
+			if name != "" {
+				key = "fan:" + name
+			}
+			records = append(records, app.ComponentStatusRecord{ComponentKey: key, Status: topoSeverityStatus(f.Status)})
+		}
 	case "gpu", "nic", "raid":
 		for i, dev := range hw.PCIeDevices {
 			if pcieDeviceKind(dev) != compType {
diff --git a/audit/internal/webui/page_topo_test.go b/audit/internal/webui/page_topo_test.go
index 36ed1b2..7d011b9 100644
--- a/audit/internal/webui/page_topo_test.go
+++ b/audit/internal/webui/page_topo_test.go
@@ -152,6 +152,71 @@ func TestTopoPageRendersArbitraryPSUAndFirmwareCountsAsFlexRows(t *testing.T) {
 	}
 }
 
+func TestTopoPageRendersCoolingFansAsFlexRow(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "audit.json")
+
+	ok, warn := "OK", "Warning"
+	rpm := func(v int) *int { return &v }
+
+	ingest := schema.HardwareIngestRequest{
+		CollectedAt: "2026-03-15T00:00:00Z",
+		Hardware: schema.HardwareSnapshot{
+			Sensors: &schema.HardwareSensors{
+				Fans: []schema.HardwareFanSensor{
+					{Name: "FAN1", RPM: rpm(4200), Status: &ok},
+					{Name: "FAN2", RPM: rpm(15000), Status: &warn},
+					{Name: "FAN2", RPM: rpm(15000), Status: &warn}, // dup name, first wins
+				},
+			},
+		},
+	}
+	data, err := json.Marshal(ingest)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(path, data, 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	handler := NewHandler(HandlerOptions{AuditPath: path})
+	rec := httptest.NewRecorder()
+	handler.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/topo", nil))
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status=%d", rec.Code)
+	}
+	body := rec.Body.String()
+
+	// One clickable square per fan (2 after dedup by name), each with a
+	// spinning glyph, under a COOLING heading.
+	if !strings.Contains(body, "Cooling") {
+		t.Fatalf("topo page missing Cooling heading: %s", body)
+	}
+	if n := strings.Count(body, `onclick="openComponentDetail('fan')"`) +
+		strings.Count(body, `onclick="openComponentDetail(&#39;fan&#39;)"`); n != 2 {
+		t.Fatalf("expected one clickable square per fan (2), got %d: %s", n, body)
+	}
+	if n := strings.Count(body, `class="topo-fan-spin"`); n != 2 {
+		t.Fatalf("expected 2 spinning fan glyphs, got %d: %s", n, body)
+	}
+	if !strings.Contains(body, "FAN1 · 4200 RPM") || !strings.Contains(body, "FAN2 · 15000 RPM") {
+		t.Fatalf("topo page missing per-fan RPM tooltips: %s", body)
+	}
+	if !strings.Contains(body, "2 fans") {
+		t.Fatalf("topo page missing fan count caption: %s", body)
+	}
+
+	// Component-detail fallback endpoint must resolve the "fan" type.
+	rec2 := httptest.NewRecorder()
+	handler.ServeHTTP(rec2, httptest.NewRequest(http.MethodGet, "/api/components/fan", nil))
+	if rec2.Code != http.StatusOK {
+		t.Fatalf("/api/components/fan status=%d", rec2.Code)
+	}
+	if b := rec2.Body.String(); !strings.Contains(b, "FAN1") || !strings.Contains(b, "FAN2") {
+		t.Fatalf("fan component detail missing fan names: %s", b)
+	}
+}
+
 func TestTopoPageRendersStorageDisksGroupedByType(t *testing.T) {
 	dir := t.TempDir()
 	path := filepath.Join(dir, "audit.json")
diff --git a/audit/internal/webui/page_validate.go b/audit/internal/webui/page_validate.go
index 53b184d..45f802c 100644
--- a/audit/internal/webui/page_validate.go
+++ b/audit/internal/webui/page_validate.go
@@ -114,6 +114,12 @@ func renderValidateMode(opts HandlerOptions, stressDefault bool) string {
 				`Tests power supply transient response by pulsing all GPUs simultaneously between idle and full load. Synchronous pulses across all GPUs create worst-case PSU load spikes — running per-GPU would miss PSU-level failures.`,
 				`<code>dcgmi diag pulse_test</code>`,
 				validateFmtDur(platform.SATEstimatedNvidiaPulseTestSec)+` (all GPUs simultaneously; measured on 8-GPU system).`,
+			)) +
+			renderSATCard("fan", "Fan Ceiling Check", "runSAT('fan')", "", renderValidateCardBody(
+				"All system fans reported over IPMI / lm-sensors.",
+				`Drives CPU (+memory) and, when a GPU is present, GPU load to 100% at the same time and watches every fan until none has climbed for ~1 min. The peak RPM reached is recorded as each fan's ceiling and is what the Topology view sizes the fan tiles against. Success once every fan plateaus (or the time cap is hit). A fan reading 0 RPM or an IPMI status of cr/nr under full load fails. If the host cannot be loaded at all, or exposes no fan sensors, the task is cancelled as "not applicable" rather than failed — the platform does not support forcing fans, so this is the closest safe equivalent.`,
+				`<code>stressapptest</code> / <code>stress-ng</code> + <code>bee-gpu-burn</code> / <code>rvs gst</code>; <code>ipmitool sdr type Fan</code>`,
+				`~2–8 min depending on how fast the fan curve settles (hard cap 15 min).`,
 			))
 	}
 
diff --git a/audit/internal/webui/server.go b/audit/internal/webui/server.go
index 2ffb7fe..b35f514 100644
--- a/audit/internal/webui/server.go
+++ b/audit/internal/webui/server.go
@@ -272,6 +272,7 @@ func NewHandler(opts HandlerOptions) http.Handler {
 	mux.HandleFunc("POST /api/sat/memory-stress/run", h.handleAPISATRun("memory-stress"))
 	mux.HandleFunc("POST /api/sat/sat-stress/run", h.handleAPISATRun("sat-stress"))
 	mux.HandleFunc("POST /api/sat/platform-stress/run", h.handleAPISATRun("platform-stress"))
+	mux.HandleFunc("POST /api/sat/fan/run", h.handleAPISATRun("fan"))
 	mux.HandleFunc("POST /api/sat/run-all", h.handleAPISATRunAll)
 	mux.HandleFunc("GET /api/sat/stream", h.handleAPISATStream)
 	mux.HandleFunc("POST /api/sat/abort", h.handleAPISATAbort)
diff --git a/audit/internal/webui/task_runner.go b/audit/internal/webui/task_runner.go
index 9715664..2841760 100644
--- a/audit/internal/webui/task_runner.go
+++ b/audit/internal/webui/task_runner.go
@@ -3,6 +3,7 @@ package webui
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"log/slog"
@@ -79,9 +80,11 @@ func finalizeTaskForResult(t *Task, errMsg string, cancelled bool) {
 	now := time.Now()
 	t.DoneAt = &now
 	switch {
-	case cancelled:
+	case cancelled || t.Status == TaskCancelled:
 		t.Status = TaskCancelled
-		t.ErrMsg = "aborted"
+		if strings.TrimSpace(t.ErrMsg) == "" {
+			t.ErrMsg = "aborted"
+		}
 	case strings.TrimSpace(errMsg) != "":
 		t.Status = TaskFailed
 		t.ErrMsg = errMsg
@@ -377,6 +380,12 @@ func executeTaskWithOptions(opts *HandlerOptions, t *Task, j *jobState, ctx cont
 		runOpts := resolvePlatformStressPreset(t.params.BurnProfile)
 		runOpts.Components = t.params.PlatformComponents
 		archive, err = a.RunPlatformStress(ctx, "", runOpts, j.append)
+	case "fan":
+		if a == nil {
+			err = fmt.Errorf("app not configured")
+			break
+		}
+		archive, err = runFanCheckPackCtx(a, ctx, "", platform.FanCheckOptions{GPUIndices: t.params.GPUIndices}, j.append)
 	case "audit":
 		if a == nil {
 			err = fmt.Errorf("app not configured")
@@ -476,10 +485,19 @@ func executeTaskWithOptions(opts *HandlerOptions, t *Task, j *jobState, ctx cont
 	}
 
 	if err != nil {
-		if ctx.Err() != nil {
+		switch {
+		case ctx.Err() != nil:
 			j.append("Aborted.")
 			j.finish("aborted")
-		} else {
+		case errors.Is(err, platform.ErrTestNotApplicable):
+			// The host offered no way to run this test — not a hardware
+			// fault. Land the task as cancelled ("not applicable") with a
+			// detailed log, so an engineer never sees a false failure.
+			j.append("NOT APPLICABLE: " + err.Error())
+			t.Status = TaskCancelled
+			t.ErrMsg = "not applicable — " + err.Error()
+			j.finish("")
+		default:
 			j.append("ERROR: " + err.Error())
 			j.finish(err.Error())
 		}
diff --git a/audit/internal/webui/tasks.go b/audit/internal/webui/tasks.go
index 4b1cfe8..a0ba100 100644
--- a/audit/internal/webui/tasks.go
+++ b/audit/internal/webui/tasks.go
@@ -53,6 +53,7 @@ var taskNames = map[string]string{
 	"memory-stress":          "Memory Burn-in",
 	"sat-stress":             "SAT Stress (stressapptest)",
 	"platform-stress":        "Platform Thermal Cycling",
+	"fan":                    "Fan Ceiling Check (CPU+GPU load)",
 	"audit":                  "Audit",
 	"support-bundle":         "Support Bundle",
 	"install":                "Install to Disk",
@@ -196,7 +197,7 @@ func taskMayLeaveOrphanWorkers(target string) bool {
 	switch strings.TrimSpace(strings.ToLower(target)) {
 	case "nvidia", "nvidia-targeted-stress", "nvidia-targeted-power", "nvidia-pulse",
 		"nvidia-bandwidth", "nvidia-stress", "nvidia-compute", "nvidia-bench-perf",
-		"memory", "memory-stress", "cpu", "sat-stress", "platform-stress":
+		"memory", "memory-stress", "cpu", "sat-stress", "platform-stress", "fan":
 		return true
 	default:
 		return false
@@ -343,6 +344,9 @@ var (
 	runSATStressPackCtx = func(a *app.App, ctx context.Context, baseDir string, durationSec int, logFunc func(string)) (string, error) {
 		return a.RunSATStressPackCtx(ctx, baseDir, durationSec, logFunc)
 	}
+	runFanCheckPackCtx = func(a *app.App, ctx context.Context, baseDir string, opts platform.FanCheckOptions, logFunc func(string)) (string, error) {
+		return a.RunFanCheckCtx(ctx, baseDir, opts, logFunc)
+	}
 	buildSupportBundle = app.BuildSupportBundle
 	installCommand     = func(ctx context.Context, device string, logPath string) *exec.Cmd {
 		return exec.CommandContext(ctx, "bee-install", device, logPath)
diff --git a/audit/internal/webui/tasks_test.go b/audit/internal/webui/tasks_test.go
index 5743bf4..2c567b9 100644
--- a/audit/internal/webui/tasks_test.go
+++ b/audit/internal/webui/tasks_test.go
@@ -3,6 +3,7 @@ package webui
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"os"
@@ -700,6 +701,34 @@ func TestRunTaskHonorsCancel(t *testing.T) {
 	}
 }
 
+func TestRunTaskFanNotApplicableIsCancelledNotFailed(t *testing.T) {
+	q := &taskQueue{opts: &HandlerOptions{App: &app.App{}}}
+	tk := &Task{
+		ID: "fan-1", Name: "Fan Ceiling Check", Target: "fan",
+		Status: TaskRunning, CreatedAt: time.Now(),
+	}
+	j := &jobState{}
+	tk.job = j
+
+	orig := runFanCheckPackCtx
+	runFanCheckPackCtx = func(_ *app.App, _ context.Context, _ string, _ platform.FanCheckOptions, _ func(string)) (string, error) {
+		return "", fmt.Errorf("no fan sensors readable: %w", platform.ErrTestNotApplicable)
+	}
+	defer func() { runFanCheckPackCtx = orig }()
+
+	q.runTask(tk, j, context.Background())
+
+	if tk.Status != TaskCancelled {
+		t.Fatalf("status=%q want %q", tk.Status, TaskCancelled)
+	}
+	if j.err != "" {
+		t.Fatalf("job err should be empty for a not-applicable task, got %q", j.err)
+	}
+	if !strings.Contains(tk.ErrMsg, "not applicable") {
+		t.Fatalf("ErrMsg should explain not-applicable, got %q", tk.ErrMsg)
+	}
+}
+
 func TestRunTaskUsesBurnProfileDurationForCPU(t *testing.T) {
 	var gotDuration int
 	q := &taskQueue{
diff --git a/bible-local/README.md b/bible-local/README.md
index fa0b0a4..d0f1d4f 100644
--- a/bible-local/README.md
+++ b/bible-local/README.md
@@ -9,6 +9,7 @@ Generic engineering rules live in `bible/rules/patterns/`.
 |---|---|
 | `architecture/system-overview.md` | What bee does, scope, tech stack |
 | `architecture/runtime-flows.md` | Boot sequence, audit flow, service order |
+| `architecture/squashfs-layers.md` | Semantic SquashFS layer model, ownership, order, verification |
 | `docs/customer-gpu-test-methodology.md` | Customer-facing GPU PCIe Validate / Validate -> Stress test list |
 | `docs/hardware-ingest-contract.md` | Current Reanimator hardware ingest JSON contract |
 | `docs/validate-vs-burn.md` | Validate and Validate -> Stress hardware test policy |
@@ -74,3 +75,8 @@ Generic engineering rules live in `bible/rules/patterns/`.
   - `all_reduce_perf`
 - GPU bandwidth check
   - `dcgmi diag -r nvbandwidth` (per CPU socket, then all selected GPUs, on multi-socket systems -- see `decisions/2026-07-27-nvbandwidth-per-socket-split.md`)
+- Fan ceiling check (Load tier / `3. Load` only)
+  - `stressapptest` (or `stress-ng`) + `bee-gpu-burn` / `rvs gst` at 100%, run simultaneously
+  - `ipmitool sdr type Fan` sampled 1 Hz until every fan plateaus (~1 min flat) or the 15 min cap
+  - records each fan's observed peak RPM to `/var/log/bee-sat/fan-observation.json` (used by the Topology fan tiles); FAIL only on a fan at 0 RPM / IPMI cr-nr under load; **cancelled ("not applicable")**, never failed, if the host cannot be loaded or has no fan sensors
+  - see `decisions/2026-09-04-fan-ceiling-check.md`
diff --git a/bible-local/architecture/api-surface.md b/bible-local/architecture/api-surface.md
index bbae0fa..948e306 100644
--- a/bible-local/architecture/api-surface.md
+++ b/bible-local/architecture/api-surface.md
@@ -53,6 +53,7 @@ All SAT run endpoints enqueue an async task. Response: `{"task_id": "..."}`.
 | POST   | `/api/sat/memory-stress/run`               | Memory stress                     |
 | POST   | `/api/sat/sat-stress/run`                  | Combined storage+memory stress    |
 | POST   | `/api/sat/platform-stress/run`             | Fan + thermal stress              |
+| POST   | `/api/sat/fan/run`                         | Fan ceiling check (CPU+GPU load until fans plateau; Load tier). Not-applicable → task cancelled, not failed. |
 | POST   | `/api/sat/run-all`                          | Plan + enqueue the whole validate/check set server-side. Body: `{stress_mode, amd_targets[], nvidia_gpu_indices[]}` (operator intent only). Response: `{task_ids[], task_count, notes[]}`. Hardware presence/readiness and which tasks to run are decided by `handler.planSATRunAll`, not the page. |
 | GET    | `/api/sat/stream`                          | SSE: live SAT log stream          |
 | POST   | `/api/sat/abort`                           | Abort the running SAT task        |
diff --git a/bible-local/decisions/2026-09-04-fan-ceiling-check.md b/bible-local/decisions/2026-09-04-fan-ceiling-check.md
new file mode 100644
index 0000000..9bbdca5
--- /dev/null
+++ b/bible-local/decisions/2026-09-04-fan-ceiling-check.md
@@ -0,0 +1,68 @@
+# Decision: Fan check discovers the RPM ceiling by CPU+GPU load, not by forcing fans over the BMC
+
+**Date:** 2026-09-04
+**Status:** active
+
+## Context
+
+We want a SAT test that pushes every system fan to its top speed, records that
+speed as the fan's ceiling, and flags a fan that will not spin. The recorded
+ceiling is what the Topology view sizes each fan tile against
+(`platform.ResolveFanMaxRPM`).
+
+The obvious approach — force the fans to 100% PWM over IPMI/Redfish and read the
+resulting RPM — does not work on our current platform:
+
+- Stand: MSI G4201 / MS-S3831, AMI MegaRAC BMC (fw 1.08).
+- Every documented host-side fan-control OEM command returns
+  `rsp=0xc1 Invalid command`: Supermicro `0x30 0x45`, ASRock/AMI reference
+  `0x3a 0x01 / 0xd0 0x12 / 0xd0 0x0f / 0xd6 / 0xd7 / 0xda`, `0x30 0x30..0x32`.
+  BIOS `KCS Access Control Policy = Allow All`, so this is not KCS filtering —
+  MSI simply does not implement them.
+- The MSI G4201 Redfish API guide documents Thermal as **GET only**; no
+  fan-mode / fan-PWM PATCH endpoint exists.
+- The only fan knob in BIOS is `Fan PWM Offset` (0–100, additive to the auto
+  curve, reboot-gated) — not a runtime 100% force.
+
+## Decision
+
+The `fan` SAT test (`platform.RunFanCheck`, formerly the unwired
+`RunFanStressTest`) drives load, not the BMC:
+
+1. Start `stressapptest` (CPU + memory) and, when a GPU is present, a GPU burn
+   (`bee-gpu-burn` / `rvs gst`) **simultaneously**, each in its own goroutine.
+   A missing GPU is not an error — CPU/memory load alone exercises the cooling
+   loop. Load sources reach full power at different times, so the plateau clock
+   only starts once every launched source reports its process running (plus a
+   fixed GPU ramp grace).
+2. Sample every fan once a second. Per fan, track the peak RPM and the last time
+   it climbed by more than `PlateauDeltaRPM` (default 50).
+3. When no fan has climbed for `PlateauHoldSec` (default 60 s) and at least one
+   fan rose meaningfully above baseline, declare the ceiling found and stop —
+   **success**. `MaxLoadSec` (default 900 s) is a hard cap; hitting it is also
+   success (the highest RPM seen is still recorded).
+4. Persist each peak through the existing `updateFanObservation` path
+   (`/var/log/bee-sat/fan-observation.json`), which is what `ResolveFanMaxRPM`
+   reads.
+
+## Verdict mapping
+
+- A fan reading **0 RPM**, or IPMI status **cr/nr**, while under full load →
+  `FAILED` (dead / stuck rotor).
+- No load source available (no `stressapptest`/`stress-ng` and no GPU burn
+  tool), or no fan sensors at all → `platform.ErrTestNotApplicable`, which the
+  task layer lands as **cancelled ("not applicable")**, never failed, with a
+  detailed log. An engineer must not see a red for "this platform can't run the
+  test".
+
+## Tier
+
+Load only (`/load`, "3. Load"). It is a sustained full-load test, so it does
+not belong on the read-only Check page. Added to the stress-mode `Run All`.
+
+## Consequences
+
+- The ceiling is *observed*, not a spec value — only as high as the load drove
+  the fans. Good enough for tile sizing and stuck-fan detection.
+- If a future platform does expose a safe host-side fan force, revisit: a real
+  100% force is a stronger test than load-driven ramp.

From 8cb250f3f48e32d8b46569f30374668156ed559a Mon Sep 17 00:00:00 2001
From: Mikhail Chusavitin <mchusavitin@mchusmbp.local>
Date: Fri, 4 Sep 2026 11:02:31 +0300
Subject: [PATCH 3/9] fix(sat): fan check uses hottest GPU load +
 IPMI-hang-proof polling
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- GPU load switches from bee-gpu-burn (compute burn, ~88% TDP) to
  dcgmproftester -t 1004 / targeted_power via
  resolveBenchmarkPowerLoadCommand — the same engine Power/Thermal Fit
  uses and the hottest sustained NVIDIA load we have, so fans are
  actually pushed toward their ceiling.
- Sample loop is now IPMI-hang-proof: every ipmitool read is time-boxed
  in an abandonable goroutine, and the poll interval backs off
  geometrically (1s→30s) when reads are slow, tightening again on
  recovery. A plateau is only trusted while telemetry is healthy;
  degraded runs ride out to MaxLoadSec. Summary gains fan_samples /
  telemetry_degraded. Drops the per-second nvidia-smi+power+cpu-temp
  sampling from the hot loop.
- Dead code removed: FanStressRow, GPUStressMetric, sampleFanStressRow,
  sampleGPUStressMetrics, WriteFanStressCSV/WriteFanSensorsCSV,
  analyzeMaxTemp, sampleSystemPowerResolved.

Topology fan tiles:
- size encodes the fan's ceiling RPM (its class), not current speed;
  coloured fill rising from the bottom encodes live duty cycle
  (current / ceiling), shown only when the ceiling was measured.
- glyph spin rate now maps absolute RPM into a human-perceptible band
  (fanSpinPeriodSec: 2.2s/turn at <=1000 RPM, 0.35s at >=13000).
- the "N fans · N OK · tile size ∝ …" caption line is gone.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019VHG21rgTUiR1G3qFHTVmN
---
 audit/internal/platform/sat_fan_stress.go     | 405 +++++++++---------
 audit/internal/webui/page_topo_diagram.go     | 132 +++---
 audit/internal/webui/page_topo_test.go        |  22 +-
 audit/internal/webui/page_validate.go         |   6 +-
 bible-local/README.md                         |   6 +-
 .../decisions/2026-09-04-fan-ceiling-check.md |  24 +-
 6 files changed, 328 insertions(+), 267 deletions(-)

diff --git a/audit/internal/platform/sat_fan_stress.go b/audit/internal/platform/sat_fan_stress.go
index 4648b25..ccaf30d 100644
--- a/audit/internal/platform/sat_fan_stress.go
+++ b/audit/internal/platform/sat_fan_stress.go
@@ -12,6 +12,7 @@ import (
 	"strconv"
 	"strings"
 	"sync"
+	"syscall"
 	"time"
 )
 
@@ -35,29 +36,6 @@ type FanReading struct {
 	RPM  float64
 }
 
-// GPUStressMetric holds per-GPU metrics during the stress test.
-type GPUStressMetric struct {
-	Index     int
-	TempC     float64
-	UsagePct  float64
-	PowerW    float64
-	ClockMHz  float64
-	Throttled bool // true if any throttle reason is active
-}
-
-// FanStressRow is one second-interval telemetry sample covering all monitored dimensions.
-type FanStressRow struct {
-	TimestampUTC   string
-	ElapsedSec     float64
-	Phase          string // "baseline", "load1", "pause", "load2", "cooldown"
-	GPUs           []GPUStressMetric
-	Fans           []FanReading
-	CPUMaxTempC    float64 // highest CPU temperature from ipmitool / sensors
-	SysPowerW      float64
-	SysPowerSource string
-	SysPowerMode   string
-}
-
 type cachedPowerReading struct {
 	Value     float64
 	Source    string
@@ -76,8 +54,6 @@ type fanPeakCandidate struct {
 }
 
 var (
-	systemPowerCacheMu sync.Mutex
-	systemPowerCache   cachedPowerReading
 	fanObservationMu   sync.Mutex
 	fanObservation     fanObservationState
 	fanObservationInit bool
@@ -157,10 +133,16 @@ func (s *System) RunFanCheck(ctx context.Context, baseDir string, opts FanCheckO
 	logFunc(fmt.Sprintf("Fan check: %d fans; load = CPU/mem:%v + GPU:%s", len(baseFans), haveCPU, orNone(haveGPU, vendor)))
 
 	// ── Load: every source runs at the same time, each in its own goroutine.
-	// Sources can take different amounts of time to actually reach full load
-	// (stressapptest is near-instant; a GPU burn kernel needs to compile and
-	// ramp), so the plateau clock does not start until every launched source
-	// has reported its process running, plus a fixed GPU ramp grace.
+	// GPU load is the hottest sustained NVIDIA load we have — dcgmproftester
+	// -t 1004 / targeted_power, the same engine the Power/Thermal Fit
+	// benchmark uses (resolveBenchmarkPowerLoadCommand) — not the
+	// compute-throughput bee-gpu-burn, which tops out well below TDP and so
+	// never demands the fans' true ceiling.
+	//
+	// Sources reach full load at different times (stressapptest is instant; a
+	// dcgmproftester kernel compiles and ramps), so the plateau clock does not
+	// start until every launched source reports its process running, plus a
+	// fixed GPU ramp grace.
 	loadCtx, loadCancel := context.WithTimeout(ctx, time.Duration(opts.MaxLoadSec)*time.Second)
 	defer loadCancel()
 
@@ -190,14 +172,20 @@ func (s *System) RunFanCheck(ctx context.Context, baseDir string, opts FanCheckO
 		loadWG.Add(1)
 		go func() {
 			defer loadWG.Done()
-			cmd := buildGPUStressCmd(loadCtx, vendor, opts.MaxLoadSec)
-			if cmd == nil {
-				logFunc("GPU load unavailable (no burn tool for " + vendor + ")")
-				appendSATVerboseLog(verboseLog, "gpu load: no burn tool")
+			cmd, label, err := buildFanCheckGPULoadCmd(loadCtx, vendor, opts.MaxLoadSec, opts.GPUIndices)
+			if err != nil || cmd == nil {
+				logFunc("GPU load unavailable: " + errString(err))
+				appendSATVerboseLog(verboseLog, "gpu load unavailable: "+errString(err))
 				started <- false
 				return
 			}
-			logFunc("GPU load running (" + vendor + ")")
+			if err := cmd.Start(); err != nil {
+				logFunc("GPU load failed to start: " + err.Error())
+				appendSATVerboseLog(verboseLog, "gpu load start error: "+err.Error())
+				started <- false
+				return
+			}
+			logFunc("GPU load running (" + label + ")")
 			started <- true
 			_ = cmd.Wait()
 		}()
@@ -226,19 +214,39 @@ func (s *System) RunFanCheck(ctx context.Context, baseDir string, opts FanCheckO
 	appendSATVerboseLog(verboseLog, fmt.Sprintf("%d load source(s) active; plateau clock effective from +%.0fs",
 		activeLoads, readyAt.Sub(start).Seconds()))
 
-	// ── Sample loop: one row/second, per-fan plateau tracking.
+	// ── Sample loop with IPMI-hang protection.
+	//
+	// Under full load ipmitool over KCS can take tens of seconds per call or
+	// wedge outright. So: every fan read is time-boxed (readFansBounded runs
+	// it in a goroutine we abandon on timeout — a wedged KCS read can never
+	// block this loop), and the polling interval backs off geometrically when
+	// reads are slow and tightens again when they recover. A plateau is only
+	// declared while telemetry is healthy (interval near the floor); a
+	// degraded run just rides out to MaxLoadSec and records the peak it saw.
+	const (
+		fanPollFloor = 1 * time.Second
+		fanPollCeil  = 30 * time.Second
+		fanReadTMO   = 8 * time.Second
+	)
 	type fanState struct {
 		peak        float64
 		lastRiseSec float64
 	}
 	fanBy := map[string]*fanState{}
-	var rows []FanStressRow
 	rampConfirmed := false
 	plateauReached := false
 	aborted := false
+	degraded := false
+	goodSamples := 0
+	poll := fanPollFloor
+
+	csvPath := filepath.Join(runDir, "fan-sensors.csv")
+	_ = os.WriteFile(csvPath, []byte("elapsed_sec,fan_name,rpm\n"), 0644)
+	csvFile, _ := os.OpenFile(csvPath, os.O_APPEND|os.O_WRONLY, 0644)
+	if csvFile != nil {
+		defer csvFile.Close()
+	}
 
-	ticker := time.NewTicker(time.Second)
-	defer ticker.Stop()
 loop:
 	for {
 		select {
@@ -247,13 +255,36 @@ loop:
 			break loop
 		case <-loadCtx.Done():
 			break loop // MaxLoadSec reached
-		case <-ticker.C:
+		case <-time.After(poll):
 		}
 		elapsed := time.Since(start).Seconds()
-		row := sampleFanStressRow(opts.GPUIndices, "load", elapsed)
-		rows = append(rows, row)
 
-		for _, f := range row.Fans {
+		readStart := time.Now()
+		fans, ok := readFansBounded(fanReadTMO)
+		readDur := time.Since(readStart)
+
+		// Adapt the interval to how ipmitool is behaving.
+		switch {
+		case !ok || readDur > fanReadTMO*3/4:
+			if poll < fanPollCeil {
+				poll = minDuration(poll*2, fanPollCeil)
+				degraded = true
+				appendSATVerboseLog(verboseLog, fmt.Sprintf("[%.0fs] ipmitool slow (%.1fs, ok=%v) — polling backed off to %s",
+					elapsed, readDur.Seconds(), ok, poll))
+				logFunc(fmt.Sprintf("IPMI slow — fan polling backed off to %s", poll))
+			}
+		case poll > fanPollFloor && readDur < fanPollFloor:
+			poll = maxDuration(poll*2/3, fanPollFloor)
+		}
+		if !ok {
+			continue
+		}
+		goodSamples++
+
+		for _, f := range fans {
+			if csvFile != nil {
+				fmt.Fprintf(csvFile, "%.0f,%s,%.0f\n", elapsed, f.Name, f.RPM)
+			}
 			st := fanBy[f.Name]
 			if st == nil {
 				fanBy[f.Name] = &fanState{peak: f.RPM, lastRiseSec: elapsed}
@@ -270,7 +301,11 @@ loop:
 			}
 		}
 
-		if elapsed >= float64(opts.MinLoadSec) && time.Since(readyAt) >= time.Duration(opts.PlateauHoldSec)*time.Second && len(fanBy) > 0 {
+		// Only trust a plateau while telemetry is healthy and we have enough
+		// recent samples to have actually seen a flat window.
+		healthy := poll <= 2*fanPollFloor && goodSamples >= 5
+		if healthy && rampConfirmed && elapsed >= float64(opts.MinLoadSec) &&
+			time.Since(readyAt) >= time.Duration(opts.PlateauHoldSec)*time.Second && len(fanBy) > 0 {
 			allFlat := true
 			for _, st := range fanBy {
 				if elapsed-st.lastRiseSec < float64(opts.PlateauHoldSec) {
@@ -278,7 +313,7 @@ loop:
 					break
 				}
 			}
-			if allFlat && rampConfirmed {
+			if allFlat {
 				plateauReached = true
 				logFunc(fmt.Sprintf("All %d fans plateaued at %.0fs of load", len(fanBy), elapsed))
 				break loop
@@ -295,6 +330,8 @@ loop:
 		return runDir, ctx.Err()
 	}
 
+	loadDur := time.Since(start).Seconds()
+
 	// ── Verdict.
 	statuses := readFanStatuses()
 	var summary strings.Builder
@@ -304,19 +341,12 @@ loop:
 	fmt.Fprintf(&summary, "gpu_vendor=%s\n", orNone(haveGPU, vendor))
 	fmt.Fprintf(&summary, "plateau_reached=%v\n", plateauReached)
 	fmt.Fprintf(&summary, "ramp_confirmed=%v\n", rampConfirmed)
-	if len(rows) > 0 {
-		fmt.Fprintf(&summary, "load_duration_sec=%.0f\n", rows[len(rows)-1].ElapsedSec)
+	fmt.Fprintf(&summary, "load_duration_sec=%.0f\n", loadDur)
+	fmt.Fprintf(&summary, "fan_samples=%d\n", goodSamples)
+	fmt.Fprintf(&summary, "telemetry_degraded=%v\n", degraded)
+	if t := boundedGPUMaxTemp(opts.GPUIndices); t > 0 {
+		fmt.Fprintf(&summary, "gpu_temp_c=%.0f\n", t)
 	}
-	fmt.Fprintf(&summary, "max_gpu_temp_c=%.1f\n", analyzeMaxTemp(rows, func(r FanStressRow) float64 {
-		var m float64
-		for _, g := range r.GPUs {
-			if g.TempC > m {
-				m = g.TempC
-			}
-		}
-		return m
-	}))
-	fmt.Fprintf(&summary, "max_cpu_temp_c=%.1f\n", analyzeMaxTemp(rows, func(r FanStressRow) float64 { return r.CPUMaxTempC }))
 
 	stats := satStats{}
 	names := make([]string, 0, len(baselineRPM))
@@ -349,14 +379,126 @@ loop:
 	}
 	writeSATStats(&summary, stats)
 
-	_ = WriteFanStressCSV(filepath.Join(runDir, "metrics.csv"), rows, opts.GPUIndices)
-	_ = WriteFanSensorsCSV(filepath.Join(runDir, "fan-sensors.csv"), rows)
 	if err := os.WriteFile(filepath.Join(runDir, "summary.txt"), []byte(summary.String()), 0644); err != nil {
 		return "", err
 	}
 	return runDir, nil
 }
 
+func errString(err error) string {
+	if err == nil {
+		return "no GPU stress tool"
+	}
+	return err.Error()
+}
+
+func minDuration(a, b time.Duration) time.Duration {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func maxDuration(a, b time.Duration) time.Duration {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+// readFansBounded runs "ipmitool sdr type Fan" but never blocks the caller
+// longer than timeout: the read happens in a goroutine that is abandoned if it
+// does not return in time (a KCS read wedged in uninterruptible I/O cannot be
+// killed, so we leave it and move on). ok=false means "no usable sample this
+// tick" — the caller must treat that as missing data, not as a flat fan.
+func readFansBounded(timeout time.Duration) ([]FanReading, bool) {
+	type result struct {
+		fans []FanReading
+		ok   bool
+	}
+	ch := make(chan result, 1)
+	go func() {
+		out, err := exec.Command("ipmitool", "sdr", "type", "Fan").Output()
+		if err != nil {
+			ch <- result{}
+			return
+		}
+		fans := parseFanSpeeds(string(out))
+		if len(fans) == 0 {
+			ch <- result{}
+			return
+		}
+		ch <- result{fans, true}
+	}()
+	select {
+	case r := <-ch:
+		if r.ok {
+			updateFanObservation(r.fans, time.Now())
+		}
+		return r.fans, r.ok
+	case <-time.After(timeout):
+		return nil, false
+	}
+}
+
+// boundedGPUMaxTemp returns the hottest GPU temperature via a single
+// time-boxed nvidia-smi call, or 0 if unavailable.
+func boundedGPUMaxTemp(gpuIndices []int) float64 {
+	ctx, cancel := context.WithTimeout(context.Background(), 6*time.Second)
+	defer cancel()
+	args := []string{"--query-gpu=temperature.gpu", "--format=csv,noheader,nounits"}
+	if len(gpuIndices) > 0 {
+		ids := make([]string, len(gpuIndices))
+		for i, idx := range gpuIndices {
+			ids[i] = strconv.Itoa(idx)
+		}
+		args = append([]string{"--id=" + strings.Join(ids, ",")}, args...)
+	}
+	out, err := exec.CommandContext(ctx, "nvidia-smi", args...).Output()
+	if err != nil {
+		return 0
+	}
+	var max float64
+	for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
+		if v, err := strconv.ParseFloat(strings.TrimSpace(line), 64); err == nil && v > max {
+			max = v
+		}
+	}
+	return max
+}
+
+// buildFanCheckGPULoadCmd builds the hottest sustained GPU load for the fan
+// check. NVIDIA uses the Power/Thermal Fit engine (dcgmproftester -t 1004 /
+// targeted_power); AMD uses the RVS gst stressor.
+func buildFanCheckGPULoadCmd(ctx context.Context, vendor string, durSec int, gpuIndices []int) (*exec.Cmd, string, error) {
+	switch strings.ToLower(vendor) {
+	case "nvidia":
+		argv, env, err := resolveBenchmarkPowerLoadCommand(durSec, gpuIndices)
+		if err != nil {
+			return nil, "", err
+		}
+		cmd := exec.CommandContext(ctx, argv[0], argv[1:]...)
+		if len(env) > 0 {
+			cmd.Env = append(os.Environ(), env...)
+		}
+		cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+		cmd.Cancel = func() error {
+			if cmd.Process != nil {
+				_ = syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
+			}
+			return nil
+		}
+		return cmd, "dcgmproftester targeted_power", nil
+	case "amd":
+		cmd := buildAMDGPUStressCmd(ctx, durSec)
+		if cmd == nil {
+			return nil, "", nil
+		}
+		return cmd, "rvs gst", nil
+	}
+	return nil, "", nil
+}
+
 func applyFanCheckDefaults(o *FanCheckOptions) {
 	if o.PlateauHoldSec <= 0 {
 		o.PlateauHoldSec = 60
@@ -459,68 +601,6 @@ func ResolveFanMaxRPM(current map[string]float64) map[string]float64 {
 	return out
 }
 
-// sampleFanStressRow collects all metrics for one telemetry sample.
-func sampleFanStressRow(gpuIndices []int, phase string, elapsed float64) FanStressRow {
-	row := FanStressRow{
-		TimestampUTC: time.Now().UTC().Format(time.RFC3339),
-		ElapsedSec:   elapsed,
-		Phase:        phase,
-	}
-	row.GPUs = sampleGPUStressMetrics(gpuIndices)
-	row.Fans, _ = sampleFanSpeeds()
-	row.CPUMaxTempC = sampleCPUMaxTemp()
-	row.SysPowerW, row.SysPowerSource, row.SysPowerMode = sampleSystemPowerResolved()
-	return row
-}
-
-// sampleGPUStressMetrics queries nvidia-smi for temperature, utilization, power,
-// clock frequency, and active throttle reasons for each GPU.
-func sampleGPUStressMetrics(gpuIndices []int) []GPUStressMetric {
-	args := []string{
-		"--query-gpu=index,temperature.gpu,utilization.gpu,power.draw,clocks.current.graphics,clocks_throttle_reasons.active",
-		"--format=csv,noheader,nounits",
-	}
-	if len(gpuIndices) > 0 {
-		ids := make([]string, len(gpuIndices))
-		for i, idx := range gpuIndices {
-			ids[i] = strconv.Itoa(idx)
-		}
-		args = append([]string{"--id=" + strings.Join(ids, ",")}, args...)
-	}
-	out, err := exec.Command("nvidia-smi", args...).Output()
-	if err != nil {
-		return nil
-	}
-	var metrics []GPUStressMetric
-	for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
-		line = strings.TrimSpace(line)
-		if line == "" {
-			continue
-		}
-		parts := strings.Split(line, ", ")
-		if len(parts) < 6 {
-			continue
-		}
-		idx, _ := strconv.Atoi(strings.TrimSpace(parts[0]))
-		throttleVal := strings.TrimSpace(parts[5])
-		// Throttled if active reasons bitmask is non-zero.
-		throttled := throttleVal != "0x0000000000000000" &&
-			throttleVal != "0x0" &&
-			throttleVal != "0" &&
-			throttleVal != "" &&
-			throttleVal != "N/A"
-		metrics = append(metrics, GPUStressMetric{
-			Index:     idx,
-			TempC:     parseGPUFloat(parts[1]),
-			UsagePct:  parseGPUFloat(parts[2]),
-			PowerW:    parseGPUFloat(parts[3]),
-			ClockMHz:  parseGPUFloat(parts[4]),
-			Throttled: throttled,
-		})
-	}
-	return metrics
-}
-
 // sampleFanSpeeds reads fan RPM values from ipmitool sdr.
 func sampleFanSpeeds() ([]FanReading, error) {
 	out, err := exec.Command("ipmitool", "sdr", "type", "Fan").Output()
@@ -940,21 +1020,6 @@ func sampleCPUTempViaSensors() float64 {
 	return max
 }
 
-// sampleSystemPowerResolved reads system power via the global autotune source,
-// falling back to the historical heuristic before autotune or when degraded.
-func sampleSystemPowerResolved() (float64, string, string) {
-	now := time.Now()
-	current, decision, err := SampleSystemPowerResolved("")
-	systemPowerCacheMu.Lock()
-	defer systemPowerCacheMu.Unlock()
-	if err != nil {
-		current = 0
-	}
-	value, updated := effectiveSystemPowerReading(systemPowerCache, current, decision.EffectiveSource, decision.Mode, decision.Reason, now)
-	systemPowerCache = updated
-	return value, updated.Source, updated.Mode
-}
-
 // parseDCMIPowerReading extracts the instantaneous power reading from ipmitool dcmi output.
 // Sample: "    Instantaneous power reading:                   500 Watts"
 func parseDCMIPowerReading(raw string) float64 {
@@ -986,76 +1051,6 @@ func effectiveSystemPowerReading(cache cachedPowerReading, current float64, sour
 	return 0, cache
 }
 
-// analyzeMaxTemp returns the maximum value of the given extractor across all rows.
-func analyzeMaxTemp(rows []FanStressRow, extract func(FanStressRow) float64) float64 {
-	var max float64
-	for _, row := range rows {
-		if v := extract(row); v > max {
-			max = v
-		}
-	}
-	return max
-}
-
-// WriteFanStressCSV writes the wide-format metrics CSV with one row per second.
-// GPU columns are generated per index in gpuIndices order.
-func WriteFanStressCSV(path string, rows []FanStressRow, gpuIndices []int) error {
-	if len(rows) == 0 {
-		return os.WriteFile(path, []byte("no data\n"), 0644)
-	}
-
-	var b strings.Builder
-
-	// Header: fixed system columns + per-GPU columns.
-	b.WriteString("timestamp_utc,elapsed_sec,phase,fan_avg_rpm,fan_min_rpm,fan_max_rpm,cpu_max_temp_c,sys_power_w")
-	for _, idx := range gpuIndices {
-		fmt.Fprintf(&b, ",gpu%d_temp_c,gpu%d_usage_pct,gpu%d_power_w,gpu%d_clock_mhz,gpu%d_throttled",
-			idx, idx, idx, idx, idx)
-	}
-	b.WriteRune('\n')
-
-	for _, row := range rows {
-		favg, fmin, fmax := fanRPMStats(row.Fans)
-		fmt.Fprintf(&b, "%s,%.1f,%s,%.0f,%.0f,%.0f,%.1f,%.1f",
-			row.TimestampUTC,
-			row.ElapsedSec,
-			row.Phase,
-			favg, fmin, fmax,
-			row.CPUMaxTempC,
-			row.SysPowerW,
-		)
-		gpuByIdx := make(map[int]GPUStressMetric, len(row.GPUs))
-		for _, g := range row.GPUs {
-			gpuByIdx[g.Index] = g
-		}
-		for _, idx := range gpuIndices {
-			g := gpuByIdx[idx]
-			throttled := 0
-			if g.Throttled {
-				throttled = 1
-			}
-			fmt.Fprintf(&b, ",%.1f,%.1f,%.1f,%.0f,%d",
-				g.TempC, g.UsagePct, g.PowerW, g.ClockMHz, throttled)
-		}
-		b.WriteRune('\n')
-	}
-
-	return os.WriteFile(path, []byte(b.String()), 0644)
-}
-
-// WriteFanSensorsCSV writes individual fan sensor readings in long (tidy) format.
-func WriteFanSensorsCSV(path string, rows []FanStressRow) error {
-	var b strings.Builder
-	b.WriteString("timestamp_utc,elapsed_sec,phase,fan_name,rpm\n")
-	for _, row := range rows {
-		for _, f := range row.Fans {
-			fmt.Fprintf(&b, "%s,%.1f,%s,%s,%.0f\n",
-				row.TimestampUTC, row.ElapsedSec, row.Phase, f.Name, f.RPM)
-		}
-	}
-	return os.WriteFile(path, []byte(b.String()), 0644)
-}
-
 // fanRPMStats computes average, min, max RPM across all fans in a sample row.
 func fanRPMStats(fans []FanReading) (avg, min, max float64) {
 	if len(fans) == 0 {
diff --git a/audit/internal/webui/page_topo_diagram.go b/audit/internal/webui/page_topo_diagram.go
index 9a0af7c..71bbf22 100644
--- a/audit/internal/webui/page_topo_diagram.go
+++ b/audit/internal/webui/page_topo_diagram.go
@@ -614,10 +614,10 @@ func renderTopoMainDiagram(hw schema.HardwareSnapshot, exportDir string) string
 		}}))
 	}
 
-	// Cooling fans — one small square per fan (no PCIe/CPU affinity, arbitrary
-	// count, so a wrapping flex row like PSUs rather than SVG boxes). Each
-	// square is sized by rpm / observed-max-rpm and carries a fan glyph that
-	// spins via CSS — faster when the fan is spinning faster.
+	// Cooling fans — one small clickable square per fan (no PCIe/CPU affinity,
+	// arbitrary count, so a wrapping flex row like PSUs rather than SVG boxes).
+	// Square SIZE encodes the fan's ceiling RPM (its class); the coloured FILL
+	// rising from the bottom encodes live duty cycle (current / ceiling).
 	if fans := dedupeFansByName(hw.Sensors); len(fans) > 0 {
 		current := map[string]float64{}
 		for _, f := range fans {
@@ -625,26 +625,28 @@ func renderTopoMainDiagram(hw schema.HardwareSnapshot, exportDir string) string
 				current[strings.TrimSpace(f.Name)] = float64(*f.RPM)
 			}
 		}
-		b.WriteString(renderTopoFanRow(fans, platform.ResolveFanMaxRPM(current)))
+		b.WriteString(renderTopoFanRow(fans, platform.ResolveFanMaxRPM(current), platform.ObservedFanMaxRPM()))
 	}
 
 	return topoCard("Topology", b.String())
 }
 
-// renderTopoFanRow renders the COOLING row: one clickable square per fan,
-// side length scaled by rpm/maxRPM and a fan glyph whose spin rate tracks the
-// same ratio. maxByName comes from platform.ResolveFanMaxRPM — it already has
-// an entry for every fan (persisted peak, else peer peak, else current RPM),
-// so no fallback logic lives here.
-func renderTopoFanRow(fans []schema.HardwareFanSensor, maxByName map[string]float64) string {
+// renderTopoFanRow renders the COOLING row. ceilByName (from
+// platform.ResolveFanMaxRPM) has a value for every fan and drives tile size.
+// observedByName (from platform.ObservedFanMaxRPM) holds only ceilings that
+// were actually measured under load — a fan present there gets a duty-cycle
+// fill; one that isn't shows no fill (ceiling not measured yet).
+func renderTopoFanRow(fans []schema.HardwareFanSensor, ceilByName, observedByName map[string]float64) string {
 	const (
-		fanTileMin = 30 // px, a stalled / slowest fan
-		fanTileMax = 58 // px, a fan at its ceiling
+		fanTileMin = 34 // px, the smallest-ceiling fan
+		fanTileMax = 60 // px, the largest-ceiling fan
 	)
 
-	var tally topoStatusTally
-	for _, f := range fans {
-		tally.add(classifyTopoSeverity(f.Status))
+	ceilMax := 0.0
+	for _, v := range ceilByName {
+		if v > ceilMax {
+			ceilMax = v
+		}
 	}
 
 	var b strings.Builder
@@ -653,54 +655,84 @@ func renderTopoFanRow(fans []schema.HardwareFanSensor, maxByName map[string]floa
 	b.WriteString(`<div style="display:flex;flex-wrap:wrap;gap:6px;align-items:flex-end">`)
 	for _, f := range fans {
 		name := strings.TrimSpace(f.Name)
-		fill, stroke, text := topoSeverityColors(classifyTopoSeverity(f.Status))
+		_, stroke, text := topoSeverityColors(classifyTopoSeverity(f.Status))
+		ceil := ceilByName[name]
 
-		denom := maxByName[name]
-		ratio := 0.0
-		title := name
-		if f.RPM != nil {
-			if denom > 0 {
-				ratio = float64(*f.RPM) / denom
+		sizeRatio := 1.0
+		if ceilMax > 0 && ceil > 0 {
+			sizeRatio = ceil / ceilMax
+		}
+		side := fanTileMin + int(float64(fanTileMax-fanTileMin)*sizeRatio+0.5)
+		glyphSz := side * 7 / 16
+
+		// Duty cycle: only when the ceiling was actually measured under load.
+		duty := -1.0
+		if _, measured := observedByName[name]; measured && ceil > 0 && f.RPM != nil {
+			duty = float64(*f.RPM) / ceil * 100
+			if duty < 0 {
+				duty = 0
 			}
-			if ratio < 0 {
-				ratio = 0
+			if duty > 100 {
+				duty = 100
 			}
-			if ratio > 1 {
-				ratio = 1
-			}
-			if denom > float64(*f.RPM) {
-				title = fmt.Sprintf("%s · %d RPM (max %d)", name, *f.RPM, int(denom))
-			} else {
-				title = fmt.Sprintf("%s · %d RPM", name, *f.RPM)
-			}
-		} else {
-			title = name + " · no reading"
 		}
 
-		side := fanTileMin + int(float64(fanTileMax-fanTileMin)*ratio+0.5)
-		// Spin period: 2.6s at rest down to 0.5s at the observed peak. A fan
-		// with no reading doesn't spin.
-		spin := ""
+		title := name
+		switch {
+		case f.RPM == nil:
+			title = name + " · no reading"
+		case duty >= 0:
+			title = fmt.Sprintf("%s · %d RPM · %.0f%% duty (ceiling %d)", name, *f.RPM, duty, int(ceil))
+		default:
+			title = fmt.Sprintf("%s · %d RPM · ceiling not measured — run Fan Ceiling Check", name, *f.RPM)
+		}
+
+		glyph := fmt.Sprintf(`<svg width="%d" height="%d" viewBox="0 0 24 24" fill="currentColor" style="opacity:.35" aria-hidden="true">`, glyphSz, glyphSz) + topoFanGlyphPaths() + `</svg>`
 		if f.RPM != nil && *f.RPM > 0 {
-			period := 2.6 - 2.1*ratio
-			spin = fmt.Sprintf(`<svg class="topo-fan-spin" style="animation-duration:%.2fs" width="%d" height="%d" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">`,
-				period, side*7/16, side*7/16) + topoFanGlyphPaths() + `</svg>`
-		} else {
-			spin = fmt.Sprintf(`<svg width="%d" height="%d" viewBox="0 0 24 24" fill="currentColor" style="opacity:.4" aria-hidden="true">`,
-				side*7/16, side*7/16) + topoFanGlyphPaths() + `</svg>`
+			period := fanSpinPeriodSec(float64(*f.RPM))
+			glyph = fmt.Sprintf(`<svg class="topo-fan-spin" style="animation-duration:%.2fs" width="%d" height="%d" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">`,
+				period, glyphSz, glyphSz) + topoFanGlyphPaths() + `</svg>`
+		}
+
+		fillBar := ""
+		if duty >= 0 {
+			fillBar = fmt.Sprintf(`<div style="position:absolute;left:0;right:0;bottom:0;height:%.0f%%;background:%s;opacity:.55"></div>`, duty, stroke)
 		}
 
 		fmt.Fprintf(&b, `<div title="%s" onclick="openComponentDetail('fan')" `+
-			`style="width:%dpx;height:%dpx;display:flex;align-items:center;justify-content:center;`+
-			`border-radius:5px;background:%s;border:1px solid %s;color:%s;cursor:pointer">%s</div>`,
-			html.EscapeString(title), side, side, fill, stroke, text, spin)
+			`style="position:relative;overflow:hidden;width:%dpx;height:%dpx;display:flex;align-items:center;justify-content:center;`+
+			`border-radius:5px;background:var(--surface-2);border:1px solid %s;color:%s;cursor:pointer">`+
+			`%s<span style="position:relative;display:flex">%s</span></div>`,
+			html.EscapeString(title), side, side, stroke, text, fillBar, glyph)
 	}
 	b.WriteString(`</div>`)
-	fmt.Fprintf(&b, `<div style="font-size:11px;color:var(--muted);margin-top:6px">%d fans · %s · tile size ∝ RPM / observed max</div>`,
-		len(fans), html.EscapeString(tally.line()))
 	return b.String()
 }
 
+// fanSpinPeriodSec maps an absolute fan RPM to a CSS animation period (one
+// full turn of the glyph, in seconds). The real period would be 60/RPM — a
+// blur at any real fan speed — so it is compressed into a band the eye can
+// actually read: at/below fanSpinRPMLo the glyph turns at its slowest still
+// clearly-moving rate, at/above fanSpinRPMHi at the fastest rate past which
+// faster is indistinguishable (and starts to stutter), linear in between.
+func fanSpinPeriodSec(rpm float64) float64 {
+	const (
+		fanSpinRPMLo   = 1000.0
+		fanSpinRPMHi   = 13000.0
+		fanSpinSlowSec = 2.2
+		fanSpinFastSec = 0.35
+	)
+	switch {
+	case rpm <= fanSpinRPMLo:
+		return fanSpinSlowSec
+	case rpm >= fanSpinRPMHi:
+		return fanSpinFastSec
+	default:
+		t := (rpm - fanSpinRPMLo) / (fanSpinRPMHi - fanSpinRPMLo)
+		return fanSpinSlowSec + t*(fanSpinFastSec-fanSpinSlowSec)
+	}
+}
+
 // topoFanSpinStyle emits the keyframes + base class for the spinning fan
 // glyph once per row. A repeated identical <style> is harmless.
 func topoFanSpinStyle() string {
diff --git a/audit/internal/webui/page_topo_test.go b/audit/internal/webui/page_topo_test.go
index 7d011b9..acf908e 100644
--- a/audit/internal/webui/page_topo_test.go
+++ b/audit/internal/webui/page_topo_test.go
@@ -202,8 +202,9 @@ func TestTopoPageRendersCoolingFansAsFlexRow(t *testing.T) {
 	if !strings.Contains(body, "FAN1 · 4200 RPM") || !strings.Contains(body, "FAN2 · 15000 RPM") {
 		t.Fatalf("topo page missing per-fan RPM tooltips: %s", body)
 	}
-	if !strings.Contains(body, "2 fans") {
-		t.Fatalf("topo page missing fan count caption: %s", body)
+	// No observed ceiling in this test → tiles show no duty fill and say so.
+	if !strings.Contains(body, "ceiling not measured") {
+		t.Fatalf("topo fan tooltip should note the ceiling is unmeasured: %s", body)
 	}
 
 	// Component-detail fallback endpoint must resolve the "fan" type.
@@ -217,6 +218,23 @@ func TestTopoPageRendersCoolingFansAsFlexRow(t *testing.T) {
 	}
 }
 
+func TestFanSpinPeriodSec(t *testing.T) {
+	// Clamped at both ends; monotonically faster (smaller period) with RPM.
+	if got := fanSpinPeriodSec(200); got != 2.2 {
+		t.Fatalf("low RPM: got %v want 2.2 (slowest visible)", got)
+	}
+	if got := fanSpinPeriodSec(25000); got != 0.35 {
+		t.Fatalf("high RPM: got %v want 0.35 (fastest visible)", got)
+	}
+	mid := fanSpinPeriodSec(7000)
+	if mid <= 0.35 || mid >= 2.2 {
+		t.Fatalf("mid RPM period %v out of band", mid)
+	}
+	if fanSpinPeriodSec(10000) >= fanSpinPeriodSec(3000) {
+		t.Fatalf("higher RPM must spin faster (shorter period)")
+	}
+}
+
 func TestTopoPageRendersStorageDisksGroupedByType(t *testing.T) {
 	dir := t.TempDir()
 	path := filepath.Join(dir, "audit.json")
diff --git a/audit/internal/webui/page_validate.go b/audit/internal/webui/page_validate.go
index 45f802c..ac735df 100644
--- a/audit/internal/webui/page_validate.go
+++ b/audit/internal/webui/page_validate.go
@@ -117,9 +117,9 @@ func renderValidateMode(opts HandlerOptions, stressDefault bool) string {
 			)) +
 			renderSATCard("fan", "Fan Ceiling Check", "runSAT('fan')", "", renderValidateCardBody(
 				"All system fans reported over IPMI / lm-sensors.",
-				`Drives CPU (+memory) and, when a GPU is present, GPU load to 100% at the same time and watches every fan until none has climbed for ~1 min. The peak RPM reached is recorded as each fan's ceiling and is what the Topology view sizes the fan tiles against. Success once every fan plateaus (or the time cap is hit). A fan reading 0 RPM or an IPMI status of cr/nr under full load fails. If the host cannot be loaded at all, or exposes no fan sensors, the task is cancelled as "not applicable" rather than failed — the platform does not support forcing fans, so this is the closest safe equivalent.`,
-				`<code>stressapptest</code> / <code>stress-ng</code> + <code>bee-gpu-burn</code> / <code>rvs gst</code>; <code>ipmitool sdr type Fan</code>`,
-				`~2–8 min depending on how fast the fan curve settles (hard cap 15 min).`,
+				`Drives CPU (+memory) and, when a GPU is present, the hottest sustained GPU load (dcgmproftester targeted-power — the Power/Thermal Fit engine) at the same time, and watches every fan until none has climbed for ~1 min. The peak RPM reached is recorded as each fan's ceiling and is what the Topology view sizes the fan tiles and duty-cycle fill against. Success once every fan plateaus (or the time cap is hit). A fan reading 0 RPM or an IPMI status of cr/nr under full load fails. IPMI polling backs off automatically if the BMC gets slow under load. If the host cannot be loaded at all, or exposes no fan sensors, the task is cancelled as "not applicable" rather than failed — the platform does not support forcing fans, so this is the closest safe equivalent.`,
+				`<code>stressapptest</code> / <code>stress-ng</code> + <code>dcgmproftester -t 1004</code> / <code>rvs gst</code>; <code>ipmitool sdr type Fan</code>`,
+				`~3–10 min depending on how fast the fan curve settles (hard cap 15 min).`,
 			))
 	}
 
diff --git a/bible-local/README.md b/bible-local/README.md
index d0f1d4f..b39f46e 100644
--- a/bible-local/README.md
+++ b/bible-local/README.md
@@ -76,7 +76,7 @@ Generic engineering rules live in `bible/rules/patterns/`.
 - GPU bandwidth check
   - `dcgmi diag -r nvbandwidth` (per CPU socket, then all selected GPUs, on multi-socket systems -- see `decisions/2026-07-27-nvbandwidth-per-socket-split.md`)
 - Fan ceiling check (Load tier / `3. Load` only)
-  - `stressapptest` (or `stress-ng`) + `bee-gpu-burn` / `rvs gst` at 100%, run simultaneously
-  - `ipmitool sdr type Fan` sampled 1 Hz until every fan plateaus (~1 min flat) or the 15 min cap
-  - records each fan's observed peak RPM to `/var/log/bee-sat/fan-observation.json` (used by the Topology fan tiles); FAIL only on a fan at 0 RPM / IPMI cr-nr under load; **cancelled ("not applicable")**, never failed, if the host cannot be loaded or has no fan sensors
+  - `stressapptest` (or `stress-ng`) + the hottest GPU load — `dcgmproftester -t 1004` / `targeted_power` (Power/Thermal Fit engine), **not** `bee-gpu-burn` — run simultaneously
+  - `ipmitool sdr type Fan` on an adaptive interval (1 s floor, backs off to 30 s when the BMC gets slow, every read time-boxed) until every fan plateaus (~1 min flat, only trusted while telemetry is healthy) or the 15 min cap
+  - records each fan's observed peak RPM to the fan-observation store (used by the Topology fan tiles: size ∝ ceiling, fill ∝ duty cycle); FAIL only on a fan at 0 RPM / IPMI cr-nr under load; **cancelled ("not applicable")**, never failed, if the host cannot be loaded or has no fan sensors
   - see `decisions/2026-09-04-fan-ceiling-check.md`
diff --git a/bible-local/decisions/2026-09-04-fan-ceiling-check.md b/bible-local/decisions/2026-09-04-fan-ceiling-check.md
index 9bbdca5..5dc0619 100644
--- a/bible-local/decisions/2026-09-04-fan-ceiling-check.md
+++ b/bible-local/decisions/2026-09-04-fan-ceiling-check.md
@@ -29,14 +29,30 @@ resulting RPM — does not work on our current platform:
 The `fan` SAT test (`platform.RunFanCheck`, formerly the unwired
 `RunFanStressTest`) drives load, not the BMC:
 
-1. Start `stressapptest` (CPU + memory) and, when a GPU is present, a GPU burn
-   (`bee-gpu-burn` / `rvs gst`) **simultaneously**, each in its own goroutine.
+1. Start `stressapptest` (CPU + memory) and, when a GPU is present, the
+   **hottest sustained GPU load** — `dcgmproftester -t 1004` /
+   `targeted_power`, via `resolveBenchmarkPowerLoadCommand`, the same engine
+   Power/Thermal Fit uses — **simultaneously**, each in its own goroutine.
+   NOT `bee-gpu-burn`: that is a compute-throughput burn that tops out around
+   88% of TDP (measured ~525 W of 600 W on RTX PRO 6000 Blackwell) and never
+   makes the fans demand their true ceiling. A first run on the MSI stand with
+   `bee-gpu-burn` peaked F2U fans at 24 400 RPM vs a historical 26 000.
    A missing GPU is not an error — CPU/memory load alone exercises the cooling
    loop. Load sources reach full power at different times, so the plateau clock
    only starts once every launched source reports its process running (plus a
    fixed GPU ramp grace).
-2. Sample every fan once a second. Per fan, track the peak RPM and the last time
-   it climbed by more than `PlateauDeltaRPM` (default 50).
+2. Sample every fan on an adaptive interval (floor 1 s). Each read is
+   time-boxed (`readFansBounded` — a goroutine abandoned on timeout, so a
+   KCS-wedged `ipmitool` can never block the loop); when reads are slow the
+   interval backs off geometrically to 30 s and tightens again when they
+   recover. Under 8-GPU + CPU load on the MSI stand, `ipmitool sdr type Fan`
+   took ~14 s/call and at one point wedged for minutes — without this the
+   "1 Hz" sampler silently degraded to one sample per 14 s and the plateau
+   timer ran on stale data. A plateau is only declared while telemetry is
+   healthy (interval near the floor, ≥5 recent samples); a degraded run just
+   rides out to `MaxLoadSec` and records the peak it saw. Per fan, track the
+   peak RPM and the last time it climbed by more than `PlateauDeltaRPM`
+   (default 50).
 3. When no fan has climbed for `PlateauHoldSec` (default 60 s) and at least one
    fan rose meaningfully above baseline, declare the ceiling found and stop —
    **success**. `MaxLoadSec` (default 900 s) is a hard cap; hitting it is also

From d8b05069e0db3db882e6f03cedb535399a6a8ea3 Mon Sep 17 00:00:00 2001
From: Mikhail Chusavitin <mchusavitin@mchusmbp.local>
Date: Fri, 4 Sep 2026 11:43:41 +0300
Subject: [PATCH 4/9] fix(webui): move Fan Ceiling Check to the
 CPU/Memory/Storage row
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

It is a platform cooling test (CPU + memory always; GPU only as extra
heat when present), not a GPU test — so it belongs with the other
whole-box checks, not in the NVIDIA section. Still Load-page only, via
the new renderLoadOnlySATCard (inverse of renderCheckOnlySATCard).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019VHG21rgTUiR1G3qFHTVmN
---
 audit/internal/webui/page_validate.go | 26 ++++++++++++++++++++------
 1 file changed, 20 insertions(+), 6 deletions(-)

diff --git a/audit/internal/webui/page_validate.go b/audit/internal/webui/page_validate.go
index ac735df..4fcd370 100644
--- a/audit/internal/webui/page_validate.go
+++ b/audit/internal/webui/page_validate.go
@@ -114,15 +114,19 @@ func renderValidateMode(opts HandlerOptions, stressDefault bool) string {
 				`Tests power supply transient response by pulsing all GPUs simultaneously between idle and full load. Synchronous pulses across all GPUs create worst-case PSU load spikes — running per-GPU would miss PSU-level failures.`,
 				`<code>dcgmi diag pulse_test</code>`,
 				validateFmtDur(platform.SATEstimatedNvidiaPulseTestSec)+` (all GPUs simultaneously; measured on 8-GPU system).`,
-			)) +
-			renderSATCard("fan", "Fan Ceiling Check", "runSAT('fan')", "", renderValidateCardBody(
-				"All system fans reported over IPMI / lm-sensors.",
-				`Drives CPU (+memory) and, when a GPU is present, the hottest sustained GPU load (dcgmproftester targeted-power — the Power/Thermal Fit engine) at the same time, and watches every fan until none has climbed for ~1 min. The peak RPM reached is recorded as each fan's ceiling and is what the Topology view sizes the fan tiles and duty-cycle fill against. Success once every fan plateaus (or the time cap is hit). A fan reading 0 RPM or an IPMI status of cr/nr under full load fails. IPMI polling backs off automatically if the BMC gets slow under load. If the host cannot be loaded at all, or exposes no fan sensors, the task is cancelled as "not applicable" rather than failed — the platform does not support forcing fans, so this is the closest safe equivalent.`,
-				`<code>stressapptest</code> / <code>stress-ng</code> + <code>dcgmproftester -t 1004</code> / <code>rvs gst</code>; <code>ipmitool sdr type Fan</code>`,
-				`~3–10 min depending on how fast the fan curve settles (hard cap 15 min).`,
 			))
 	}
 
+	// Fan Ceiling Check is a platform cooling test (CPU/memory always, GPU only
+	// as extra heat when present), so it sits with CPU/Memory/Storage, not in
+	// the NVIDIA section. Load page only.
+	fanCard := renderLoadOnlySATCard(stressDefault, renderSATCard("fan", "Fan Ceiling Check", "runSAT('fan')", "", renderValidateCardBody(
+		"All system fans reported over IPMI / lm-sensors.",
+		`Drives CPU (+memory) and, when a GPU is present, the hottest sustained GPU load (dcgmproftester targeted-power — the Power/Thermal Fit engine) at the same time, and watches every fan until none has climbed for ~1 min. The peak RPM reached is recorded as each fan's ceiling and is what the Topology view sizes the fan tiles and duty-cycle fill against. Success once every fan plateaus (or the time cap is hit). A fan reading 0 RPM or an IPMI status of cr/nr under full load fails. IPMI polling backs off automatically if the BMC gets slow under load. If the host cannot be loaded at all, or exposes no fan sensors, the task is cancelled as "not applicable" rather than failed — the platform does not support forcing fans, so this is the closest safe equivalent.`,
+		`<code>stressapptest</code> / <code>stress-ng</code> + <code>dcgmproftester -t 1004</code> / <code>rvs gst</code>; <code>ipmitool sdr type Fan</code>`,
+		`~3–10 min depending on how fast the fan curve settles (hard cap 15 min).`,
+	)))
+
 	satStressModeJS := "function satStressMode() { return false; }"
 	if stressDefault {
 		satStressModeJS = "function satStressMode() { return true; }"
@@ -161,6 +165,7 @@ func renderValidateMode(opts HandlerOptions, stressDefault bool) string {
 			`<code>tpm2_getcap properties-fixed</code>, <code>tpm2_getcap pcrs</code>, <code>tpm2_pcrread</code>, <code>tpm2_gettestresult</code>`,
 			`Seconds - read-only queries; no ownership, NV, PCR, or key changes.`,
 		))) +
+		fanCard +
 		`</div>
 <div style="height:1px;background:var(--border);margin:16px 0"></div>
 <div class="card" style="margin-bottom:16px">
@@ -621,6 +626,15 @@ func renderCheckOnlySATCard(stressMode bool, card string) string {
 	return card
 }
 
+// renderLoadOnlySATCard is the inverse of renderCheckOnlySATCard: the card
+// shows only on the Load page (a sustained-load test, not a Check-tier one).
+func renderLoadOnlySATCard(stressMode bool, card string) string {
+	if !stressMode {
+		return ""
+	}
+	return card
+}
+
 // renderCheck renders the non-destructive Check page (step 2).
 // Shows validate-mode tests only: CPU, Memory, Storage, NVIDIA L2, NCCL, NVBandwidth, AMD.
 // Stress-mode tests (targeted-stress, targeted-power, pulse) are on the Load page.

From a4853a0a4f8430859621cab7f1ccfc0abf8777a1 Mon Sep 17 00:00:00 2001
From: Mikhail Chusavitin <mchusavitin@mchusmbp.local>
Date: Fri, 4 Sep 2026 12:09:37 +0300
Subject: [PATCH 5/9] feat(webui): live-update topology fan tiles without a
 page reload
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Each fan tile carries data-fan / data-ceil / data-measured and a small
script polls /api/metrics/latest every 5s — the metrics collector's own
sampling period, served from memory with no extra BMC call — updating
each tile's spin rate, duty fill and tooltip in place. Polling faster
would only re-read identical numbers; sampling the BMC faster would
choke it under load. FanReading gains json tags for the endpoint.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019VHG21rgTUiR1G3qFHTVmN
---
 audit/internal/platform/sat_fan_stress.go |  4 +-
 audit/internal/webui/page_topo_diagram.go | 46 +++++++++++++++++++++--
 audit/internal/webui/page_topo_test.go    |  7 ++++
 3 files changed, 51 insertions(+), 6 deletions(-)

diff --git a/audit/internal/platform/sat_fan_stress.go b/audit/internal/platform/sat_fan_stress.go
index ccaf30d..5639b30 100644
--- a/audit/internal/platform/sat_fan_stress.go
+++ b/audit/internal/platform/sat_fan_stress.go
@@ -32,8 +32,8 @@ type FanCheckOptions struct {
 
 // FanReading holds one fan sensor reading.
 type FanReading struct {
-	Name string
-	RPM  float64
+	Name string  `json:"name"`
+	RPM  float64 `json:"rpm"`
 }
 
 type cachedPowerReading struct {
diff --git a/audit/internal/webui/page_topo_diagram.go b/audit/internal/webui/page_topo_diagram.go
index 71bbf22..96eae8f 100644
--- a/audit/internal/webui/page_topo_diagram.go
+++ b/audit/internal/webui/page_topo_diagram.go
@@ -694,21 +694,59 @@ func renderTopoFanRow(fans []schema.HardwareFanSensor, ceilByName, observedByNam
 				period, glyphSz, glyphSz) + topoFanGlyphPaths() + `</svg>`
 		}
 
-		fillBar := ""
+		measured := 0
+		fillH := 0.0
 		if duty >= 0 {
-			fillBar = fmt.Sprintf(`<div style="position:absolute;left:0;right:0;bottom:0;height:%.0f%%;background:%s;opacity:.55"></div>`, duty, stroke)
+			measured = 1
+			fillH = duty
 		}
+		fillBar := fmt.Sprintf(`<div class="topo-fan-fill" style="position:absolute;left:0;right:0;bottom:0;height:%.0f%%;background:%s;opacity:.55;transition:height .8s linear"></div>`, fillH, stroke)
 
-		fmt.Fprintf(&b, `<div title="%s" onclick="openComponentDetail('fan')" `+
+		fmt.Fprintf(&b, `<div class="topo-fan-tile" data-fan="%s" data-ceil="%d" data-measured="%d" title="%s" onclick="openComponentDetail('fan')" `+
 			`style="position:relative;overflow:hidden;width:%dpx;height:%dpx;display:flex;align-items:center;justify-content:center;`+
 			`border-radius:5px;background:var(--surface-2);border:1px solid %s;color:%s;cursor:pointer">`+
 			`%s<span style="position:relative;display:flex">%s</span></div>`,
-			html.EscapeString(title), side, side, stroke, text, fillBar, glyph)
+			html.EscapeString(name), int(ceil), measured, html.EscapeString(title),
+			side, side, stroke, text, fillBar, glyph)
 	}
 	b.WriteString(`</div>`)
+	b.WriteString(topoFanLiveScript())
 	return b.String()
 }
 
+// topoFanLiveScript polls the already-collected live-metrics snapshot
+// (/api/metrics/latest — served from memory, no BMC call) every 5s and
+// updates each fan tile's spin rate, duty fill and tooltip in place. 5s is
+// the metrics collector's own sampling period, so polling faster would only
+// re-read identical numbers; the endpoint is a mutex read + small JSON, so
+// this is cheap even with many viewers.
+func topoFanLiveScript() string {
+	return `<script>(function(){
+  var tiles=document.querySelectorAll('.topo-fan-tile');
+  if(!tiles.length)return;
+  function period(rpm){var lo=1000,hi=13000,slow=2.2,fast=0.35;
+    if(rpm<=lo)return slow;if(rpm>=hi)return fast;
+    return slow+(rpm-lo)/(hi-lo)*(fast-slow);}
+  function tick(){
+    fetch('/api/metrics/latest',{cache:'no-store'}).then(function(r){return r.json();}).then(function(m){
+      if(!m||!m.fans)return;
+      var by={};m.fans.forEach(function(f){by[f.name]=f.rpm;});
+      tiles.forEach(function(t){
+        var rpm=by[t.dataset.fan];if(rpm==null)return;
+        var ceil=parseFloat(t.dataset.ceil)||0;
+        var svg=t.querySelector('.topo-fan-spin');
+        if(svg&&rpm>0)svg.style.animationDuration=period(rpm).toFixed(2)+'s';
+        var meas=t.dataset.measured==='1'&&ceil>0;
+        var duty=meas?Math.max(0,Math.min(100,rpm/ceil*100)):-1;
+        if(meas){var fill=t.querySelector('.topo-fan-fill');if(fill)fill.style.height=duty.toFixed(0)+'%';}
+        t.title=t.dataset.fan+' · '+Math.round(rpm)+' RPM'+(meas?' · '+Math.round(duty)+'% duty (ceiling '+ceil+')':' · ceiling not measured — run Fan Ceiling Check');
+      });
+    }).catch(function(){});
+  }
+  setInterval(tick,5000);tick();
+})();</script>`
+}
+
 // fanSpinPeriodSec maps an absolute fan RPM to a CSS animation period (one
 // full turn of the glyph, in seconds). The real period would be 60/RPM — a
 // blur at any real fan speed — so it is compressed into a band the eye can
diff --git a/audit/internal/webui/page_topo_test.go b/audit/internal/webui/page_topo_test.go
index acf908e..c0df23f 100644
--- a/audit/internal/webui/page_topo_test.go
+++ b/audit/internal/webui/page_topo_test.go
@@ -206,6 +206,13 @@ func TestTopoPageRendersCoolingFansAsFlexRow(t *testing.T) {
 	if !strings.Contains(body, "ceiling not measured") {
 		t.Fatalf("topo fan tooltip should note the ceiling is unmeasured: %s", body)
 	}
+	// Live-update: each tile is addressable and the poll script is present.
+	if n := strings.Count(body, `class="topo-fan-tile"`); n != 2 {
+		t.Fatalf("expected 2 addressable fan tiles, got %d", n)
+	}
+	if !strings.Contains(body, `data-fan="FAN1"`) || !strings.Contains(body, "/api/metrics/latest") {
+		t.Fatalf("topo fan row missing live-update wiring: %s", body)
+	}
 
 	// Component-detail fallback endpoint must resolve the "fan" type.
 	rec2 := httptest.NewRecorder()

From 59271fa67414d7695cb1995c25157e2f5d6043e5 Mon Sep 17 00:00:00 2001
From: Mikhail Chusavitin <mchusavitin@mchusmbp.local>
Date: Fri, 4 Sep 2026 12:32:56 +0300
Subject: [PATCH 6/9] feat(webui): break the topology PSU row into one card per
 supply
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Each PSU is its own card, coloured by its own status — a failed unit
goes red on its own instead of dragging a single grouped card down —
and shows input voltage + draw (measured output/input, else nameplate
rating). Cards click through to the PSU detail modal and carry data-psu
so the shared topoLiveScript refreshes their wattage from
/api/metrics/latest on the same 5s poll as the fan tiles.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019VHG21rgTUiR1G3qFHTVmN
---
 audit/internal/webui/page_topo_diagram.go | 150 +++++++++++++++-------
 audit/internal/webui/page_topo_test.go    |  29 +++--
 2 files changed, 125 insertions(+), 54 deletions(-)

diff --git a/audit/internal/webui/page_topo_diagram.go b/audit/internal/webui/page_topo_diagram.go
index 96eae8f..6c77d57 100644
--- a/audit/internal/webui/page_topo_diagram.go
+++ b/audit/internal/webui/page_topo_diagram.go
@@ -592,33 +592,16 @@ func renderTopoMainDiagram(hw schema.HardwareSnapshot, exportDir string) string
 	}
 	b.WriteString(renderTopoFlexRow("Firmware", firmwareItems))
 
-	if len(hw.PowerSupplies) > 0 {
-		var tally topoStatusTally
-		watt := 0
-		for _, psu := range hw.PowerSupplies {
-			tally.add(classifyTopoSeverity(psu.Status))
-			if psu.WattageW != nil {
-				watt = *psu.WattageW
-			}
-		}
-		fill, stroke, text := topoSeverityColors(tally.worst())
-		sublabel := ""
-		if watt > 0 {
-			sublabel = fmt.Sprintf("%dW each", watt)
-		}
-		b.WriteString(renderTopoFlexRow("Power Supplies", []topoCardInfo{{
-			label: "Power Supplies", sublabel: sublabel, count: len(hw.PowerSupplies),
-			statusLine: tally.line(),
-			fillVar:    fill, strokeVar: stroke, textVar: text,
-			detailType: "psu",
-		}}))
+	hasPSU := len(hw.PowerSupplies) > 0
+	if hasPSU {
+		b.WriteString(renderTopoPSURow(hw.PowerSupplies))
 	}
 
-	// Cooling fans — one small clickable square per fan (no PCIe/CPU affinity,
-	// arbitrary count, so a wrapping flex row like PSUs rather than SVG boxes).
-	// Square SIZE encodes the fan's ceiling RPM (its class); the coloured FILL
-	// rising from the bottom encodes live duty cycle (current / ceiling).
-	if fans := dedupeFansByName(hw.Sensors); len(fans) > 0 {
+	// Cooling fans — one small clickable square per fan. Square SIZE encodes
+	// the fan's ceiling RPM (its class); the coloured FILL rising from the
+	// bottom encodes live duty cycle (current / ceiling).
+	fans := dedupeFansByName(hw.Sensors)
+	if len(fans) > 0 {
 		current := map[string]float64{}
 		for _, f := range fans {
 			if f.RPM != nil {
@@ -628,9 +611,75 @@ func renderTopoMainDiagram(hw schema.HardwareSnapshot, exportDir string) string
 		b.WriteString(renderTopoFanRow(fans, platform.ResolveFanMaxRPM(current), platform.ObservedFanMaxRPM()))
 	}
 
+	if hasPSU || len(fans) > 0 {
+		b.WriteString(topoLiveScript())
+	}
+
 	return topoCard("Topology", b.String())
 }
 
+// renderTopoPSURow renders the POWER SUPPLIES row: one card per PSU, coloured
+// by that PSU's own status (a failed unit goes red on its own), showing input
+// voltage and draw. Cards click through to the shared PSU detail modal and
+// carry data-psu so topoLiveScript can refresh the wattage in place.
+func renderTopoPSURow(psus []schema.HardwarePowerSupply) string {
+	var b strings.Builder
+	b.WriteString(topoRowHeading("Power Supplies"))
+	b.WriteString(`<div style="display:flex;flex-wrap:wrap;gap:8px">`)
+	for i, p := range psus {
+		sev := classifyTopoSeverity(p.Status)
+		fill, stroke, text := topoSeverityColors(sev)
+
+		label := fmt.Sprintf("PSU %d", i)
+		if p.Slot != nil && strings.TrimSpace(*p.Slot) != "" {
+			label = strings.TrimSpace(*p.Slot)
+		}
+
+		var parts []string
+		if p.InputVoltage != nil && *p.InputVoltage > 0 {
+			parts = append(parts, fmt.Sprintf("%.0f V", *p.InputVoltage))
+		}
+		if w := psuWatts(p); w != "" {
+			parts = append(parts, w)
+		}
+		detail := strings.Join(parts, " · ")
+
+		statusWord := ""
+		if sev >= 2 {
+			statusWord = topoSeverityStatus(p.Status)
+		}
+
+		fmt.Fprintf(&b, `<div class="topo-psu-tile" data-psu="%d" onclick="openComponentDetail('psu')" `+
+			`style="cursor:pointer;min-width:96px;padding:8px 11px;border-radius:6px;background:%s;border:1px solid %s;color:%s">`+
+			`<div style="font-size:13px;font-weight:700">%s</div>`,
+			i, fill, stroke, text, html.EscapeString(label))
+		if detail != "" {
+			fmt.Fprintf(&b, `<div class="topo-psu-detail" style="font-size:11px;opacity:.85;margin-top:2px">%s</div>`, html.EscapeString(detail))
+		}
+		if statusWord != "" {
+			fmt.Fprintf(&b, `<div style="font-size:10px;font-weight:700;margin-top:3px">%s</div>`, html.EscapeString(strings.ToUpper(statusWord)))
+		}
+		b.WriteString(`</div>`)
+	}
+	b.WriteString(`</div>`)
+	return b.String()
+}
+
+// psuWatts picks the most meaningful power figure for a PSU card: measured
+// output, else measured input, else the nameplate rating.
+func psuWatts(p schema.HardwarePowerSupply) string {
+	switch {
+	case p.OutputPowerW != nil && *p.OutputPowerW > 0:
+		return fmt.Sprintf("%.0f W", *p.OutputPowerW)
+	case p.InputPowerW != nil && *p.InputPowerW > 0:
+		return fmt.Sprintf("%.0f W", *p.InputPowerW)
+	case p.WattageW != nil && *p.WattageW > 0:
+		return fmt.Sprintf("%d W rated", *p.WattageW)
+	default:
+		return ""
+	}
+}
+
 // renderTopoFanRow renders the COOLING row. ceilByName (from
 // platform.ResolveFanMaxRPM) has a value for every fan and drives tile size.
 // observedByName (from platform.ObservedFanMaxRPM) holds only ceilings that
@@ -710,37 +759,46 @@ func renderTopoFanRow(fans []schema.HardwareFanSensor, ceilByName, observedByNam
 			side, side, stroke, text, fillBar, glyph)
 	}
 	b.WriteString(`</div>`)
-	b.WriteString(topoFanLiveScript())
 	return b.String()
 }
 
-// topoFanLiveScript polls the already-collected live-metrics snapshot
+// topoLiveScript polls the already-collected live-metrics snapshot
 // (/api/metrics/latest — served from memory, no BMC call) every 5s and
-// updates each fan tile's spin rate, duty fill and tooltip in place. 5s is
-// the metrics collector's own sampling period, so polling faster would only
-// re-read identical numbers; the endpoint is a mutex read + small JSON, so
-// this is cheap even with many viewers.
-func topoFanLiveScript() string {
+// refreshes the fan tiles (spin rate, duty fill, tooltip) and PSU tiles
+// (wattage) in place. 5s is the metrics collector's own sampling period, so
+// polling faster only re-reads identical numbers; the endpoint is a mutex
+// read + small JSON, so this stays cheap with many viewers.
+func topoLiveScript() string {
 	return `<script>(function(){
-  var tiles=document.querySelectorAll('.topo-fan-tile');
-  if(!tiles.length)return;
+  var fans=document.querySelectorAll('.topo-fan-tile');
+  var psus=document.querySelectorAll('.topo-psu-tile');
+  if(!fans.length&&!psus.length)return;
   function period(rpm){var lo=1000,hi=13000,slow=2.2,fast=0.35;
     if(rpm<=lo)return slow;if(rpm>=hi)return fast;
     return slow+(rpm-lo)/(hi-lo)*(fast-slow);}
   function tick(){
     fetch('/api/metrics/latest',{cache:'no-store'}).then(function(r){return r.json();}).then(function(m){
-      if(!m||!m.fans)return;
-      var by={};m.fans.forEach(function(f){by[f.name]=f.rpm;});
-      tiles.forEach(function(t){
-        var rpm=by[t.dataset.fan];if(rpm==null)return;
-        var ceil=parseFloat(t.dataset.ceil)||0;
-        var svg=t.querySelector('.topo-fan-spin');
-        if(svg&&rpm>0)svg.style.animationDuration=period(rpm).toFixed(2)+'s';
-        var meas=t.dataset.measured==='1'&&ceil>0;
-        var duty=meas?Math.max(0,Math.min(100,rpm/ceil*100)):-1;
-        if(meas){var fill=t.querySelector('.topo-fan-fill');if(fill)fill.style.height=duty.toFixed(0)+'%';}
-        t.title=t.dataset.fan+' · '+Math.round(rpm)+' RPM'+(meas?' · '+Math.round(duty)+'% duty (ceiling '+ceil+')':' · ceiling not measured — run Fan Ceiling Check');
-      });
+      if(!m)return;
+      if(m.fans){
+        var by={};m.fans.forEach(function(f){by[f.name]=f.rpm;});
+        fans.forEach(function(t){
+          var rpm=by[t.dataset.fan];if(rpm==null)return;
+          var ceil=parseFloat(t.dataset.ceil)||0;
+          var svg=t.querySelector('.topo-fan-spin');
+          if(svg&&rpm>0)svg.style.animationDuration=period(rpm).toFixed(2)+'s';
+          var meas=t.dataset.measured==='1'&&ceil>0;
+          var duty=meas?Math.max(0,Math.min(100,rpm/ceil*100)):-1;
+          if(meas){var fill=t.querySelector('.topo-fan-fill');if(fill)fill.style.height=duty.toFixed(0)+'%';}
+          t.title=t.dataset.fan+' · '+Math.round(rpm)+' RPM'+(meas?' · '+Math.round(duty)+'% duty (ceiling '+ceil+')':' · ceiling not measured — run Fan Ceiling Check');
+        });
+      }
+      if(m.psus){
+        psus.forEach(function(t){
+          var p=m.psus[parseInt(t.dataset.psu,10)];if(!p||!(p.power_w>0))return;
+          var d=t.querySelector('.topo-psu-detail');if(!d)return;
+          d.textContent=d.textContent.replace(/[\d.]+ W(?: rated)?/, Math.round(p.power_w)+' W');
+        });
+      }
     }).catch(function(){});
   }
   setInterval(tick,5000);tick();
diff --git a/audit/internal/webui/page_topo_test.go b/audit/internal/webui/page_topo_test.go
index c0df23f..64963e0 100644
--- a/audit/internal/webui/page_topo_test.go
+++ b/audit/internal/webui/page_topo_test.go
@@ -90,15 +90,22 @@ func TestTopoPageRendersArbitraryPSUAndFirmwareCountsAsFlexRows(t *testing.T) {
 	path := filepath.Join(dir, "audit.json")
 
 	okStatus := "OK"
+	failStatus := "Critical"
 	watt := 3000
+	volt := 230.0
 
 	var psus []schema.HardwarePowerSupply
 	for i := 0; i < 6; i++ {
 		slot := strconv.Itoa(i)
+		st := okStatus
+		if i == 3 {
+			st = failStatus
+		}
 		psus = append(psus, schema.HardwarePowerSupply{
-			HardwareComponentStatus: schema.HardwareComponentStatus{Status: &okStatus},
+			HardwareComponentStatus: schema.HardwareComponentStatus{Status: &st},
 			Slot:                    &slot,
 			WattageW:                &watt,
+			InputVoltage:            &volt,
 		})
 	}
 
@@ -132,14 +139,20 @@ func TestTopoPageRendersArbitraryPSUAndFirmwareCountsAsFlexRows(t *testing.T) {
 	if !strings.Contains(body, "BIOS") || !strings.Contains(body, "BMC") {
 		t.Fatalf("topo page missing BIOS/BMC firmware boxes: %s", body)
 	}
-	// All 6 PSUs must be represented, grouped into one stacked card with a
-	// count rather than 6 separate boxes.
-	if !strings.Contains(body, "Power Supplies ×6") {
-		t.Fatalf("topo page missing grouped Power Supplies x6 card: %s", body)
+	// One card per PSU (6), each clickable, each showing voltage + power.
+	if n := strings.Count(body, `class="topo-psu-tile"`); n != 6 {
+		t.Fatalf("expected 6 per-PSU cards, got %d", n)
 	}
-	if strings.Count(body, `onclick="openComponentDetail(&#39;psu&#39;)"`) != 1 &&
-		strings.Count(body, `onclick="openComponentDetail('psu')"`) != 1 {
-		t.Fatalf("expected exactly one clickable PSU group card, not one per PSU: %s", body)
+	if n := strings.Count(body, `onclick="openComponentDetail('psu')"`) +
+		strings.Count(body, `onclick="openComponentDetail(&#39;psu&#39;)"`); n != 6 {
+		t.Fatalf("expected one clickable card per PSU (6), got %d", n)
+	}
+	if !strings.Contains(body, "230 V · 3000 W rated") {
+		t.Fatalf("PSU card missing voltage/power line: %s", body)
+	}
+	// The one failed PSU is coloured red on its own (crit token) and labelled.
+	if !strings.Contains(body, "var(--crit-bg)") || !strings.Contains(body, "CRITICAL") {
+		t.Fatalf("failed PSU should render individually as critical: %s", body)
 	}
 	// Firmware/PSU rows must be flex-wrap HTML (arbitrary count, no overlap),
 	// not absolutely-positioned SVG rects sharing fixed x/y coordinates.

From e713504fc9e25a9e041b3f7f7f7a0bfc997ac059 Mon Sep 17 00:00:00 2001
From: Mikhail Chusavitin <mchusavitin@mchusmbp.local>
Date: Fri, 4 Sep 2026 12:37:59 +0300
Subject: [PATCH 7/9] feat(webui): show PSU load as a fill on the topology PSU
 card
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Same idea as the fan duty-cycle fill: a bar rising from the bottom of
each PSU card for draw / nameplate rating, live-updated on the shared
5s /api/metrics/latest poll. Drawn only when the rating (wattage_w) is
known — a raw wattage with nothing to scale against is not a load
figure, so BMCs that report only input power (e.g. this MSI stand) keep
showing the plain watts. Detail line becomes "<v> V · <draw> / <rating> W
· <n>% load" when both are present.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019VHG21rgTUiR1G3qFHTVmN
---
 audit/internal/webui/page_topo_diagram.go | 80 +++++++++++++++++------
 audit/internal/webui/page_topo_test.go    | 11 +++-
 2 files changed, 68 insertions(+), 23 deletions(-)

diff --git a/audit/internal/webui/page_topo_diagram.go b/audit/internal/webui/page_topo_diagram.go
index 6c77d57..048cdcd 100644
--- a/audit/internal/webui/page_topo_diagram.go
+++ b/audit/internal/webui/page_topo_diagram.go
@@ -628,19 +628,30 @@ func renderTopoPSURow(psus []schema.HardwarePowerSupply) string {
 	b.WriteString(`<div style="display:flex;flex-wrap:wrap;gap:8px">`)
 	for i, p := range psus {
 		sev := classifyTopoSeverity(p.Status)
-		fill, stroke, text := topoSeverityColors(sev)
+		_, stroke, text := topoSeverityColors(sev)
 
 		label := fmt.Sprintf("PSU %d", i)
 		if p.Slot != nil && strings.TrimSpace(*p.Slot) != "" {
 			label = strings.TrimSpace(*p.Slot)
 		}
 
+		draw, haveDraw := psuDrawW(p)
+		rating := 0
+		if p.WattageW != nil && *p.WattageW > 0 {
+			rating = *p.WattageW
+		}
+
 		var parts []string
 		if p.InputVoltage != nil && *p.InputVoltage > 0 {
 			parts = append(parts, fmt.Sprintf("%.0f V", *p.InputVoltage))
 		}
-		if w := psuWatts(p); w != "" {
-			parts = append(parts, w)
+		switch {
+		case haveDraw && rating > 0:
+			parts = append(parts, fmt.Sprintf("%.0f / %d W · %.0f%% load", draw, rating, draw/float64(rating)*100))
+		case haveDraw:
+			parts = append(parts, fmt.Sprintf("%.0f W", draw))
+		case rating > 0:
+			parts = append(parts, fmt.Sprintf("%d W rated", rating))
 		}
 		detail := strings.Join(parts, " · ")
 
@@ -649,34 +660,55 @@ func renderTopoPSURow(psus []schema.HardwarePowerSupply) string {
 			statusWord = topoSeverityStatus(p.Status)
 		}
 
-		fmt.Fprintf(&b, `<div class="topo-psu-tile" data-psu="%d" onclick="openComponentDetail('psu')" `+
-			`style="cursor:pointer;min-width:96px;padding:8px 11px;border-radius:6px;background:%s;border:1px solid %s;color:%s">`+
-			`<div style="font-size:13px;font-weight:700">%s</div>`,
-			i, fill, stroke, text, html.EscapeString(label))
-		if detail != "" {
-			fmt.Fprintf(&b, `<div class="topo-psu-detail" style="font-size:11px;opacity:.85;margin-top:2px">%s</div>`, html.EscapeString(detail))
+		// Load fill (draw / rating) rises from the bottom of the card, the
+		// same idea as the fan duty-cycle fill. Only drawn when the nameplate
+		// rating is known — a raw wattage with nothing to scale it against is
+		// not a load figure.
+		loadPct := -1.0
+		if haveDraw && rating > 0 {
+			loadPct = draw / float64(rating) * 100
+			if loadPct < 0 {
+				loadPct = 0
+			}
+			if loadPct > 100 {
+				loadPct = 100
+			}
 		}
+		fillH := 0.0
+		if loadPct >= 0 {
+			fillH = loadPct
+		}
+
+		voltAttr := ""
+		if p.InputVoltage != nil && *p.InputVoltage > 0 {
+			voltAttr = fmt.Sprintf("%.0f", *p.InputVoltage)
+		}
+
+		fmt.Fprintf(&b, `<div class="topo-psu-tile" data-psu="%d" data-psu-max="%d" data-psu-v="%s" onclick="openComponentDetail('psu')" `+
+			`style="position:relative;overflow:hidden;cursor:pointer;min-width:104px;padding:8px 11px;border-radius:6px;background:var(--surface-2);border:1px solid %s;color:%s">`,
+			i, rating, voltAttr, stroke, text)
+		fmt.Fprintf(&b, `<div class="topo-psu-fill" style="position:absolute;left:0;right:0;bottom:0;height:%.0f%%;background:%s;opacity:.5;transition:height .8s linear"></div>`, fillH, stroke)
+		fmt.Fprintf(&b, `<div style="position:relative"><div style="font-size:13px;font-weight:700">%s</div>`, html.EscapeString(label))
+		fmt.Fprintf(&b, `<div class="topo-psu-detail" style="font-size:11px;opacity:.9;margin-top:2px">%s</div>`, html.EscapeString(detail))
 		if statusWord != "" {
 			fmt.Fprintf(&b, `<div style="font-size:10px;font-weight:700;margin-top:3px">%s</div>`, html.EscapeString(strings.ToUpper(statusWord)))
 		}
-		b.WriteString(`</div>`)
+		b.WriteString(`</div></div>`)
 	}
 	b.WriteString(`</div>`)
 	return b.String()
 }
 
-// psuWatts picks the most meaningful power figure for a PSU card: measured
-// output, else measured input, else the nameplate rating.
-func psuWatts(p schema.HardwarePowerSupply) string {
+// psuDrawW returns the PSU's current power draw (measured output preferred,
+// else measured input).
+func psuDrawW(p schema.HardwarePowerSupply) (float64, bool) {
 	switch {
 	case p.OutputPowerW != nil && *p.OutputPowerW > 0:
-		return fmt.Sprintf("%.0f W", *p.OutputPowerW)
+		return *p.OutputPowerW, true
 	case p.InputPowerW != nil && *p.InputPowerW > 0:
-		return fmt.Sprintf("%.0f W", *p.InputPowerW)
-	case p.WattageW != nil && *p.WattageW > 0:
-		return fmt.Sprintf("%d W rated", *p.WattageW)
+		return *p.InputPowerW, true
 	default:
-		return ""
+		return 0, false
 	}
 }
 
@@ -794,9 +826,15 @@ func topoLiveScript() string {
       }
       if(m.psus){
         psus.forEach(function(t){
-          var p=m.psus[parseInt(t.dataset.psu,10)];if(!p||!(p.power_w>0))return;
-          var d=t.querySelector('.topo-psu-detail');if(!d)return;
-          d.textContent=d.textContent.replace(/[\d.]+ W(?: rated)?/, Math.round(p.power_w)+' W');
+          var p=m.psus[parseInt(t.dataset.psu,10)];if(!p)return;
+          var w=p.power_w||0,max=parseFloat(t.dataset.psuMax)||0,v=t.dataset.psuV;
+          var parts=[];
+          if(v)parts.push(v+' V');
+          if(w>0&&max>0)parts.push(Math.round(w)+' / '+max+' W · '+Math.round(w/max*100)+'% load');
+          else if(w>0)parts.push(Math.round(w)+' W');
+          else if(max>0)parts.push(max+' W rated');
+          var d=t.querySelector('.topo-psu-detail');if(d&&parts.length)d.textContent=parts.join(' · ');
+          if(w>0&&max>0){var f=t.querySelector('.topo-psu-fill');if(f)f.style.height=Math.max(0,Math.min(100,w/max*100)).toFixed(0)+'%';}
         });
       }
     }).catch(function(){});
diff --git a/audit/internal/webui/page_topo_test.go b/audit/internal/webui/page_topo_test.go
index 64963e0..185d5bf 100644
--- a/audit/internal/webui/page_topo_test.go
+++ b/audit/internal/webui/page_topo_test.go
@@ -93,6 +93,7 @@ func TestTopoPageRendersArbitraryPSUAndFirmwareCountsAsFlexRows(t *testing.T) {
 	failStatus := "Critical"
 	watt := 3000
 	volt := 230.0
+	draw := 1500.0
 
 	var psus []schema.HardwarePowerSupply
 	for i := 0; i < 6; i++ {
@@ -101,11 +102,13 @@ func TestTopoPageRendersArbitraryPSUAndFirmwareCountsAsFlexRows(t *testing.T) {
 		if i == 3 {
 			st = failStatus
 		}
+		d := draw
 		psus = append(psus, schema.HardwarePowerSupply{
 			HardwareComponentStatus: schema.HardwareComponentStatus{Status: &st},
 			Slot:                    &slot,
 			WattageW:                &watt,
 			InputVoltage:            &volt,
+			InputPowerW:             &d,
 		})
 	}
 
@@ -147,8 +150,12 @@ func TestTopoPageRendersArbitraryPSUAndFirmwareCountsAsFlexRows(t *testing.T) {
 		strings.Count(body, `onclick="openComponentDetail(&#39;psu&#39;)"`); n != 6 {
 		t.Fatalf("expected one clickable card per PSU (6), got %d", n)
 	}
-	if !strings.Contains(body, "230 V · 3000 W rated") {
-		t.Fatalf("PSU card missing voltage/power line: %s", body)
+	if !strings.Contains(body, "230 V · 1500 / 3000 W · 50% load") {
+		t.Fatalf("PSU card missing voltage / draw / load line: %s", body)
+	}
+	// Load fill (draw/rating) is drawn, same idea as the fan duty fill.
+	if !strings.Contains(body, `class="topo-psu-fill"`) || !strings.Contains(body, "height:50%") {
+		t.Fatalf("PSU card missing load fill: %s", body)
 	}
 	// The one failed PSU is coloured red on its own (crit token) and labelled.
 	if !strings.Contains(body, "var(--crit-bg)") || !strings.Contains(body, "CRITICAL") {

From 7ed652c5b1441480525e87f0bea07685d555a3c3 Mon Sep 17 00:00:00 2001
From: Mikhail Chusavitin <mchusavitin@mchusmbp.local>
Date: Fri, 4 Sep 2026 12:53:13 +0300
Subject: [PATCH 8/9] feat: autotune PSU capacity from the same full-load run
 as fan ceilings
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Extract the fan peak-tracking into observedPeakStore (observe max under
load, hold >= minHold to reject spikes, round, persist JSON) and add a
second instance for PSU draw (psu-observation.json, keyed by PSU
ordinal). Fed from samplePSUPower like fans are from sampleFanSpeeds, so
any full-load run refines it — the Fan Ceiling Check (which also samples
PSU power at a slow cadence off its loop and writes psu_<i>_peak_w), a
burn, thermal cycling, and the 5s web metrics collector.

/topo PSU cards now scale the load fill by wattage_w when the BMC
reports it, else by the observed peak draw — marked "~N% load". This
MSI stand's BMC gives only instantaneous input power, so the observed
peak is the only capacity figure available.

Fan behaviour is unchanged (tests exercise updateFanObservation /
estimateFanDutyCyclePctFromObservation / ResolveFanMaxRPM through the
new store).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019VHG21rgTUiR1G3qFHTVmN
---
 audit/internal/platform/live_metrics.go       |   4 +
 audit/internal/platform/observed_peaks.go     | 183 ++++++++++++++++++
 audit/internal/platform/sat_fan_stress.go     | 179 ++++++-----------
 .../internal/platform/sat_fan_stress_test.go  |  89 ++++++---
 audit/internal/webui/page_topo_diagram.go     |  70 ++++---
 audit/internal/webui/page_topo_test.go        |  21 ++
 .../decisions/2026-09-04-fan-ceiling-check.md |  25 ++-
 7 files changed, 396 insertions(+), 175 deletions(-)
 create mode 100644 audit/internal/platform/observed_peaks.go

diff --git a/audit/internal/platform/live_metrics.go b/audit/internal/platform/live_metrics.go
index 0fe5e6a..53a7214 100644
--- a/audit/internal/platform/live_metrics.go
+++ b/audit/internal/platform/live_metrics.go
@@ -393,5 +393,9 @@ func samplePSUPower() []PSUReading {
 	if len(psus) == 0 {
 		return nil
 	}
+	// Feed the observed-capacity store (the "autotune" for PSU load scaling on
+	// BMCs that report only instantaneous power) — every load run that samples
+	// PSU power, including the 5 s metrics collector, refines it.
+	updatePSUObservation(psus, time.Now())
 	return psus
 }
diff --git a/audit/internal/platform/observed_peaks.go b/audit/internal/platform/observed_peaks.go
new file mode 100644
index 0000000..3a0540e
--- /dev/null
+++ b/audit/internal/platform/observed_peaks.go
@@ -0,0 +1,183 @@
+package platform
+
+import (
+	"encoding/json"
+	"math"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+// observedPeakStore is the "autotune" primitive for components that expose no
+// host-readable nameplate maximum: fan top RPM, PSU capacity. It records the
+// highest value seen per key while the box is under load, persists it to a
+// JSON file, and hands it back so live readings can be scaled against a real
+// maximum. A new peak only sticks after it has been held for at least
+// minHold, which rejects transient spikes.
+type observedPeakStore struct {
+	path    string        // JSON file
+	jsonKey string        // top-level object key, e.g. "max_rpm"
+	roundUp float64       // round a new peak up to this multiple; 0 = keep raw
+	minHold time.Duration // a candidate peak must persist this long to stick
+
+	mu         sync.Mutex
+	loaded     bool
+	peaks      map[string]float64
+	candidates map[string]peakCandidate
+}
+
+type peakCandidate struct {
+	firstSeen time.Time
+	val       float64
+}
+
+// persistedPeaks reads the file fresh (no lock, no cache mutation) and returns
+// its sanitized {key -> peak} map. Empty map when the file is missing or
+// unparsable.
+func (s *observedPeakStore) persistedPeaks() map[string]float64 {
+	out := map[string]float64{}
+	raw, err := os.ReadFile(s.path)
+	if err != nil || len(raw) == 0 {
+		return out
+	}
+	var doc map[string]map[string]float64
+	if json.Unmarshal(raw, &doc) != nil {
+		return out
+	}
+	for k, v := range doc[s.jsonKey] {
+		k = strings.TrimSpace(k)
+		if k == "" || v <= 0 {
+			continue
+		}
+		out[k] = v
+	}
+	return out
+}
+
+func (s *observedPeakStore) loadLocked() {
+	if s.loaded {
+		return
+	}
+	s.loaded = true
+	s.peaks = s.persistedPeaks()
+	if s.candidates == nil {
+		s.candidates = map[string]peakCandidate{}
+	}
+}
+
+func (s *observedPeakStore) saveLocked() {
+	if len(s.peaks) == 0 {
+		return
+	}
+	dir := filepath.Dir(s.path)
+	if dir == "" || dir == "." {
+		return
+	}
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return
+	}
+	raw, err := json.MarshalIndent(map[string]map[string]float64{s.jsonKey: s.peaks}, "", "  ")
+	if err != nil {
+		return
+	}
+	_ = os.WriteFile(s.path, raw, 0644)
+}
+
+func (s *observedPeakStore) round(v float64) float64 {
+	if v <= 0 {
+		return 0
+	}
+	if s.roundUp <= 0 {
+		return v
+	}
+	return math.Ceil(v/s.roundUp) * s.roundUp
+}
+
+// observe feeds one telemetry sample (key -> current value). Non-positive
+// values and blank keys are ignored.
+func (s *observedPeakStore) observe(samples map[string]float64, now time.Time) {
+	if len(samples) == 0 {
+		return
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.loadLocked()
+	changed := false
+	for key, val := range samples {
+		key = strings.TrimSpace(key)
+		if key == "" || val <= 0 {
+			continue
+		}
+		cur := s.peaks[key]
+		if val <= cur {
+			delete(s.candidates, key)
+			continue
+		}
+		if cand, ok := s.candidates[key]; ok {
+			if now.Sub(cand.firstSeen) >= s.minHold {
+				nv := math.Max(cand.val, val)
+				if nv > cur {
+					s.peaks[key] = s.round(nv)
+					changed = true
+				}
+				delete(s.candidates, key)
+				continue
+			}
+			if val > cand.val {
+				s.candidates[key] = peakCandidate{firstSeen: cand.firstSeen, val: val}
+			}
+			continue
+		}
+		s.candidates[key] = peakCandidate{firstSeen: now, val: val}
+	}
+	if changed {
+		s.saveLocked()
+	}
+}
+
+// snapshot returns the persisted peaks (fresh from disk), for read-only
+// consumers such as the /topo web view.
+func (s *observedPeakStore) snapshot() map[string]float64 {
+	return s.persistedPeaks()
+}
+
+// ── PSU capacity ────────────────────────────────────────────────────────────
+
+var psuPeaks = &observedPeakStore{
+	path:    "/var/log/bee-sat/psu-observation.json",
+	jsonKey: "max_w",
+	roundUp: 50,
+	minHold: time.Second,
+}
+
+// updatePSUObservation feeds the current per-PSU draw (keyed by ordinal, in
+// the order the caller lists them) into the observed-capacity store. On a BMC
+// that reports only instantaneous input power this is the only way to know
+// what "100% load" looks like for each supply: observe the peak draw during
+// any full-load run (the Fan Ceiling Check, a burn, thermal cycling — the 5 s
+// metrics collector samples PSUs throughout) and remember it.
+func updatePSUObservation(psus []PSUReading, now time.Time) {
+	if len(psus) == 0 {
+		return
+	}
+	m := make(map[string]float64, len(psus))
+	for i, p := range psus {
+		if p.PowerW > 0 {
+			m[strconv.Itoa(i)] = p.PowerW
+		}
+	}
+	psuPeaks.observe(m, now)
+}
+
+// ObservedPSUMaxW returns the persisted per-PSU observed peak draw, keyed by
+// ordinal ("0", "1", …), or nil if none recorded yet.
+func ObservedPSUMaxW() map[string]float64 {
+	p := psuPeaks.snapshot()
+	if len(p) == 0 {
+		return nil
+	}
+	return p
+}
diff --git a/audit/internal/platform/sat_fan_stress.go b/audit/internal/platform/sat_fan_stress.go
index 5639b30..d13d173 100644
--- a/audit/internal/platform/sat_fan_stress.go
+++ b/audit/internal/platform/sat_fan_stress.go
@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"math"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -44,33 +43,16 @@ type cachedPowerReading struct {
 	UpdatedAt time.Time
 }
 
-type fanObservationState struct {
-	MaxRPM map[string]float64 `json:"max_rpm"`
-}
-
-type fanPeakCandidate struct {
-	FirstSeen time.Time
-	RPM       float64
-}
-
-var (
-	fanObservationMu   sync.Mutex
-	fanObservation     fanObservationState
-	fanObservationInit bool
-	fanPeakCandidates  = make(map[string]fanPeakCandidate)
-)
-
 const systemPowerHoldTTL = 15 * time.Second
 
-var fanObservationStatePath = "/var/log/bee-sat/fan-observation.json"
-
-const fanObservationMinPeakHold = time.Second
-
-func normalizeObservedFanMaxRPM(rpm float64) float64 {
-	if rpm <= 0 {
-		return 0
-	}
-	return math.Ceil(rpm/1000.0) * 1000.0
+// fanPeaks is the observed top-RPM store — the "autotune" for fan ceilings.
+// Any full-load run (Fan Ceiling Check, burn, thermal cycling) feeds it via
+// updateFanObservation; ResolveFanMaxRPM / ObservedFanMaxRPM read it back.
+var fanPeaks = &observedPeakStore{
+	path:    "/var/log/bee-sat/fan-observation.json",
+	jsonKey: "max_rpm",
+	roundUp: 1000,
+	minHold: time.Second,
 }
 
 // RunFanCheck drives CPU (+memory) and, when a GPU is present, GPU load to
@@ -240,6 +222,12 @@ func (s *System) RunFanCheck(ctx context.Context, baseDir string, opts FanCheckO
 	goodSamples := 0
 	poll := fanPollFloor
 
+	// PSU peak draw, sampled at a slow cadence off the same loop — the fan
+	// check already drives the box to full power, so it is also the right run
+	// to observe what each PSU tops out at (updatePSUObservation persists it).
+	psuPeakW := map[int]float64{}
+	lastPSUSec := -1e9
+
 	csvPath := filepath.Join(runDir, "fan-sensors.csv")
 	_ = os.WriteFile(csvPath, []byte("elapsed_sec,fan_name,rpm\n"), 0644)
 	csvFile, _ := os.OpenFile(csvPath, os.O_APPEND|os.O_WRONLY, 0644)
@@ -281,6 +269,17 @@ loop:
 		}
 		goodSamples++
 
+		if elapsed-lastPSUSec >= 15 {
+			lastPSUSec = elapsed
+			if ps, ok := readPSUPowerBounded(fanReadTMO); ok {
+				for i, p := range ps {
+					if p.PowerW > psuPeakW[i] {
+						psuPeakW[i] = p.PowerW
+					}
+				}
+			}
+		}
+
 		for _, f := range fans {
 			if csvFile != nil {
 				fmt.Fprintf(csvFile, "%.0f,%s,%.0f\n", elapsed, f.Name, f.RPM)
@@ -347,6 +346,16 @@ loop:
 	if t := boundedGPUMaxTemp(opts.GPUIndices); t > 0 {
 		fmt.Fprintf(&summary, "gpu_temp_c=%.0f\n", t)
 	}
+	if len(psuPeakW) > 0 {
+		idx := make([]int, 0, len(psuPeakW))
+		for i := range psuPeakW {
+			idx = append(idx, i)
+		}
+		sort.Ints(idx)
+		for _, i := range idx {
+			fmt.Fprintf(&summary, "psu_%d_peak_w=%.0f\n", i, psuPeakW[i])
+		}
+	}
 
 	stats := satStats{}
 	names := make([]string, 0, len(baselineRPM))
@@ -441,6 +450,21 @@ func readFansBounded(timeout time.Duration) ([]FanReading, bool) {
 	}
 }
 
+// readPSUPowerBounded is readFansBounded's PSU sibling: a time-boxed,
+// abandonable "ipmitool sdr" read of per-PSU power (samplePSUPower also feeds
+// the observed-capacity store). Used at a slow cadence during the fan check so
+// the same max-load run that finds fan ceilings also records peak PSU draw.
+func readPSUPowerBounded(timeout time.Duration) ([]PSUReading, bool) {
+	ch := make(chan []PSUReading, 1)
+	go func() { ch <- samplePSUPower() }()
+	select {
+	case ps := <-ch:
+		return ps, len(ps) > 0
+	case <-time.After(timeout):
+		return nil, false
+	}
+}
+
 // boundedGPUMaxTemp returns the hottest GPU temperature via a single
 // time-boxed nvidia-smi call, or 0 if unavailable.
 func boundedGPUMaxTemp(gpuIndices []int) float64 {
@@ -569,8 +593,8 @@ func readFanStatuses() map[string]string {
 
 // ResolveFanMaxRPM returns, for every fan name in current (name -> current
 // RPM), the RPM to treat as that fan's 100% reference. Preference order:
-//  1. the persisted observed peak (fanObservationStatePath), written by
-//     RunFanCheck and by live-metrics sampling under load;
+//  1. the persisted observed peak, written by RunFanCheck and by live-metrics
+//     sampling under load;
 //  2. the largest peak observed on any peer fan (keeps a group visually
 //     consistent when only some fans have a recorded peak);
 //  3. the fan's own current RPM (so a tile is never sized against zero).
@@ -578,7 +602,7 @@ func readFanStatuses() map[string]string {
 // The fallback lives here, not in the view, so every consumer of a fan
 // maximum applies the same rule.
 func ResolveFanMaxRPM(current map[string]float64) map[string]float64 {
-	persisted := readPersistedFanMaxRPM()
+	persisted := fanPeaks.snapshot()
 
 	peerMax := 0.0
 	for _, v := range persisted {
@@ -621,122 +645,41 @@ func sampleFanSpeeds() ([]FanReading, error) {
 	return nil, sensorsErr
 }
 
-// readPersistedFanMaxRPM reads fanObservationStatePath and returns its
-// sanitized {fan name -> observed peak RPM} map (empty names / non-positive
-// values dropped). Returns an empty map when the file is missing or unparsable.
-func readPersistedFanMaxRPM() map[string]float64 {
-	out := map[string]float64{}
-	raw, err := os.ReadFile(fanObservationStatePath)
-	if err != nil || len(raw) == 0 {
-		return out
-	}
-	var persisted fanObservationState
-	if json.Unmarshal(raw, &persisted) != nil {
-		return out
-	}
-	for name, rpm := range persisted.MaxRPM {
-		name = strings.TrimSpace(name)
-		if name == "" || rpm <= 0 {
-			continue
-		}
-		out[name] = rpm
-	}
-	return out
-}
-
 // ObservedFanMaxRPM returns the per-fan observed peak RPM map persisted by
-// fan-stress SAT runs, or nil if none is recorded yet. It reads the file
-// directly without touching the in-process observation cache or its lock, so
-// read-only consumers (the /topo web view) can call it without perturbing a
-// concurrent SAT run's peak tracking.
+// full-load runs, or nil if none is recorded yet.
 func ObservedFanMaxRPM() map[string]float64 {
-	out := readPersistedFanMaxRPM()
+	out := fanPeaks.snapshot()
 	if len(out) == 0 {
 		return nil
 	}
 	return out
 }
 
-func loadFanObservationLocked() {
-	if fanObservationInit {
-		return
-	}
-	fanObservationInit = true
-	fanObservation.MaxRPM = readPersistedFanMaxRPM()
-}
-
-func saveFanObservationLocked() {
-	if len(fanObservation.MaxRPM) == 0 {
-		return
-	}
-	dir := filepath.Dir(fanObservationStatePath)
-	if dir == "" || dir == "." {
-		dir = "/var/log/bee-sat"
-	}
-	if err := os.MkdirAll(dir, 0755); err != nil {
-		return
-	}
-	raw, err := json.MarshalIndent(fanObservation, "", "  ")
-	if err != nil {
-		return
-	}
-	_ = os.WriteFile(fanObservationStatePath, raw, 0644)
-}
-
 func updateFanObservation(fans []FanReading, now time.Time) {
 	if len(fans) == 0 {
 		return
 	}
-	fanObservationMu.Lock()
-	defer fanObservationMu.Unlock()
-	loadFanObservationLocked()
-	changed := false
+	m := make(map[string]float64, len(fans))
 	for _, fan := range fans {
-		name := strings.TrimSpace(fan.Name)
-		if name == "" || fan.RPM <= 0 {
-			continue
+		if n := strings.TrimSpace(fan.Name); n != "" && fan.RPM > 0 {
+			m[n] = fan.RPM
 		}
-		currentMax := fanObservation.MaxRPM[name]
-		if fan.RPM <= currentMax {
-			delete(fanPeakCandidates, name)
-			continue
-		}
-		if cand, ok := fanPeakCandidates[name]; ok {
-			if now.Sub(cand.FirstSeen) >= fanObservationMinPeakHold {
-				newMax := math.Max(cand.RPM, fan.RPM)
-				if newMax > currentMax {
-					fanObservation.MaxRPM[name] = normalizeObservedFanMaxRPM(newMax)
-					changed = true
-				}
-				delete(fanPeakCandidates, name)
-				continue
-			}
-			if fan.RPM > cand.RPM {
-				fanPeakCandidates[name] = fanPeakCandidate{FirstSeen: cand.FirstSeen, RPM: fan.RPM}
-			}
-			continue
-		}
-		fanPeakCandidates[name] = fanPeakCandidate{FirstSeen: now, RPM: fan.RPM}
-	}
-	if changed {
-		saveFanObservationLocked()
 	}
+	fanPeaks.observe(m, now)
 }
 
 func estimateFanDutyCyclePctFromObservation(fans []FanReading) (float64, bool) {
 	if len(fans) == 0 {
 		return 0, false
 	}
-	fanObservationMu.Lock()
-	defer fanObservationMu.Unlock()
-	loadFanObservationLocked()
+	maxByName := fanPeaks.snapshot()
 	var samples []float64
 	for _, fan := range fans {
 		name := strings.TrimSpace(fan.Name)
 		if name == "" || fan.RPM <= 0 {
 			continue
 		}
-		maxRPM := fanObservation.MaxRPM[name]
+		maxRPM := maxByName[name]
 		if maxRPM <= 0 {
 			continue
 		}
diff --git a/audit/internal/platform/sat_fan_stress_test.go b/audit/internal/platform/sat_fan_stress_test.go
index 3d79787..817fccf 100644
--- a/audit/internal/platform/sat_fan_stress_test.go
+++ b/audit/internal/platform/sat_fan_stress_test.go
@@ -8,15 +8,20 @@ import (
 	"time"
 )
 
+// resetPeakStore points a store at a fresh temp file and clears its cache for
+// the duration of the test.
+func resetPeakStore(t *testing.T, s *observedPeakStore) {
+	t.Helper()
+	old := *s
+	s.path = filepath.Join(t.TempDir(), "peaks.json")
+	s.loaded = false
+	s.peaks = nil
+	s.candidates = nil
+	t.Cleanup(func() { *s = old })
+}
+
 func TestResolveFanMaxRPM(t *testing.T) {
-	oldPath := fanObservationStatePath
-	oldInit := fanObservationInit
-	fanObservationStatePath = filepath.Join(t.TempDir(), "fan-observation.json")
-	fanObservationInit = false
-	t.Cleanup(func() {
-		fanObservationStatePath = oldPath
-		fanObservationInit = oldInit
-	})
+	resetPeakStore(t, fanPeaks)
 
 	// No persisted file yet: unknown fans fall back to their own current RPM.
 	got := ResolveFanMaxRPM(map[string]float64{"A": 4000, "B": 9000})
@@ -24,7 +29,7 @@ func TestResolveFanMaxRPM(t *testing.T) {
 		t.Fatalf("no-persist fallback: got %v", got)
 	}
 
-	if err := os.WriteFile(fanObservationStatePath, []byte(`{"max_rpm":{"A":17000}}`), 0644); err != nil {
+	if err := os.WriteFile(fanPeaks.path, []byte(`{"max_rpm":{"A":17000}}`), 0644); err != nil {
 		t.Fatal(err)
 	}
 	got = ResolveFanMaxRPM(map[string]float64{"A": 4000, "B": 9000, "C": 5000})
@@ -34,6 +39,49 @@ func TestResolveFanMaxRPM(t *testing.T) {
 	}
 }
 
+func TestObservedPeakStore(t *testing.T) {
+	s := &observedPeakStore{
+		path:    filepath.Join(t.TempDir(), "peaks.json"),
+		jsonKey: "max_w",
+		roundUp: 50,
+		minHold: time.Second,
+	}
+	t0 := time.Unix(0, 0)
+
+	// A single spike does not stick.
+	s.observe(map[string]float64{"0": 900}, t0)
+	if len(s.snapshot()) != 0 {
+		t.Fatalf("transient spike should not persist: %v", s.snapshot())
+	}
+	// Held past minHold → sticks, rounded up to the next 50.
+	s.observe(map[string]float64{"0": 920}, t0.Add(1200*time.Millisecond))
+	if got := s.snapshot()["0"]; got != 950 {
+		t.Fatalf("held peak: got %v want 950", got)
+	}
+	// A lower reading never lowers the peak.
+	s.observe(map[string]float64{"0": 400}, t0.Add(5*time.Second))
+	if got := s.snapshot()["0"]; got != 950 {
+		t.Fatalf("peak must not drop: got %v", got)
+	}
+	// Fresh store reloads from disk.
+	s2 := &observedPeakStore{path: s.path, jsonKey: "max_w"}
+	if got := s2.snapshot()["0"]; got != 950 {
+		t.Fatalf("reload from disk: got %v want 950", got)
+	}
+}
+
+func TestUpdatePSUObservationKeyedByOrdinal(t *testing.T) {
+	resetPeakStore(t, psuPeaks)
+	now := time.Unix(0, 0)
+	psus := []PSUReading{{Name: "PSU1", PowerW: 1200}, {Name: "PSU2", PowerW: 1400}}
+	updatePSUObservation(psus, now)
+	updatePSUObservation(psus, now.Add(1200*time.Millisecond))
+	got := ObservedPSUMaxW()
+	if got["0"] != 1200 || got["1"] != 1400 {
+		t.Fatalf("keyed-by-ordinal peaks: got %v", got)
+	}
+}
+
 func TestApplyFanCheckDefaults(t *testing.T) {
 	var o FanCheckOptions
 	applyFanCheckDefaults(&o)
@@ -109,22 +157,7 @@ func TestParseFanDutyCyclePctSensorsJSON(t *testing.T) {
 }
 
 func TestEstimateFanDutyCyclePctFromObservation(t *testing.T) {
-	t.Parallel()
-
-	oldPath := fanObservationStatePath
-	oldState := fanObservation
-	oldInit := fanObservationInit
-	oldCandidates := fanPeakCandidates
-	fanObservationStatePath = filepath.Join(t.TempDir(), "fan-observation.json")
-	fanObservation = fanObservationState{}
-	fanObservationInit = false
-	fanPeakCandidates = make(map[string]fanPeakCandidate)
-	t.Cleanup(func() {
-		fanObservationStatePath = oldPath
-		fanObservation = oldState
-		fanObservationInit = oldInit
-		fanPeakCandidates = oldCandidates
-	})
+	resetPeakStore(t, fanPeaks)
 
 	start := time.Unix(100, 0)
 	updateFanObservation([]FanReading{{Name: "FAN1", RPM: 5000}}, start)
@@ -143,9 +176,9 @@ func TestEstimateFanDutyCyclePctFromObservation(t *testing.T) {
 		t.Fatalf("got=%v want ~43.3", got)
 	}
 
-	fanObservation = fanObservationState{}
-	fanObservationInit = false
-	fanPeakCandidates = make(map[string]fanPeakCandidate)
+	fanPeaks.loaded = false
+	fanPeaks.peaks = nil
+	fanPeaks.candidates = nil
 	got, ok = estimateFanDutyCyclePctFromObservation([]FanReading{{Name: "FAN1", RPM: 2600}})
 	if !ok {
 		t.Fatalf("expected persisted observed max to be reloaded from disk")
diff --git a/audit/internal/webui/page_topo_diagram.go b/audit/internal/webui/page_topo_diagram.go
index 048cdcd..3cd956b 100644
--- a/audit/internal/webui/page_topo_diagram.go
+++ b/audit/internal/webui/page_topo_diagram.go
@@ -594,7 +594,7 @@ func renderTopoMainDiagram(hw schema.HardwareSnapshot, exportDir string) string
 
 	hasPSU := len(hw.PowerSupplies) > 0
 	if hasPSU {
-		b.WriteString(renderTopoPSURow(hw.PowerSupplies))
+		b.WriteString(renderTopoPSURow(hw.PowerSupplies, platform.ObservedPSUMaxW()))
 	}
 
 	// Cooling fans — one small clickable square per fan. Square SIZE encodes
@@ -619,10 +619,13 @@ func renderTopoMainDiagram(hw schema.HardwareSnapshot, exportDir string) string
 }
 
 // renderTopoPSURow renders the POWER SUPPLIES row: one card per PSU, coloured
-// by that PSU's own status (a failed unit goes red on its own), showing input
-// voltage and draw. Cards click through to the shared PSU detail modal and
-// carry data-psu so topoLiveScript can refresh the wattage in place.
-func renderTopoPSURow(psus []schema.HardwarePowerSupply) string {
+// by that PSU's own status (a failed unit goes red on its own). The card shows
+// input voltage and draw, and a load fill rising from the bottom — same idea
+// as the fan duty-cycle fill. The load scale is the nameplate rating when the
+// BMC reports it; otherwise it is the observed peak draw (observedMaxW, keyed
+// by ordinal — the "autotune" recorded during any full-load run), and the
+// figure is marked as an estimate.
+func renderTopoPSURow(psus []schema.HardwarePowerSupply, observedMaxW map[string]float64) string {
 	var b strings.Builder
 	b.WriteString(topoRowHeading("Power Supplies"))
 	b.WriteString(`<div style="display:flex;flex-wrap:wrap;gap:8px">`)
@@ -640,14 +643,25 @@ func renderTopoPSURow(psus []schema.HardwarePowerSupply) string {
 		if p.WattageW != nil && *p.WattageW > 0 {
 			rating = *p.WattageW
 		}
+		// Load scale: true rating if known, else the observed peak draw.
+		scaleMax := float64(rating)
+		scaleEstimate := false
+		if scaleMax <= 0 {
+			if m := observedMaxW[strconv.Itoa(i)]; m > 0 {
+				scaleMax = m
+				scaleEstimate = true
+			}
+		}
 
 		var parts []string
 		if p.InputVoltage != nil && *p.InputVoltage > 0 {
 			parts = append(parts, fmt.Sprintf("%.0f V", *p.InputVoltage))
 		}
 		switch {
-		case haveDraw && rating > 0:
-			parts = append(parts, fmt.Sprintf("%.0f / %d W · %.0f%% load", draw, rating, draw/float64(rating)*100))
+		case haveDraw && scaleMax > 0 && scaleEstimate:
+			parts = append(parts, fmt.Sprintf("%.0f / ~%.0f W · ~%.0f%% load", draw, scaleMax, draw/scaleMax*100))
+		case haveDraw && scaleMax > 0:
+			parts = append(parts, fmt.Sprintf("%.0f / %d W · %.0f%% load", draw, rating, draw/scaleMax*100))
 		case haveDraw:
 			parts = append(parts, fmt.Sprintf("%.0f W", draw))
 		case rating > 0:
@@ -660,33 +674,29 @@ func renderTopoPSURow(psus []schema.HardwarePowerSupply) string {
 			statusWord = topoSeverityStatus(p.Status)
 		}
 
-		// Load fill (draw / rating) rises from the bottom of the card, the
-		// same idea as the fan duty-cycle fill. Only drawn when the nameplate
-		// rating is known — a raw wattage with nothing to scale it against is
-		// not a load figure.
-		loadPct := -1.0
-		if haveDraw && rating > 0 {
-			loadPct = draw / float64(rating) * 100
-			if loadPct < 0 {
-				loadPct = 0
-			}
-			if loadPct > 100 {
-				loadPct = 100
-			}
-		}
 		fillH := 0.0
-		if loadPct >= 0 {
-			fillH = loadPct
+		if haveDraw && scaleMax > 0 {
+			fillH = draw / scaleMax * 100
+			if fillH < 0 {
+				fillH = 0
+			}
+			if fillH > 100 {
+				fillH = 100
+			}
 		}
 
 		voltAttr := ""
 		if p.InputVoltage != nil && *p.InputVoltage > 0 {
 			voltAttr = fmt.Sprintf("%.0f", *p.InputVoltage)
 		}
+		maxSrc := "rated"
+		if scaleEstimate {
+			maxSrc = "observed"
+		}
 
-		fmt.Fprintf(&b, `<div class="topo-psu-tile" data-psu="%d" data-psu-max="%d" data-psu-v="%s" onclick="openComponentDetail('psu')" `+
+		fmt.Fprintf(&b, `<div class="topo-psu-tile" data-psu="%d" data-psu-max="%.0f" data-psu-max-src="%s" data-psu-v="%s" onclick="openComponentDetail('psu')" `+
 			`style="position:relative;overflow:hidden;cursor:pointer;min-width:104px;padding:8px 11px;border-radius:6px;background:var(--surface-2);border:1px solid %s;color:%s">`,
-			i, rating, voltAttr, stroke, text)
+			i, scaleMax, maxSrc, voltAttr, stroke, text)
 		fmt.Fprintf(&b, `<div class="topo-psu-fill" style="position:absolute;left:0;right:0;bottom:0;height:%.0f%%;background:%s;opacity:.5;transition:height .8s linear"></div>`, fillH, stroke)
 		fmt.Fprintf(&b, `<div style="position:relative"><div style="font-size:13px;font-weight:700">%s</div>`, html.EscapeString(label))
 		fmt.Fprintf(&b, `<div class="topo-psu-detail" style="font-size:11px;opacity:.9;margin-top:2px">%s</div>`, html.EscapeString(detail))
@@ -828,11 +838,15 @@ func topoLiveScript() string {
         psus.forEach(function(t){
           var p=m.psus[parseInt(t.dataset.psu,10)];if(!p)return;
           var w=p.power_w||0,max=parseFloat(t.dataset.psuMax)||0,v=t.dataset.psuV;
+          var est=t.dataset.psuMaxSrc==='observed';
           var parts=[];
           if(v)parts.push(v+' V');
-          if(w>0&&max>0)parts.push(Math.round(w)+' / '+max+' W · '+Math.round(w/max*100)+'% load');
-          else if(w>0)parts.push(Math.round(w)+' W');
-          else if(max>0)parts.push(max+' W rated');
+          if(w>0&&max>0){
+            var pct=Math.round(w/max*100);
+            parts.push(est?Math.round(w)+' / ~'+Math.round(max)+' W · ~'+pct+'% load'
+                          :Math.round(w)+' / '+Math.round(max)+' W · '+pct+'% load');
+          }else if(w>0)parts.push(Math.round(w)+' W');
+          else if(max>0)parts.push(Math.round(max)+' W rated');
           var d=t.querySelector('.topo-psu-detail');if(d&&parts.length)d.textContent=parts.join(' · ');
           if(w>0&&max>0){var f=t.querySelector('.topo-psu-fill');if(f)f.style.height=Math.max(0,Math.min(100,w/max*100)).toFixed(0)+'%';}
         });
diff --git a/audit/internal/webui/page_topo_test.go b/audit/internal/webui/page_topo_test.go
index 185d5bf..b0ba5f3 100644
--- a/audit/internal/webui/page_topo_test.go
+++ b/audit/internal/webui/page_topo_test.go
@@ -262,6 +262,27 @@ func TestFanSpinPeriodSec(t *testing.T) {
 	}
 }
 
+func TestRenderTopoPSURowUsesObservedMaxWhenNoRating(t *testing.T) {
+	ok := "OK"
+	draw := 340.0
+	psus := []schema.HardwarePowerSupply{
+		{HardwareComponentStatus: schema.HardwareComponentStatus{Status: &ok}, InputPowerW: &draw}, // no WattageW
+	}
+	// Observed peak (keyed by ordinal) stands in for the missing nameplate.
+	html := renderTopoPSURow(psus, map[string]float64{"0": 2400})
+	if !strings.Contains(html, `data-psu-max-src="observed"`) {
+		t.Fatalf("expected observed-scale marker: %s", html)
+	}
+	if !strings.Contains(html, "340 / ~2400 W · ~14% load") {
+		t.Fatalf("expected estimated load line: %s", html)
+	}
+	// Without an observed peak either, just the raw watts, no fill.
+	html = renderTopoPSURow(psus, nil)
+	if strings.Contains(html, "% load") {
+		t.Fatalf("no rating and no observed peak → no load figure: %s", html)
+	}
+}
+
 func TestTopoPageRendersStorageDisksGroupedByType(t *testing.T) {
 	dir := t.TempDir()
 	path := filepath.Join(dir, "audit.json")
diff --git a/bible-local/decisions/2026-09-04-fan-ceiling-check.md b/bible-local/decisions/2026-09-04-fan-ceiling-check.md
index 5dc0619..2baf14d 100644
--- a/bible-local/decisions/2026-09-04-fan-ceiling-check.md
+++ b/bible-local/decisions/2026-09-04-fan-ceiling-check.md
@@ -57,10 +57,33 @@ The `fan` SAT test (`platform.RunFanCheck`, formerly the unwired
    fan rose meaningfully above baseline, declare the ceiling found and stop —
    **success**. `MaxLoadSec` (default 900 s) is a hard cap; hitting it is also
    success (the highest RPM seen is still recorded).
-4. Persist each peak through the existing `updateFanObservation` path
+4. Persist each peak through `updateFanObservation`
    (`/var/log/bee-sat/fan-observation.json`), which is what `ResolveFanMaxRPM`
    reads.
 
+## The observed-peak store (autotune primitive)
+
+`platform.observedPeakStore` (`observed_peaks.go`) is the shared mechanism:
+observe the max value per key while the box is under load, require a candidate
+to hold ≥ `minHold` before it sticks (rejects spikes), round up, persist to a
+`{"<jsonKey>": {key: peak}}` JSON file. Two instances:
+
+- `fanPeaks` → `fan-observation.json` `max_rpm`, keyed by fan name, round-up 1000.
+- `psuPeaks` → `psu-observation.json` `max_w`, keyed by **PSU ordinal**, round-up 50.
+
+Both are fed from the ordinary telemetry paths — `sampleFanSpeeds` and
+`samplePSUPower` call `update*Observation` — so **any** full-load run refines
+them: the Fan Ceiling Check itself, a burn, thermal cycling, power
+calibration, and the 5 s web metrics collector while any of those run. There
+is no separate "PSU autotune" test: the fan check's max-CPU+GPU load is
+already the right moment to observe peak PSU draw, and it samples PSU power at
+a slow cadence off its own loop (`psu_<i>_peak_w` in the summary).
+
+This exists because BMCs like the MSI stand's report only instantaneous PSU
+input power, no nameplate rating. `/topo` PSU cards scale the load fill by the
+real `wattage_w` when present, otherwise by `ObservedPSUMaxW()` — marked as an
+estimate (`~N% load`).
+
 ## Verdict mapping
 
 - A fan reading **0 RPM**, or IPMI status **cr/nr**, while under full load →

From 08044c81e714823fb3164d893c7503cdcfc7ac93 Mon Sep 17 00:00:00 2001
From: Mikhail Chusavitin <mchusavitin@mchusmbp.local>
Date: Fri, 4 Sep 2026 12:56:25 +0300
Subject: [PATCH 9/9] fix(webui): don't show PSU load % until the observed peak
 clears idle draw

The passive collector records PSU draw at idle too, so right after boot
the "observed peak" is just idle wattage and a load % off it is
meaningless. Require the observed peak to sit >=25% above current draw
before using it as a load scale; until a real full-load run bumps it,
show plain watts.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019VHG21rgTUiR1G3qFHTVmN
---
 audit/internal/webui/page_topo_diagram.go | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/audit/internal/webui/page_topo_diagram.go b/audit/internal/webui/page_topo_diagram.go
index 3cd956b..8d7b6fb 100644
--- a/audit/internal/webui/page_topo_diagram.go
+++ b/audit/internal/webui/page_topo_diagram.go
@@ -643,11 +643,14 @@ func renderTopoPSURow(psus []schema.HardwarePowerSupply, observedMaxW map[string
 		if p.WattageW != nil && *p.WattageW > 0 {
 			rating = *p.WattageW
 		}
-		// Load scale: true rating if known, else the observed peak draw.
+		// Load scale: true rating if known, else the observed peak draw — but
+		// only once that peak sits meaningfully above the current draw. Until
+		// a real full-load run has bumped it, the "peak" is just idle draw and
+		// a load % off it would be nonsense, so fall back to plain watts.
 		scaleMax := float64(rating)
 		scaleEstimate := false
 		if scaleMax <= 0 {
-			if m := observedMaxW[strconv.Itoa(i)]; m > 0 {
+			if m := observedMaxW[strconv.Itoa(i)]; m > 0 && (!haveDraw || m >= draw*1.25) {
 				scaleMax = m
 				scaleEstimate = true
 			}