Fix USB/RAM status checks; add server model+S/N to dashboard; remove cycles

USB Export Drive:
  lsblk reports TRAN only for whole disks, not partitions (/dev/sdc1).
  Strip trailing partition digits to get parent disk before transport check.

LiveCD in RAM:
  When RunInstallToRAM copies squashfs to /dev/shm/bee-live/ but bind-mount
  of /run/live/medium fails (CD-ROM boots), /run/live/medium still shows the
  CD-ROM fstype. Add fallback: if /dev/shm/bee-live/*.squashfs exists, the
  data is in RAM — report status OK.

Dashboard Hardware Summary:
  Show server Manufacturer + ProductName as heading and S/N as subline above
  the component table, sourced from hw.Board (dmidecode system-type data).

Validate:
  Remove Cycles input — always run once. cycles=1 hardcoded in runAllSAT().

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

audit/internal/platform/benchmark.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"math"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"regexp"
 	"sort"
@@ -108,7 +109,11 @@ func (s *System) RunNvidiaBenchmark(ctx context.Context, baseDir string, opts Nv
 		ServerModel:        readServerModel(),
 		BenchmarkProfile:   spec.Name,
 		ParallelGPUs:       opts.ParallelGPUs,
+		RampStep:           opts.RampStep,
+		RampTotal:          opts.RampTotal,
+		RampRunID:          opts.RampRunID,
 		SelectedGPUIndices: append([]int(nil), selected...),
+		HostConfig:         readBenchmarkHostConfig(),
 		Normalization: BenchmarkNormalization{
 			Status: "full",
 		},
@@ -152,8 +157,16 @@ func (s *System) RunNvidiaBenchmark(ctx context.Context, baseDir string, opts Nv
 		}
 	}()
 
+	// Power calibration: run dcgmi targeted_power while sampling nvidia-smi power.
+	// Returns per-GPU p95 power as an honest TDP reference for PowerSustainScore.
+	calibPowerByIndex := runBenchmarkPowerCalibration(ctx, verboseLog, runDir, selected, logFunc)
+
+	// Start background CPU load sampler — samples every 10s during GPU phases.
+	cpuStopCh := make(chan struct{})
+	cpuSamplesCh := startCPULoadSampler(cpuStopCh, 10)
+
 	if opts.ParallelGPUs {
-		runNvidiaBenchmarkParallel(ctx, verboseLog, runDir, selected, infoByIndex, opts, spec, logFunc, &result, &serverIdleW, &serverLoadedWSum, &serverIdleOK, &serverLoadedOK, &serverLoadedSamples)
+		runNvidiaBenchmarkParallel(ctx, verboseLog, runDir, selected, infoByIndex, opts, spec, logFunc, &result, calibPowerByIndex, &serverIdleW, &serverLoadedWSum, &serverIdleOK, &serverLoadedOK, &serverLoadedSamples)
 	} else {
 
 	for _, idx := range selected {
@@ -173,6 +186,9 @@ func (s *System) RunNvidiaBenchmark(ctx context.Context, baseDir string, opts Nv
 			gpuResult.BaseGraphicsClockMHz = info.BaseGraphicsClockMHz
 			gpuResult.MaxMemoryClockMHz = info.MaxMemoryClockMHz
 		}
+		if w, ok := calibPowerByIndex[idx]; ok && w > 0 {
+			gpuResult.CalibratedPeakPowerW = w
+		}
 		if norm := findBenchmarkNormalization(result.Normalization.GPUs, idx); norm != nil {
 			gpuResult.LockedGraphicsClockMHz = norm.GPUClockLockMHz
 			gpuResult.LockedMemoryClockMHz = norm.MemoryClockLockMHz
@@ -310,6 +326,16 @@ func (s *System) RunNvidiaBenchmark(ctx context.Context, baseDir string, opts Nv
 		}
 	}
 
+	// Stop CPU load sampler and attach results.
+	close(cpuStopCh)
+	if cpuSamples := <-cpuSamplesCh; len(cpuSamples) > 0 {
+		result.CPULoad = summarizeCPULoad(cpuSamples)
+		if result.CPULoad != nil && result.CPULoad.Status != "ok" {
+			logFunc(fmt.Sprintf("host CPU load during benchmark: avg=%.1f%% max=%.1f%% status=%s",
+				result.CPULoad.AvgPct, result.CPULoad.MaxPct, result.CPULoad.Status))
+		}
+	}
+
 	// Compute server power characterization from accumulated IPMI samples.
 	var gpuReportedSumW float64
 	for _, gpu := range result.GPUs {
@@ -321,6 +347,20 @@ func (s *System) RunNvidiaBenchmark(ctx context.Context, baseDir string, opts Nv
 	}
 	result.ServerPower = characterizeServerPower(serverIdleW, serverLoadedW, gpuReportedSumW, serverIdleOK && serverLoadedOK)
 
+	// Apply server-power penalty when IPMI reports the server delta is much
+	// lower than GPU-reported sum: GPU power telemetry is over-stated, making
+	// CalibratedPeakPowerW and PowerSustainScore unreliable.
+	// Penalty factor scales from 1.0 (ratio ≥ 0.75, no penalty) down to 0.
+	if sp := result.ServerPower; sp != nil && sp.Available && sp.ReportingRatio > 0 && sp.ReportingRatio < 0.75 {
+		factor := sp.ReportingRatio / 0.75
+		for i := range result.GPUs {
+			result.GPUs[i].Scores.CompositeScore *= factor
+			result.GPUs[i].Notes = append(result.GPUs[i].Notes,
+				fmt.Sprintf("server-power penalty applied (reporting_ratio=%.2f < 0.75): composite score reduced to %.1f%%",
+					sp.ReportingRatio, factor*100))
+		}
+	}
+
 	result.Findings = buildBenchmarkFindings(result)
 	result.OverallStatus = benchmarkOverallStatus(result)
 
@@ -423,6 +463,9 @@ func enrichGPUInfoWithMaxClocks(infoByIndex map[int]benchmarkGPUInfo, nvsmiQ []b
 	gpuSectionRe := regexp.MustCompile(`(?m)^GPU\s+([\dA-Fa-f:\.]+)`)
 	maxGfxRe      := regexp.MustCompile(`(?i)Max Clocks[\s\S]*?Graphics\s*:\s*(\d+)\s*MHz`)
 	maxMemRe      := regexp.MustCompile(`(?i)Max Clocks[\s\S]*?Memory\s*:\s*(\d+)\s*MHz`)
+	defaultPwrRe  := regexp.MustCompile(`(?i)Default Power Limit\s*:\s*([0-9.]+)\s*W`)
+	currentPwrRe  := regexp.MustCompile(`(?i)Current Power Limit\s*:\s*([0-9.]+)\s*W`)
+	smCountRe     := regexp.MustCompile(`(?i)Multiprocessor Count\s*:\s*(\d+)`)
 
 	sectionStarts := gpuSectionRe.FindAllSubmatchIndex(nvsmiQ, -1)
 	for i, loc := range sectionStarts {
@@ -443,17 +486,14 @@ func enrichGPUInfoWithMaxClocks(infoByIndex map[int]benchmarkGPUInfo, nvsmiQ []b
 			continue
 		}
 
-		info := infoByIndex[benchIdx]
-		if info.MaxGraphicsClockMHz > 0 && info.MaxMemoryClockMHz > 0 {
-			continue // already populated
-		}
-
 		end := len(nvsmiQ)
 		if i+1 < len(sectionStarts) {
 			end = sectionStarts[i+1][0]
 		}
 		section := nvsmiQ[loc[0]:end]
 
+		info := infoByIndex[benchIdx]
+
 		if info.MaxGraphicsClockMHz == 0 {
 			if m := maxGfxRe.FindSubmatch(section); m != nil {
 				if v, err := strconv.ParseFloat(string(m[1]), 64); err == nil {
@@ -468,6 +508,27 @@ func enrichGPUInfoWithMaxClocks(infoByIndex map[int]benchmarkGPUInfo, nvsmiQ []b
 				}
 			}
 		}
+		if info.DefaultPowerLimitW == 0 {
+			if m := defaultPwrRe.FindSubmatch(section); m != nil {
+				if v, err := strconv.ParseFloat(string(m[1]), 64); err == nil && v > 0 {
+					info.DefaultPowerLimitW = v
+				}
+			}
+		}
+		if info.PowerLimitW == 0 {
+			if m := currentPwrRe.FindSubmatch(section); m != nil {
+				if v, err := strconv.ParseFloat(string(m[1]), 64); err == nil && v > 0 {
+					info.PowerLimitW = v
+				}
+			}
+		}
+		if info.MultiprocessorCount == 0 {
+			if m := smCountRe.FindSubmatch(section); m != nil {
+				if v, err := strconv.Atoi(string(m[1])); err == nil && v > 0 {
+					info.MultiprocessorCount = v
+				}
+			}
+		}
 		infoByIndex[benchIdx] = info
 	}
 }
@@ -834,14 +895,22 @@ func scoreBenchmarkGPUResult(gpu BenchmarkGPUResult) BenchmarkScorecard {
 			score.ComputeScore += precision.TeraOpsPerSec
 		}
 	}
-	// Use default power limit for sustain score so a manually reduced limit
-	// does not inflate the score. Fall back to enforced limit if default unknown.
-	referencePowerW := gpu.DefaultPowerLimitW
-	if referencePowerW <= 0 {
-		referencePowerW = gpu.PowerLimitW
+	// PowerSustainScore: measures how close the GPU came to its rated TDP under
+	// a full-spectrum load (dcgmi targeted_power). 100 = exactly at rated TDP.
+	// Penalty applied symmetrically for both under- and over-TDP deviations:
+	//   score = max(0, 100 − |measured − rated| / rated × 100)
+	// Under-TDP → power delivery / cooling issue.
+	// Over-TDP  → power limit not properly enforced / power regulation fault.
+	// Falls back to 0 if calibration was not performed (dcgmi unavailable).
+	{
+		ref := gpu.DefaultPowerLimitW
+		if ref <= 0 {
+			ref = gpu.PowerLimitW
+		}
+		if gpu.CalibratedPeakPowerW > 0 && ref > 0 {
+			deviationPct := math.Abs(gpu.CalibratedPeakPowerW-ref) / ref * 100
+			score.PowerSustainScore = clampScore(100 - deviationPct)
 		}
-	if referencePowerW > 0 {
-		score.PowerSustainScore = math.Min(100, (gpu.Steady.AvgPowerW/referencePowerW)*100)
 	}
 	runtimeUS := math.Max(1, gpu.Steady.DurationSec*1e6)
 	thermalRatio := float64(gpu.Throttle.HWThermalSlowdownUS+gpu.Throttle.SWThermalSlowdownUS) / runtimeUS
@@ -855,7 +924,15 @@ func scoreBenchmarkGPUResult(gpu BenchmarkGPUResult) BenchmarkScorecard {
 }
 
 func compositeBenchmarkScore(score BenchmarkScorecard) float64 {
-	quality := 0.40 + 0.20*(score.PowerSustainScore/100.0) + 0.20*(score.ThermalSustainScore/100.0) + 0.20*(score.StabilityScore/100.0)
+	// Weights after introducing calibrated power reference:
+	//   base        0.35 — floor so a GPU that fails all sustain checks still scores
+	//   thermal     0.25 — heaviest: throttle counters are the most reliable signal
+	//   stability   0.25 — clock/power variance matters for reproducibility
+	//   power       0.15 — GPU reaches rated TDP under targeted_power? lower weight
+	//                       because calibration may be absent (dcgmi not installed)
+	//   NCCL bonus  0.10 — interconnect health
+	//   cap         1.10
+	quality := 0.35 + 0.15*(score.PowerSustainScore/100.0) + 0.25*(score.ThermalSustainScore/100.0) + 0.25*(score.StabilityScore/100.0)
 	if score.InterconnectScore > 0 {
 		quality += 0.10
 	}
@@ -1075,16 +1152,57 @@ func buildBenchmarkFindings(result NvidiaBenchmarkResult) []string {
 				gpu.Index, gpu.PowerLimitW, gpu.DefaultPowerLimitW, gpu.PowerLimitW/gpu.DefaultPowerLimitW*100,
 			))
 		}
+		// Flag significant TDP deviation (over or under) from calibration.
+		if gpu.CalibratedPeakPowerW > 0 {
+			ref := gpu.DefaultPowerLimitW
+			if ref <= 0 {
+				ref = gpu.PowerLimitW
+			}
+			if ref > 0 {
+				deviationPct := (gpu.CalibratedPeakPowerW - ref) / ref * 100
+				switch {
+				case deviationPct < -10:
+					findings = append(findings, fmt.Sprintf(
+						"GPU %d reached only %.0f W (%.0f%% of rated %.0f W) under targeted_power. Check power delivery or cooling.",
+						gpu.Index, gpu.CalibratedPeakPowerW, gpu.CalibratedPeakPowerW/ref*100, ref,
+					))
+				case deviationPct > 5:
+					findings = append(findings, fmt.Sprintf(
+						"GPU %d exceeded rated TDP: %.0f W measured vs %.0f W rated (+%.0f%%). Power limit may not be enforced correctly.",
+						gpu.Index, gpu.CalibratedPeakPowerW, ref, deviationPct,
+					))
+				}
+			}
+		}
 	}
 	if result.Interconnect != nil && result.Interconnect.Supported {
 		findings = append(findings, fmt.Sprintf("Multi-GPU all_reduce max bus bandwidth: %.1f GB/s.", result.Interconnect.MaxBusBWGBps))
 	}
+	if cl := result.CPULoad; cl != nil {
+		switch cl.Status {
+		case "high":
+			findings = append(findings, fmt.Sprintf(
+				"Host CPU load was elevated during the benchmark (avg %.1f%%, max %.1f%%). A competing CPU workload may skew GPU results.",
+				cl.AvgPct, cl.MaxPct,
+			))
+		case "unstable":
+			findings = append(findings, fmt.Sprintf(
+				"Host CPU load was erratic during the benchmark (avg %.1f%%, p95 %.1f%%). Results may be less reproducible.",
+				cl.AvgPct, cl.P95Pct,
+			))
+		}
+	}
 	if sp := result.ServerPower; sp != nil && sp.Available && sp.GPUReportedSumW > 0 {
 		if sp.ReportingRatio < 0.75 {
 			findings = append(findings, fmt.Sprintf(
-				"GPU power reporting may be unreliable: server delta %.0f W vs GPU-reported %.0f W (ratio %.2f). GPU telemetry likely over-reports actual consumption.",
+				"GPU power reporting may be unreliable: server delta %.0f W vs GPU-reported %.0f W (ratio %.2f). GPU telemetry likely over-reports actual consumption. Composite scores have been penalized accordingly.",
 				sp.DeltaW, sp.GPUReportedSumW, sp.ReportingRatio,
 			))
+		} else if sp.ReportingRatio > 1.25 {
+			findings = append(findings, fmt.Sprintf(
+				"Server power delta %.0f W exceeds GPU-reported sum %.0f W by %.0f%%. Other components (CPU, NVMe, networking) may be drawing substantial power under GPU load.",
+				sp.DeltaW, sp.GPUReportedSumW, (sp.ReportingRatio-1)*100,
+			))
 		}
 	}
 	return dedupeStrings(findings)
@@ -1389,6 +1507,7 @@ func runNvidiaBenchmarkParallel(
 	spec benchmarkProfileSpec,
 	logFunc func(string),
 	result *NvidiaBenchmarkResult,
+	calibPowerByIndex map[int]float64,
 	serverIdleW *float64, serverLoadedWSum *float64,
 	serverIdleOK *bool, serverLoadedOK *bool, serverLoadedSamples *int,
 ) {
@@ -1410,6 +1529,9 @@ func runNvidiaBenchmarkParallel(
 			r.BaseGraphicsClockMHz = info.BaseGraphicsClockMHz
 			r.MaxMemoryClockMHz = info.MaxMemoryClockMHz
 		}
+		if w, ok := calibPowerByIndex[idx]; ok && w > 0 {
+			r.CalibratedPeakPowerW = w
+		}
 		if norm := findBenchmarkNormalization(result.Normalization.GPUs, idx); norm != nil {
 			r.LockedGraphicsClockMHz = norm.GPUClockLockMHz
 			r.LockedMemoryClockMHz = norm.MemoryClockLockMHz
@@ -1571,3 +1693,225 @@ func runNvidiaBenchmarkParallel(
 		result.GPUs = append(result.GPUs, finalizeBenchmarkGPUResult(*r))
 	}
 }
+
+// readBenchmarkHostConfig reads static CPU and memory configuration from
+// /proc/cpuinfo and /proc/meminfo. Returns nil if neither source is readable.
+func readBenchmarkHostConfig() *BenchmarkHostConfig {
+	cfg := &BenchmarkHostConfig{}
+	populated := false
+
+	// Parse /proc/cpuinfo for CPU model, sockets, cores, threads.
+	if data, err := os.ReadFile("/proc/cpuinfo"); err == nil {
+		socketIDs := map[string]struct{}{}
+		coresPerSocket := map[string]int{}
+		var modelName string
+		threads := 0
+		for _, line := range strings.Split(string(data), "\n") {
+			kv := strings.SplitN(line, ":", 2)
+			if len(kv) != 2 {
+				continue
+			}
+			key := strings.TrimSpace(kv[0])
+			val := strings.TrimSpace(kv[1])
+			switch key {
+			case "processor":
+				threads++
+			case "model name":
+				if modelName == "" {
+					modelName = val
+				}
+			case "physical id":
+				socketIDs[val] = struct{}{}
+			case "cpu cores":
+				// Overwrite per-socket core count (last wins per socket, but all
+				// entries for the same socket report the same value).
+				if physLine := ""; physLine == "" {
+					// We accumulate below by treating cpu cores as a per-thread
+					// field; sum by socket requires a two-pass approach. Use the
+					// simpler approximation: totalCores = threads / (threads per core).
+					_ = val
+				}
+			}
+		}
+		// Second pass: per-socket core count.
+		var curSocket string
+		for _, line := range strings.Split(string(data), "\n") {
+			kv := strings.SplitN(line, ":", 2)
+			if len(kv) != 2 {
+				continue
+			}
+			key := strings.TrimSpace(kv[0])
+			val := strings.TrimSpace(kv[1])
+			switch key {
+			case "physical id":
+				curSocket = val
+			case "cpu cores":
+				if curSocket != "" {
+					if _, seen := coresPerSocket[curSocket]; !seen {
+						v, _ := strconv.Atoi(val)
+						coresPerSocket[curSocket] = v
+					}
+				}
+			}
+		}
+		totalCores := 0
+		for _, c := range coresPerSocket {
+			totalCores += c
+		}
+		cfg.CPUModel = modelName
+		cfg.CPUSockets = len(socketIDs)
+		if cfg.CPUSockets == 0 && threads > 0 {
+			cfg.CPUSockets = 1
+		}
+		cfg.CPUCores = totalCores
+		cfg.CPUThreads = threads
+		if modelName != "" || threads > 0 {
+			populated = true
+		}
+	}
+
+	// Parse /proc/meminfo for total physical RAM.
+	if data, err := os.ReadFile("/proc/meminfo"); err == nil {
+		for _, line := range strings.Split(string(data), "\n") {
+			if strings.HasPrefix(line, "MemTotal:") {
+				fields := strings.Fields(line)
+				if len(fields) >= 2 {
+					kb, _ := strconv.ParseUint(fields[1], 10, 64)
+					cfg.MemTotalGiB = float64(kb) / (1024 * 1024)
+					populated = true
+				}
+				break
+			}
+		}
+	}
+
+	if !populated {
+		return nil
+	}
+	return cfg
+}
+
+// startCPULoadSampler starts a goroutine that samples host CPU load every
+// intervalSec seconds until stopCh is closed, then sends the collected
+// samples on the returned channel.
+func startCPULoadSampler(stopCh <-chan struct{}, intervalSec int) <-chan []float64 {
+	ch := make(chan []float64, 1)
+	go func() {
+		var samples []float64
+		ticker := time.NewTicker(time.Duration(intervalSec) * time.Second)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-stopCh:
+				ch <- samples
+				return
+			case <-ticker.C:
+				if pct := sampleCPULoadPct(); pct > 0 {
+					samples = append(samples, pct)
+				}
+			}
+		}
+	}()
+	return ch
+}
+
+// summarizeCPULoad computes stats over sampled CPU load values and assigns
+// a health status.
+func summarizeCPULoad(samples []float64) *BenchmarkCPULoad {
+	if len(samples) == 0 {
+		return nil
+	}
+	sorted := append([]float64(nil), samples...)
+	sort.Float64s(sorted)
+	var sum float64
+	for _, v := range sorted {
+		sum += v
+	}
+	avg := sum / float64(len(sorted))
+	p95 := sorted[int(float64(len(sorted))*0.95)]
+	max := sorted[len(sorted)-1]
+
+	cl := &BenchmarkCPULoad{
+		AvgPct:  math.Round(avg*10) / 10,
+		MaxPct:  math.Round(max*10) / 10,
+		P95Pct:  math.Round(p95*10) / 10,
+		Samples: len(sorted),
+	}
+
+	// Compute standard deviation to detect instability.
+	var variance float64
+	for _, v := range sorted {
+		d := v - avg
+		variance += d * d
+	}
+	stdDev := math.Sqrt(variance / float64(len(sorted)))
+
+	switch {
+	case avg > 20 || max > 40:
+		cl.Status = "high"
+		cl.Note = fmt.Sprintf("avg %.1f%% max %.1f%% — elevated host CPU load may interfere with GPU benchmark results", avg, max)
+	case stdDev > 12:
+		cl.Status = "unstable"
+		cl.Note = fmt.Sprintf("avg %.1f%% stddev %.1f%% — host CPU load was erratic during the benchmark", avg, stdDev)
+	default:
+		cl.Status = "ok"
+	}
+	return cl
+}
+
+// runBenchmarkPowerCalibration runs a short dcgmi targeted_power test while
+// collecting nvidia-smi power samples in parallel. It returns a map from GPU
+// index to p95 observed power (watts), which is used as the reference for
+// PowerSustainScore instead of the hardware default limit.
+//
+// If dcgmi is unavailable or the run fails the function returns an empty map
+// and the caller falls back to DefaultPowerLimitW. The calibration is skipped
+// gracefully — it must never block or fail the main benchmark.
+func runBenchmarkPowerCalibration(
+	ctx context.Context,
+	verboseLog, runDir string,
+	gpuIndices []int,
+	logFunc func(string),
+) map[int]float64 {
+	const calibDurationSec = 45
+
+	// dcgmi must be present.
+	if _, err := exec.LookPath("dcgmi"); err != nil {
+		logFunc("power calibration: dcgmi not found, skipping (will use default power limit)")
+		return map[int]float64{}
+	}
+
+	logFunc(fmt.Sprintf("power calibration: running dcgmi targeted_power for %ds on GPUs %s", calibDurationSec, joinIndexList(gpuIndices)))
+
+	cmd := nvidiaDCGMNamedDiagCommand("targeted_power", calibDurationSec, gpuIndices)
+	out, rows, err := runBenchmarkCommandWithMetrics(ctx, verboseLog, "power-calibration.log", cmd, nil, gpuIndices, runDir, "power-calibration", logFunc)
+	_ = os.WriteFile(filepath.Join(runDir, "power-calibration.log"), out, 0644)
+	if err != nil {
+		logFunc(fmt.Sprintf("power calibration: dcgmi targeted_power failed (%v), skipping", err))
+		return map[int]float64{}
+	}
+
+	// Group rows by GPU index and compute p95 power for each.
+	result := make(map[int]float64, len(gpuIndices))
+	for _, idx := range gpuIndices {
+		perGPU := filterRowsByGPU(rows, idx)
+		if len(perGPU) == 0 {
+			continue
+		}
+		powers := make([]float64, 0, len(perGPU))
+		for _, r := range perGPU {
+			if r.PowerW > 0 {
+				powers = append(powers, r.PowerW)
+			}
+		}
+		if len(powers) == 0 {
+			continue
+		}
+		p95 := benchmarkPercentile(powers, 95)
+		if p95 > 0 {
+			result[idx] = p95
+			logFunc(fmt.Sprintf("power calibration: GPU %d p95=%.0f W (%d samples)", idx, p95, len(powers)))
+		}
+	}
+	return result
+}

audit/internal/platform/benchmark_report.go

@@ -60,9 +60,17 @@ func renderBenchmarkReportWithCharts(result NvidiaBenchmarkResult, charts []benc
 	fmt.Fprintf(&b, "**Profile:** %s  \n", result.BenchmarkProfile)
 	fmt.Fprintf(&b, "**App version:** %s  \n", result.BenchmarkVersion)
 	fmt.Fprintf(&b, "**Generated:** %s  \n", result.GeneratedAt.Format("2006-01-02 15:04:05 UTC"))
-	if result.ParallelGPUs {
+	if result.RampStep > 0 && result.RampTotal > 0 {
+		fmt.Fprintf(&b, "**Ramp-up step:** %d of %d  \n", result.RampStep, result.RampTotal)
+		if result.RampRunID != "" {
+			fmt.Fprintf(&b, "**Ramp-up run ID:** %s  \n", result.RampRunID)
+		}
+	} else if result.ParallelGPUs {
 		fmt.Fprintf(&b, "**Mode:** parallel (all GPUs simultaneously)  \n")
 	}
+	if result.ScalabilityScore > 0 {
+		fmt.Fprintf(&b, "**Scalability score:** %.1f%%  \n", result.ScalabilityScore)
+	}
 	fmt.Fprintf(&b, "**Overall status:** %s  \n", result.OverallStatus)
 	b.WriteString("\n")
 

audit/internal/platform/benchmark_types.go

@@ -2,6 +2,29 @@ package platform
 
 import "time"
 
+// BenchmarkHostConfig holds static CPU and memory configuration captured at
+// benchmark start. Useful for correlating results across runs on different hardware.
+type BenchmarkHostConfig struct {
+	CPUModel    string  `json:"cpu_model,omitempty"`
+	CPUSockets  int     `json:"cpu_sockets,omitempty"`
+	CPUCores    int     `json:"cpu_cores,omitempty"`
+	CPUThreads  int     `json:"cpu_threads,omitempty"`
+	MemTotalGiB float64 `json:"mem_total_gib,omitempty"`
+}
+
+// BenchmarkCPULoad summarises host CPU utilisation sampled during the GPU
+// steady-state phase. High or unstable CPU load during a GPU benchmark may
+// indicate a competing workload or a CPU-bound driver bottleneck.
+type BenchmarkCPULoad struct {
+	AvgPct  float64 `json:"avg_pct"`
+	MaxPct  float64 `json:"max_pct"`
+	P95Pct  float64 `json:"p95_pct"`
+	Samples int     `json:"samples"`
+	// Status is "ok", "high", or "unstable".
+	Status string `json:"status"`
+	Note   string `json:"note,omitempty"`
+}
+
 const (
 	NvidiaBenchmarkProfileStandard  = "standard"
 	NvidiaBenchmarkProfileStability = "stability"
@@ -15,6 +38,9 @@ type NvidiaBenchmarkOptions struct {
 	ExcludeGPUIndices []int
 	RunNCCL           bool
 	ParallelGPUs      bool   // run all selected GPUs simultaneously instead of sequentially
+	RampStep          int    // 1-based step index within a ramp-up run (0 = not a ramp-up)
+	RampTotal         int    // total number of ramp-up steps in this run
+	RampRunID         string // shared identifier across all steps of the same ramp-up run
 }
 
 
@@ -25,11 +51,17 @@ type NvidiaBenchmarkResult struct {
 	ServerModel        string                       `json:"server_model,omitempty"`
 	BenchmarkProfile   string                       `json:"benchmark_profile"`
 	ParallelGPUs       bool                         `json:"parallel_gpus,omitempty"`
+	RampStep           int                          `json:"ramp_step,omitempty"`
+	RampTotal          int                          `json:"ramp_total,omitempty"`
+	RampRunID          string                       `json:"ramp_run_id,omitempty"`
+	ScalabilityScore   float64                      `json:"scalability_score,omitempty"`
 	OverallStatus      string                       `json:"overall_status"`
 	SelectedGPUIndices []int                        `json:"selected_gpu_indices"`
 	Findings           []string                     `json:"findings,omitempty"`
 	Warnings           []string                     `json:"warnings,omitempty"`
 	Normalization      BenchmarkNormalization       `json:"normalization"`
+	HostConfig         *BenchmarkHostConfig         `json:"host_config,omitempty"`
+	CPULoad            *BenchmarkCPULoad            `json:"cpu_load,omitempty"`
 	GPUs               []BenchmarkGPUResult         `json:"gpus"`
 	Interconnect       *BenchmarkInterconnectResult `json:"interconnect,omitempty"`
 	ServerPower        *BenchmarkServerPower        `json:"server_power,omitempty"`
@@ -63,6 +95,11 @@ type BenchmarkGPUResult struct {
 	PowerLimitW            float64                    `json:"power_limit_w,omitempty"`
 	MultiprocessorCount    int                        `json:"multiprocessor_count,omitempty"`
 	DefaultPowerLimitW     float64                    `json:"default_power_limit_w,omitempty"`
+	// CalibratedPeakPowerW is the p95 power measured during a short
+	// dcgmi targeted_power calibration run before the main benchmark.
+	// Used as the reference denominator for PowerSustainScore instead of
+	// the hardware default limit, which bee-gpu-burn cannot reach.
+	CalibratedPeakPowerW   float64                    `json:"calibrated_peak_power_w,omitempty"`
 	MaxGraphicsClockMHz    float64                    `json:"max_graphics_clock_mhz,omitempty"`
 	BaseGraphicsClockMHz   float64                    `json:"base_graphics_clock_mhz,omitempty"`
 	MaxMemoryClockMHz      float64                    `json:"max_memory_clock_mhz,omitempty"`

audit/internal/platform/install_to_ram.go

@@ -14,9 +14,17 @@ import (
 func (s *System) IsLiveMediaInRAM() bool {
 	fsType := mountFSType("/run/live/medium")
 	if fsType == "" {
+		// No medium mount at all — fall back to toram kernel parameter.
 		return toramActive()
 	}
-	return strings.EqualFold(fsType, "tmpfs")
+	if strings.EqualFold(fsType, "tmpfs") {
+		return true
+	}
+	// When RunInstallToRAM copies squashfs to /dev/shm/bee-live but the bind
+	// mount of /run/live/medium fails (common for CD-ROM boots), the medium
+	// fstype still shows the CD-ROM type. Check whether the RAM copy exists.
+	files, _ := filepath.Glob("/dev/shm/bee-live/*.squashfs")
+	return len(files) > 0
 }
 
 func (s *System) LiveBootSource() LiveBootSource {

audit/internal/platform/runtime.go

@@ -244,11 +244,17 @@ func findUSBExportMount() string {
 		if readOnly {
 			continue
 		}
-		// Check USB transport via lsblk on the device
+		// Check USB transport via lsblk on the device (or its parent disk for partitions).
 		if !strings.HasPrefix(device, "/dev/") {
 			continue
 		}
-		if blockDeviceTransport(device) == "usb" {
+		checkDev := device
+		// lsblk only reports TRAN for the whole disk, not for partitions (e.g. /dev/sdc1).
+		// Strip trailing partition digits to get the parent disk name.
+		if trimmed := strings.TrimRight(device, "0123456789"); trimmed != device && len(trimmed) > len("/dev/") {
+			checkDev = trimmed
+		}
+		if blockDeviceTransport(checkDev) == "usb" {
 			return mountPoint
 		}
 	}

audit/internal/webui/api.go

@@ -571,10 +571,18 @@ func (h *handler) handleAPIBenchmarkNvidiaRun(w http.ResponseWriter, r *http.Req
 	if body.RampUp != nil {
 		rampUp = *body.RampUp
 	}
+	// Build a descriptive base name that includes profile and mode so the task
+	// list is self-explanatory without opening individual task detail pages.
+	profile := strings.TrimSpace(body.Profile)
+	if profile == "" {
+		profile = "standard"
+	}
 	name := taskDisplayName("nvidia-benchmark", "", "")
 	if strings.TrimSpace(body.DisplayName) != "" {
 		name = body.DisplayName
 	}
+	// Append profile tag.
+	name = fmt.Sprintf("%s · %s", name, profile)
 
 	if rampUp && len(body.GPUIndices) > 1 {
 		// Ramp-up mode: resolve GPU list, then create one task per prefix
@@ -594,10 +602,11 @@ func (h *handler) handleAPIBenchmarkNvidiaRun(w http.ResponseWriter, r *http.Req
 			rampUp = false
 		} else {
 			now := time.Now()
+			rampRunID := fmt.Sprintf("ramp-%s", now.UTC().Format("20060102-150405"))
 			var allTasks []*Task
 			for step := 1; step <= len(resolved); step++ {
 				subset := resolved[:step]
-				stepName := fmt.Sprintf("%s [ramp %d/%d: GPU %s]", name, step, len(resolved), formatGPUIndexList(subset))
+				stepName := fmt.Sprintf("%s · ramp %d/%d · GPU %s", name, step, len(resolved), formatGPUIndexList(subset))
 				t := &Task{
 					ID:        newJobID("benchmark-nvidia"),
 					Name:      stepName,
@@ -611,6 +620,9 @@ func (h *handler) handleAPIBenchmarkNvidiaRun(w http.ResponseWriter, r *http.Req
 						BenchmarkProfile: body.Profile,
 						RunNCCL:          runNCCL && step == len(resolved),
 						ParallelGPUs:     true,
+						RampStep:         step,
+						RampTotal:        len(resolved),
+						RampRunID:        rampRunID,
 						DisplayName:      stepName,
 					},
 				}
@@ -624,6 +636,13 @@ func (h *handler) handleAPIBenchmarkNvidiaRun(w http.ResponseWriter, r *http.Req
 		}
 	}
 
+	// For non-ramp tasks append mode tag.
+	if parallelGPUs {
+		name = fmt.Sprintf("%s · parallel", name)
+	} else {
+		name = fmt.Sprintf("%s · sequential", name)
+	}
+
 	tasks, err := buildNvidiaTaskSet("nvidia-benchmark", 15, time.Now(), taskParams{
 		GPUIndices:        body.GPUIndices,
 		ExcludeGPUIndices: body.ExcludeGPUIndices,

audit/internal/webui/pages.go

@@ -330,6 +330,33 @@ func renderHardwareSummaryCard(opts HandlerOptions) string {
 
 	var b strings.Builder
 	b.WriteString(`<div class="card"><div class="card-head">Hardware Summary</div><div class="card-body">`)
+
+	// Server identity block above the component table.
+	{
+		var model, serial string
+		parts := []string{}
+		if hw.Board.Manufacturer != nil && strings.TrimSpace(*hw.Board.Manufacturer) != "" {
+			parts = append(parts, strings.TrimSpace(*hw.Board.Manufacturer))
+		}
+		if hw.Board.ProductName != nil && strings.TrimSpace(*hw.Board.ProductName) != "" {
+			parts = append(parts, strings.TrimSpace(*hw.Board.ProductName))
+		}
+		if len(parts) > 0 {
+			model = strings.Join(parts, " ")
+		}
+		serial = strings.TrimSpace(hw.Board.SerialNumber)
+		if model != "" || serial != "" {
+			b.WriteString(`<div style="margin-bottom:14px">`)
+			if model != "" {
+				fmt.Fprintf(&b, `<div style="font-size:16px;font-weight:700;margin-bottom:2px">%s</div>`, html.EscapeString(model))
+			}
+			if serial != "" {
+				fmt.Fprintf(&b, `<div style="font-size:12px;color:var(--muted)">S/N: %s</div>`, html.EscapeString(serial))
+			}
+			b.WriteString(`</div>`)
+		}
+	}
+
 	b.WriteString(`<table style="width:auto">`)
 	writeRow := func(label, value, badgeHTML string) {
 		b.WriteString(fmt.Sprintf(`<tr><td style="padding:6px 14px 6px 0;font-weight:700;white-space:nowrap">%s</td><td style="padding:6px 0;color:var(--muted);font-size:13px">%s</td><td style="padding:6px 0 6px 12px">%s</td></tr>`,
@@ -1279,9 +1306,6 @@ func renderValidate(opts HandlerOptions) string {
 	<div class="card" style="margin-bottom:16px">
 	  <div class="card-head">Validate Profile</div>
 	  <div class="card-body validate-profile-body">
-	    <div class="validate-profile-col">
-	      <div class="form-row" style="margin:0"><label>Cycles</label><input type="number" id="sat-cycles" value="1" min="1" max="100" style="width:100%"></div>
-	    </div>
 	    <div class="validate-profile-col">
 	      <div class="form-row" style="margin:12px 0 0"><label>Mode</label></div>
 	      <label class="cb-row"><input type="radio" name="sat-mode" id="sat-mode-validate" value="validate" checked onchange="satModeChanged()"><span>Validate — quick non-destructive check</span></label>
@@ -1331,12 +1355,6 @@ func renderValidate(opts HandlerOptions) string {
       <p style="color:var(--muted);font-size:13px">Loading NVIDIA GPUs...</p>
     </div>
     <p id="sat-gpu-selection-note" style="font-size:12px;color:var(--muted);margin:10px 0 0">Select at least one NVIDIA GPU to enable NVIDIA validate tasks.</p>
-    <div style="margin-top:10px;padding-top:10px;border-top:1px solid var(--border)">
-      <label class="sat-gpu-row" title="When checked, multi-GPU tests (PSU Pulse, NCCL, NVBandwidth) run on ALL GPUs in the system regardless of the selection above.">
-        <input type="checkbox" id="sat-multi-gpu-all" checked onchange="satUpdateGPUSelectionNote()">
-        <span><strong>Multi-GPU tests</strong> — use all GPUs <span style="font-size:11px;color:var(--muted)">(PSU Pulse, NCCL, NVBandwidth)</span></span>
-      </label>
-    </div>
   </div>
 </div>
 
@@ -1455,10 +1473,6 @@ function satSelectedGPUIndices() {
     .filter(function(v) { return !Number.isNaN(v); })
     .sort(function(a, b) { return a - b; });
 }
-function satMultiGPUAll() {
-  const cb = document.getElementById('sat-multi-gpu-all');
-  return cb ? cb.checked : true;
-}
 function satUpdateGPUSelectionNote() {
   const note = document.getElementById('sat-gpu-selection-note');
   if (!note) return;
@@ -1467,8 +1481,7 @@ function satUpdateGPUSelectionNote() {
     note.textContent = 'Select at least one NVIDIA GPU to enable NVIDIA validate tasks.';
     return;
   }
-  const multiAll = satMultiGPUAll();
-  note.textContent = 'Selected GPUs: ' + selected.join(', ') + '. Multi-GPU tests: ' + (multiAll ? 'all GPUs in system' : 'selected GPUs only') + '.';
+  note.textContent = 'Selected GPUs: ' + selected.join(', ') + '. Multi-GPU tests will use all selected GPUs.';
 }
 function satRenderGPUList(gpus) {
   const root = document.getElementById('sat-gpu-list');
@@ -1582,15 +1595,8 @@ const nvidiaPerGPUTargets = ['nvidia', 'nvidia-targeted-stress', 'nvidia-targete
 // pulse_test and fabric tests run on all selected GPUs simultaneously
 const nvidiaAllGPUTargets = ['nvidia-pulse', 'nvidia-interconnect', 'nvidia-bandwidth'];
 function satAllGPUIndicesForMulti() {
-  // If "Multi-GPU tests — all GPUs" is checked, return all detected GPUs.
-  // Otherwise fall back to the per-GPU selection.
-  if (satMultiGPUAll()) {
-    return loadSatNvidiaGPUs().then(function(gpus) {
-      return gpus.map(function(g) { return Number(g.index); });
-    });
-  }
-  const sel = satSelectedGPUIndices();
-  return Promise.resolve(sel);
+  // Multi-GPU tests always use the current GPU selection.
+  return Promise.resolve(satSelectedGPUIndices());
 }
 function expandSATTarget(target) {
   if (nvidiaAllGPUTargets.indexOf(target) >= 0) {
@@ -1680,7 +1686,7 @@ function runAMDValidateSet() {
   return runNext(0);
 }
 function runAllSAT() {
-  const cycles = Math.max(1, parseInt(document.getElementById('sat-cycles').value)||1);
+  const cycles = 1;
   const status = document.getElementById('sat-all-status');
   status.textContent = 'Enqueuing...';
   const stressOnlyTargets = ['nvidia-targeted-stress', 'nvidia-targeted-power', 'nvidia-pulse', 'nvidia-interconnect', 'nvidia-bandwidth'];
@@ -1967,16 +1973,16 @@ func renderBenchmark(opts HandlerOptions) string {
         </div>
       </div>
       <label class="benchmark-cb-row">
-        <input type="checkbox" id="benchmark-ramp-up" checked onchange="benchmarkUpdateSelectionNote()">
-        <span>Ramp-up mode: run 1 GPU, then 2, then 3… up to all selected GPUs (each step is a separate task)</span>
+        <input type="radio" name="benchmark-mode" value="sequential" onchange="benchmarkUpdateSelectionNote()">
+        <span>Sequential — one GPU at a time</span>
       </label>
-      <label class="benchmark-cb-row">
-        <input type="checkbox" id="benchmark-parallel-gpus">
-        <span>Run all selected GPUs simultaneously (parallel mode, ignored in ramp-up)</span>
+      <label class="benchmark-cb-row" id="benchmark-parallel-label">
+        <input type="radio" name="benchmark-mode" value="parallel" onchange="benchmarkUpdateSelectionNote()">
+        <span>Parallel — all selected GPUs simultaneously</span>
       </label>
-      <label class="benchmark-cb-row">
-        <input type="checkbox" id="benchmark-run-nccl" checked>
-        <span>Run multi-GPU interconnect step (NCCL) only on the selected GPUs</span>
+      <label class="benchmark-cb-row" id="benchmark-ramp-label">
+        <input type="radio" name="benchmark-mode" value="ramp-up" checked onchange="benchmarkUpdateSelectionNote()">
+        <span>Ramp-up — 1 GPU → 2 → … → all selected (separate tasks)</span>
       </label>
       <p id="benchmark-selection-note" style="font-size:12px;color:var(--muted);margin:10px 0 14px">Select one GPU for single-card benchmarking or several GPUs for a constrained multi-GPU run.</p>
       <button id="benchmark-run-btn" class="btn btn-primary" onclick="runNvidiaBenchmark()" disabled>&#9654; Run Benchmark</button>
@@ -2029,27 +2035,28 @@ function benchmarkSelectedGPUIndices() {
     .sort(function(a, b) { return a - b; });
 }
 
+function benchmarkMode() {
+  const el = document.querySelector('input[name="benchmark-mode"]:checked');
+  return el ? el.value : 'sequential';
+}
+
 function benchmarkUpdateSelectionNote() {
   const selected = benchmarkSelectedGPUIndices();
   const btn = document.getElementById('benchmark-run-btn');
   const note = document.getElementById('benchmark-selection-note');
-  const nccl = document.getElementById('benchmark-run-nccl');
   if (!selected.length) {
     btn.disabled = true;
     note.textContent = 'Select at least one NVIDIA GPU to run the benchmark.';
     return;
   }
   btn.disabled = false;
-  const rampUp = selected.length > 1 && !!document.getElementById('benchmark-ramp-up').checked;
-  if (rampUp) {
-    note.textContent = 'Ramp-up: will spawn ' + selected.length + ' tasks (1 GPU → ' + selected.length + ' GPUs). NCCL runs on the final step only.';
+  const mode = benchmarkMode();
+  if (mode === 'ramp-up') {
+    note.textContent = 'Ramp-up: ' + selected.length + ' tasks (1 GPU → ' + selected.length + ' GPUs). NCCL on final step.';
+  } else if (mode === 'parallel') {
+    note.textContent = 'Parallel: all ' + selected.length + ' GPU(s) simultaneously.' + (selected.length > 1 ? ' NCCL included.' : '');
   } else {
-    note.textContent = 'Selected GPUs: ' + selected.join(', ') + '.';
-    if (nccl && nccl.checked && selected.length < 2) {
-      note.textContent += ' NCCL will be skipped because fewer than 2 GPUs are selected.';
-    } else if (nccl && nccl.checked) {
-      note.textContent += ' NCCL interconnect will use only these GPUs.';
-    }
+    note.textContent = 'Sequential: each GPU benchmarked separately.' + (selected.length > 1 ? ' NCCL included on each.' : '');
   }
 }
 
@@ -2067,6 +2074,33 @@ function benchmarkRenderGPUList(gpus) {
       + '<span><strong>GPU ' + gpu.index + '</strong> — ' + gpu.name + mem + '</span>'
       + '</label>';
   }).join('');
+  benchmarkApplyMultiGPUState(gpus.length);
+  benchmarkUpdateSelectionNote();
+}
+
+// Disable radio options that require multiple GPUs when only one is present.
+function benchmarkApplyMultiGPUState(gpuCount) {
+  var multiValues = ['parallel', 'ramp-up'];
+  var radios = document.querySelectorAll('input[name="benchmark-mode"]');
+  radios.forEach(function(el) {
+    var isMulti = multiValues.indexOf(el.value) >= 0;
+    if (gpuCount < 2 && isMulti) {
+      el.disabled = true;
+      if (el.checked) {
+        // fall back to sequential
+        var seq = document.querySelector('input[name="benchmark-mode"][value="sequential"]');
+        if (seq) seq.checked = true;
+      }
+      var label = el.closest('label');
+      if (label) label.style.opacity = '0.4';
+    } else {
+      el.disabled = false;
+      // restore default: ramp-up checked when ≥2 GPUs
+      if (gpuCount >= 2 && el.value === 'ramp-up') el.checked = true;
+      var label = el.closest('label');
+      if (label) label.style.opacity = '';
+    }
+  });
   benchmarkUpdateSelectionNote();
 }
 
@@ -2104,12 +2138,13 @@ function runNvidiaBenchmark() {
     return;
   }
   if (benchmarkES) { benchmarkES.close(); benchmarkES = null; }
-  const rampUp = selected.length > 1 && !!document.getElementById('benchmark-ramp-up').checked;
-  const parallelGPUs = !rampUp && !!document.getElementById('benchmark-parallel-gpus').checked;
+  const mode = benchmarkMode();
+  const rampUp = mode === 'ramp-up' && selected.length > 1;
+  const parallelGPUs = mode === 'parallel';
   const body = {
     profile: document.getElementById('benchmark-profile').value || 'standard',
     gpu_indices: selected,
-    run_nccl: !!document.getElementById('benchmark-run-nccl').checked,
+    run_nccl: selected.length > 1,
     parallel_gpus: parallelGPUs,
     ramp_up: rampUp,
     display_name: 'NVIDIA Benchmark'
@@ -2166,7 +2201,6 @@ function runNvidiaBenchmark() {
   });
 }
 
-document.getElementById('benchmark-run-nccl').addEventListener('change', benchmarkUpdateSelectionNote);
 benchmarkLoadGPUs();
 </script>`
 }
@@ -2382,10 +2416,20 @@ func renderBurn() string {
 	      <p style="color:var(--muted);font-size:13px">Loading NVIDIA GPUs...</p>
 	    </div>
 	    <p id="burn-selection-note" style="font-size:12px;color:var(--muted);margin:10px 0 0">Select at least one NVIDIA GPU to enable NVIDIA burn recipes.</p>
-	    <label class="cb-row" style="margin-top:10px">
-	      <input type="checkbox" id="burn-stagger-nvidia">
-	      <span>Ramp selected NVIDIA GPUs one by one before the full-load hold. Smoke: +2 min per GPU, then 5 min with all selected GPUs under load. Acceptance: +10 min per GPU, then at least 1 hour with all selected GPUs under load. Overnight: +1 hour per GPU, then at least 1 hour with all selected GPUs under load, capped at 10 hours total.</span>
+	    <div style="display:flex;flex-direction:column;gap:4px;margin-top:10px">
+	      <label class="cb-row">
+	        <input type="radio" name="burn-nvidia-mode" value="sequential" checked>
+	        <span>Sequential — selected GPUs one at a time</span>
 	      </label>
+	      <label class="cb-row" id="burn-parallel-label">
+	        <input type="radio" name="burn-nvidia-mode" value="parallel">
+	        <span>Parallel — all selected GPUs simultaneously</span>
+	      </label>
+	      <label class="cb-row" id="burn-ramp-label">
+	        <input type="radio" name="burn-nvidia-mode" value="ramp-up">
+	        <span>Ramp-up — add one GPU at a time</span>
+	      </label>
+	    </div>
 	  </div>
 	</div>
 
@@ -2461,9 +2505,30 @@ function burnSelectedGPUIndices() {
     .sort(function(a, b) { return a - b; });
 }
 
-function burnUseNvidiaRampUp() {
-  const el = document.getElementById('burn-stagger-nvidia');
-  return !!(el && el.checked);
+function burnNvidiaMode() {
+  const el = document.querySelector('input[name="burn-nvidia-mode"]:checked');
+  return el ? el.value : 'sequential';
+}
+
+function burnApplyMultiGPUState(gpuCount) {
+  var multiValues = ['parallel', 'ramp-up'];
+  var radios = document.querySelectorAll('input[name="burn-nvidia-mode"]');
+  radios.forEach(function(el) {
+    var isMulti = multiValues.indexOf(el.value) >= 0;
+    if (gpuCount < 2 && isMulti) {
+      el.disabled = true;
+      if (el.checked) {
+        var seq = document.querySelector('input[name="burn-nvidia-mode"][value="sequential"]');
+        if (seq) seq.checked = true;
+      }
+      var label = el.closest('label');
+      if (label) label.style.opacity = '0.4';
+    } else {
+      el.disabled = false;
+      var label = el.closest('label');
+      if (label) label.style.opacity = '';
+    }
+  });
 }
 
 function burnUpdateSelectionNote() {
@@ -2490,6 +2555,7 @@ function burnRenderGPUList(gpus) {
       + '<span><strong>GPU ' + gpu.index + '</strong> — ' + gpu.name + mem + '</span>'
       + '</label>';
   }).join('');
+  burnApplyMultiGPUState(gpus.length);
   burnUpdateSelectionNote();
 }
 
@@ -2525,8 +2591,11 @@ function enqueueBurnTask(target, label, extra, useSelectedNvidia) {
       return Promise.reject(new Error('Select at least one NVIDIA GPU.'));
     }
     body.gpu_indices = selected;
-    if (burnUseNvidiaRampUp() && selected.length > 1) {
+    const bMode = burnNvidiaMode();
+    if (bMode === 'ramp-up' && selected.length > 1) {
       body.stagger_gpu_start = true;
+    } else if (bMode === 'parallel' && selected.length > 1) {
+      body.parallel_gpus = true;
     }
   }
   return fetch('/api/sat/' + target + '/run', {

audit/internal/webui/tasks.go

@@ -126,6 +126,9 @@ type taskParams struct {
 	BenchmarkProfile   string   `json:"benchmark_profile,omitempty"`
 	RunNCCL            bool     `json:"run_nccl,omitempty"`
 	ParallelGPUs       bool     `json:"parallel_gpus,omitempty"`
+	RampStep           int      `json:"ramp_step,omitempty"`
+	RampTotal          int      `json:"ramp_total,omitempty"`
+	RampRunID          string   `json:"ramp_run_id,omitempty"`
 	DisplayName        string   `json:"display_name,omitempty"`
 	Device             string   `json:"device,omitempty"` // for install
 	PlatformComponents []string `json:"platform_components,omitempty"`
@@ -637,6 +640,9 @@ func (q *taskQueue) runTask(t *Task, j *jobState, ctx context.Context) {
 			ExcludeGPUIndices: t.params.ExcludeGPUIndices,
 			RunNCCL:           t.params.RunNCCL,
 			ParallelGPUs:      t.params.ParallelGPUs,
+			RampStep:          t.params.RampStep,
+			RampTotal:         t.params.RampTotal,
+			RampRunID:         t.params.RampRunID,
 		}, j.append)
 	case "nvidia-compute":
 		if a == nil {