1. Verbose live progress during SAT tests (CPU, Memory, Storage, AMD GPU)

- New tui/sat_progress.go: polls {DefaultSATBaseDir}/{prefix}-*/verbose.log every 300ms and parses completed/in-progress steps
  - Busy screen now shows each step as PASS  lscpu (234ms) / FAIL  stress-ng (60.0s) / ...   sensors-after instead of just "Working..."

  2. Test results shown on screen (instead of just "Archive written to /path")
  - RunCPUAcceptancePackResult, RunMemoryAcceptancePackResult, RunStorageAcceptancePackResult, RunAMDAcceptancePackResult now read summary.txt from the run directory and return a formatted per-step result:
  Run: 2025-03-25T10:00:00Z

  PASS  lscpu
  PASS  sensors-before
  FAIL  stress-ng
  PASS  sensors-after

  Overall: FAILED  (ok=3  failed=1)

  3. AMD GPU SAT with auto-detection
  - platform.System.DetectGPUVendor(): checks /dev/nvidia0 → "nvidia", /dev/kfd → "amd"
  - platform.System.RunAMDAcceptancePack(): runs rocm-smi, rocm-smi --showallinfo, dmidecode
  - GPU SAT (G key / GPU row enter) automatically routes to AMD or NVIDIA based on detected vendor
  - "Run All" also auto-detects vendor

  4. Panel detail view
  - GPU detail now shows the most recent (NVIDIA or AMD) SAT result, whichever is newer
  - All SAT detail views use the same human-readable formatSATDetail format

audit/cmd/bee/main.go

@@ -70,7 +70,7 @@ func printRootUsage(w io.Writer) {
   bee export  --target <device>
   bee support-bundle --output stdout|file:<path>
   bee web     --listen :80 --audit-path `+app.DefaultAuditJSONPath+`
-  bee sat nvidia|memory|storage
+  bee sat nvidia|memory|storage|cpu [--duration <seconds>]
   bee version
   bee help [command]`)
 }
@@ -346,43 +346,58 @@ func runWeb(args []string, stdout, stderr io.Writer) int {
 
 func runSAT(args []string, stdout, stderr io.Writer) int {
 	if len(args) == 0 {
-		fmt.Fprintln(stderr, "usage: bee sat nvidia|memory|storage")
+		fmt.Fprintln(stderr, "usage: bee sat nvidia|memory|storage|cpu [--duration <seconds>]")
 		return 2
 	}
 	if args[0] == "help" || args[0] == "--help" || args[0] == "-h" {
-		fmt.Fprintln(stdout, "usage: bee sat nvidia|memory|storage")
+		fmt.Fprintln(stdout, "usage: bee sat nvidia|memory|storage|cpu [--duration <seconds>]")
 		return 0
 	}
-	if args[0] != "nvidia" && args[0] != "memory" && args[0] != "storage" {
-		fmt.Fprintf(stderr, "bee sat: unknown target %q\n", args[0])
-		fmt.Fprintln(stderr, "usage: bee sat nvidia|memory|storage")
+
+	fs := flag.NewFlagSet("sat", flag.ContinueOnError)
+	fs.SetOutput(stderr)
+	duration := fs.Int("duration", 0, "stress-ng duration in seconds (cpu only; default: 60)")
+	if err := fs.Parse(args[1:]); err != nil {
+		if err == flag.ErrHelp {
+			return 0
+		}
 		return 2
 	}
-	if len(args) > 1 {
-		fmt.Fprintln(stderr, "usage: bee sat nvidia|memory|storage")
+	if fs.NArg() != 0 {
+		fmt.Fprintf(stderr, "bee sat: unexpected arguments\n")
 		return 2
 	}
+
+	target := args[0]
+	if target != "nvidia" && target != "memory" && target != "storage" && target != "cpu" {
+		fmt.Fprintf(stderr, "bee sat: unknown target %q\n", target)
+		fmt.Fprintln(stderr, "usage: bee sat nvidia|memory|storage|cpu [--duration <seconds>]")
+		return 2
+	}
+
 	application := app.New(platform.New())
 	var (
 		archive string
 		err     error
-		label   string
 	)
-	switch args[0] {
+	switch target {
 	case "nvidia":
-		label = "nvidia"
 		archive, err = application.RunNvidiaAcceptancePack("")
 	case "memory":
-		label = "memory"
 		archive, err = application.RunMemoryAcceptancePack("")
 	case "storage":
-		label = "storage"
 		archive, err = application.RunStorageAcceptancePack("")
+	case "cpu":
+		dur := *duration
+		if dur <= 0 {
+			dur = 60
+		}
+		archive, err = application.RunCPUAcceptancePack("", dur)
 	}
 	if err != nil {
-		slog.Error("run sat", "target", label, "err", err)
+		slog.Error("run sat", "target", target, "err", err)
 		return 1
 	}
-	slog.Info("sat archive written", "target", label, "path", archive)
+	slog.Info("sat archive written", "target", target, "path", archive)
 	return 0
 }

audit/cmd/bee/main_test.go

@@ -164,7 +164,7 @@ func TestRunSATHelp(t *testing.T) {
 	if rc != 0 {
 		t.Fatalf("rc=%d want 0", rc)
 	}
-	if !strings.Contains(stdout.String(), "usage: bee sat nvidia|memory|storage") {
+	if !strings.Contains(stdout.String(), "usage: bee sat nvidia|memory|storage|cpu") {
 		t.Fatalf("stdout missing sat help:\n%s", stdout.String())
 	}
 }
@@ -177,8 +177,8 @@ func TestRunSATRejectsExtraArgs(t *testing.T) {
 	if rc != 2 {
 		t.Fatalf("rc=%d want 2", rc)
 	}
-	if !strings.Contains(stderr.String(), "usage: bee sat nvidia|memory|storage") {
-		t.Fatalf("stderr missing sat usage:\n%s", stderr.String())
+	if !strings.Contains(stderr.String(), "bee sat: unexpected arguments") {
+		t.Fatalf("stderr missing sat error:\n%s", stderr.String())
 	}
 }
 

audit/go.mod

@@ -5,11 +5,12 @@ go 1.24.0
 replace reanimator/chart => ../internal/chart
 
 require github.com/charmbracelet/bubbletea v1.3.4
+require github.com/charmbracelet/lipgloss v1.0.0
 require reanimator/chart v0.0.0
 
 require (
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
-	github.com/charmbracelet/lipgloss v1.0.0 // indirect
+	github.com/charmbracelet/lipgloss v1.0.0 // promoted to direct — used for TUI colors
 	github.com/charmbracelet/x/ansi v0.8.0 // indirect
 	github.com/charmbracelet/x/term v0.2.1 // indirect
 	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect

audit/internal/app/app.go

@@ -75,7 +75,11 @@ type satRunner interface {
 	RunNvidiaAcceptancePackWithOptions(ctx context.Context, baseDir string, durationSec int, sizeMB int, gpuIndices []int) (string, error)
 	RunMemoryAcceptancePack(baseDir string) (string, error)
 	RunStorageAcceptancePack(baseDir string) (string, error)
+	RunCPUAcceptancePack(baseDir string, durationSec int) (string, error)
 	ListNvidiaGPUs() ([]platform.NvidiaGPU, error)
+	DetectGPUVendor() string
+	ListAMDGPUs() ([]platform.AMDGPUInfo, error)
+	RunAMDAcceptancePack(baseDir string) (string, error)
 }
 
 type runtimeChecker interface {
@@ -430,11 +434,19 @@ func (a *App) RunMemoryAcceptancePack(baseDir string) (string, error) {
 
 func (a *App) RunMemoryAcceptancePackResult(baseDir string) (ActionResult, error) {
 	path, err := a.RunMemoryAcceptancePack(baseDir)
-	body := "Archive written."
-	if path != "" {
-		body = "Archive written to " + path
+	return ActionResult{Title: "Memory SAT", Body: satResultBody(path)}, err
+}
+
+func (a *App) RunCPUAcceptancePack(baseDir string, durationSec int) (string, error) {
+	if strings.TrimSpace(baseDir) == "" {
+		baseDir = DefaultSATBaseDir
 	}
-	return ActionResult{Title: "Memory SAT", Body: body}, err
+	return a.sat.RunCPUAcceptancePack(baseDir, durationSec)
+}
+
+func (a *App) RunCPUAcceptancePackResult(baseDir string, durationSec int) (ActionResult, error) {
+	path, err := a.RunCPUAcceptancePack(baseDir, durationSec)
+	return ActionResult{Title: "CPU SAT", Body: satResultBody(path)}, err
 }
 
 func (a *App) RunStorageAcceptancePack(baseDir string) (string, error) {
@@ -446,11 +458,41 @@ func (a *App) RunStorageAcceptancePack(baseDir string) (string, error) {
 
 func (a *App) RunStorageAcceptancePackResult(baseDir string) (ActionResult, error) {
 	path, err := a.RunStorageAcceptancePack(baseDir)
-	body := "Archive written."
-	if path != "" {
-		body = "Archive written to " + path
+	return ActionResult{Title: "Storage SAT", Body: satResultBody(path)}, err
+}
+
+func (a *App) DetectGPUVendor() string {
+	return a.sat.DetectGPUVendor()
+}
+
+func (a *App) ListAMDGPUs() ([]platform.AMDGPUInfo, error) {
+	return a.sat.ListAMDGPUs()
+}
+
+func (a *App) RunAMDAcceptancePack(baseDir string) (string, error) {
+	if strings.TrimSpace(baseDir) == "" {
+		baseDir = DefaultSATBaseDir
 	}
-	return ActionResult{Title: "Storage SAT", Body: body}, err
+	return a.sat.RunAMDAcceptancePack(baseDir)
+}
+
+func (a *App) RunAMDAcceptancePackResult(baseDir string) (ActionResult, error) {
+	path, err := a.RunAMDAcceptancePack(baseDir)
+	return ActionResult{Title: "AMD GPU SAT", Body: satResultBody(path)}, err
+}
+
+// satResultBody reads summary.txt from the SAT run directory (archive path without .tar.gz)
+// and returns a formatted human-readable result. Falls back to a plain message if unreadable.
+func satResultBody(archivePath string) string {
+	if archivePath == "" {
+		return "No output produced."
+	}
+	runDir := strings.TrimSuffix(archivePath, ".tar.gz")
+	raw, err := os.ReadFile(filepath.Join(runDir, "summary.txt"))
+	if err != nil {
+		return "Archive written to " + archivePath
+	}
+	return formatSATDetail(strings.TrimSpace(string(raw)))
 }
 
 func (a *App) HealthSummaryResult() ActionResult {
@@ -592,6 +634,7 @@ func latestSATSummaries() []string {
 		{label: "NVIDIA SAT", prefix: "gpu-nvidia-"},
 		{label: "Memory SAT", prefix: "memory-"},
 		{label: "Storage SAT", prefix: "storage-"},
+		{label: "CPU SAT", prefix: "cpu-"},
 	}
 	var out []string
 	for _, item := range patterns {
@@ -796,12 +839,17 @@ func isGPUDevice(dev schema.HardwarePCIeDevice) bool {
 	class := trimPtr(dev.DeviceClass)
 	model := strings.ToLower(trimPtr(dev.Model))
 	vendor := strings.ToLower(trimPtr(dev.Manufacturer))
+	// Exclude ASPEED (BMC VGA adapter, not a compute GPU)
+	if strings.Contains(vendor, "aspeed") || strings.Contains(model, "aspeed") {
+		return false
+	}
+	// AMD Instinct / Radeon compute GPUs have class ProcessingAccelerator or DisplayController.
+	// Do NOT match by AMD vendor alone — chipset/CPU PCIe devices share that vendor.
 	return class == "VideoController" ||
 		class == "DisplayController" ||
 		class == "ProcessingAccelerator" ||
 		strings.Contains(model, "nvidia") ||
-		strings.Contains(vendor, "nvidia") ||
-		strings.Contains(vendor, "amd")
+		strings.Contains(vendor, "nvidia")
 }
 
 func trimPtr(value *string) string {

audit/internal/app/app_test.go

@@ -100,6 +100,7 @@ type fakeSAT struct {
 	runNvidiaFn  func(string) (string, error)
 	runMemoryFn  func(string) (string, error)
 	runStorageFn func(string) (string, error)
+	runCPUFn     func(string, int) (string, error)
 }
 
 func (f fakeSAT) RunNvidiaAcceptancePack(baseDir string) (string, error) {
@@ -122,6 +123,19 @@ func (f fakeSAT) RunStorageAcceptancePack(baseDir string) (string, error) {
 	return f.runStorageFn(baseDir)
 }
 
+func (f fakeSAT) RunCPUAcceptancePack(baseDir string, durationSec int) (string, error) {
+	if f.runCPUFn != nil {
+		return f.runCPUFn(baseDir, durationSec)
+	}
+	return "", nil
+}
+
+func (f fakeSAT) DetectGPUVendor() string { return "" }
+
+func (f fakeSAT) ListAMDGPUs() ([]platform.AMDGPUInfo, error) { return nil, nil }
+
+func (f fakeSAT) RunAMDAcceptancePack(baseDir string) (string, error) { return "", nil }
+
 func TestNetworkStatusFormatsInterfacesAndRoute(t *testing.T) {
 	t.Parallel()
 
@@ -372,10 +386,10 @@ func TestActionResultsUseFallbackBody(t *testing.T) {
 	if got, _ := a.RunNvidiaAcceptancePackResult(""); got.Body != "Archive written." {
 		t.Fatalf("sat body=%q", got.Body)
 	}
-	if got, _ := a.RunMemoryAcceptancePackResult(""); got.Body != "Archive written." {
+	if got, _ := a.RunMemoryAcceptancePackResult(""); got.Body != "No output produced." {
 		t.Fatalf("memory sat body=%q", got.Body)
 	}
-	if got, _ := a.RunStorageAcceptancePackResult(""); got.Body != "Archive written." {
+	if got, _ := a.RunStorageAcceptancePackResult(""); got.Body != "No output produced." {
 		t.Fatalf("storage sat body=%q", got.Body)
 	}
 }

audit/internal/app/panel.go

@@ -0,0 +1,387 @@
+package app
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"bee/audit/internal/schema"
+)
+
+// ComponentRow is one line in the hardware panel.
+type ComponentRow struct {
+	Key    string // "CPU", "MEM", "GPU", "DISK", "PSU"
+	Status string // "PASS", "FAIL", "CANCEL", "N/A"
+	Detail string // compact one-liner
+}
+
+// HardwarePanelData holds everything the TUI right panel needs.
+type HardwarePanelData struct {
+	Header []string
+	Rows   []ComponentRow
+}
+
+// LoadHardwarePanel reads the latest audit JSON and SAT summaries.
+// Returns empty panel if no audit data exists yet.
+func (a *App) LoadHardwarePanel() HardwarePanelData {
+	raw, err := os.ReadFile(DefaultAuditJSONPath)
+	if err != nil {
+		return HardwarePanelData{Header: []string{"No audit data — run audit first."}}
+	}
+	var snap schema.HardwareIngestRequest
+	if err := json.Unmarshal(raw, &snap); err != nil {
+		return HardwarePanelData{Header: []string{"Audit data unreadable."}}
+	}
+
+	statuses := satStatuses()
+
+	var header []string
+	if sys := formatSystemLine(snap.Hardware.Board); sys != "" {
+		header = append(header, sys)
+	}
+	for _, fw := range snap.Hardware.Firmware {
+		if fw.DeviceName == "BIOS" && fw.Version != "" {
+			header = append(header, "BIOS: "+fw.Version)
+		}
+		if fw.DeviceName == "BMC" && fw.Version != "" {
+			header = append(header, "BMC:  "+fw.Version)
+		}
+	}
+	if ip := formatIPLine(a.network.ListInterfaces); ip != "" {
+		header = append(header, ip)
+	}
+
+	var rows []ComponentRow
+
+	if cpu := formatCPULine(snap.Hardware.CPUs); cpu != "" {
+		rows = append(rows, ComponentRow{
+			Key:    "CPU",
+			Status: statuses["cpu"],
+			Detail: strings.TrimPrefix(cpu, "CPU: "),
+		})
+	}
+	if mem := formatMemoryLine(snap.Hardware.Memory); mem != "" {
+		rows = append(rows, ComponentRow{
+			Key:    "MEM",
+			Status: statuses["memory"],
+			Detail: strings.TrimPrefix(mem, "Memory: "),
+		})
+	}
+	if gpu := formatGPULine(snap.Hardware.PCIeDevices); gpu != "" {
+		rows = append(rows, ComponentRow{
+			Key:    "GPU",
+			Status: statuses["gpu"],
+			Detail: strings.TrimPrefix(gpu, "GPU: "),
+		})
+	}
+	if disk := formatStorageLine(snap.Hardware.Storage); disk != "" {
+		rows = append(rows, ComponentRow{
+			Key:    "DISK",
+			Status: statuses["storage"],
+			Detail: strings.TrimPrefix(disk, "Storage: "),
+		})
+	}
+	if psu := formatPSULine(snap.Hardware.PowerSupplies); psu != "" {
+		rows = append(rows, ComponentRow{
+			Key:    "PSU",
+			Status: "N/A",
+			Detail: psu,
+		})
+	}
+
+	return HardwarePanelData{Header: header, Rows: rows}
+}
+
+// ComponentDetailResult returns detail text for a component shown in the panel.
+func (a *App) ComponentDetailResult(key string) ActionResult {
+	switch key {
+	case "CPU":
+		return a.cpuDetailResult(false)
+	case "MEM":
+		return a.satDetailResult("memory", "memory-", "MEM detail")
+	case "GPU":
+		// Prefer whichever GPU SAT was run most recently.
+		nv, _ := filepath.Glob(filepath.Join(DefaultSATBaseDir, "gpu-nvidia-*/summary.txt"))
+		am, _ := filepath.Glob(filepath.Join(DefaultSATBaseDir, "gpu-amd-*/summary.txt"))
+		sort.Strings(nv)
+		sort.Strings(am)
+		latestNV := ""
+		if len(nv) > 0 {
+			latestNV = nv[len(nv)-1]
+		}
+		latestAM := ""
+		if len(am) > 0 {
+			latestAM = am[len(am)-1]
+		}
+		if latestAM > latestNV {
+			return a.satDetailResult("gpu", "gpu-amd-", "GPU detail")
+		}
+		return a.satDetailResult("gpu", "gpu-nvidia-", "GPU detail")
+	case "DISK":
+		return a.satDetailResult("storage", "storage-", "DISK detail")
+	case "PSU":
+		return a.psuDetailResult()
+	default:
+		return ActionResult{Title: key, Body: "No detail available."}
+	}
+}
+
+func (a *App) cpuDetailResult(satOnly bool) ActionResult {
+	var b strings.Builder
+
+	// Show latest SAT summary if available.
+	satResult := a.satDetailResult("cpu", "cpu-", "CPU SAT")
+	if satResult.Body != "No test results found. Run a test first." {
+		fmt.Fprintln(&b, "=== Last SAT ===")
+		fmt.Fprintln(&b, satResult.Body)
+		fmt.Fprintln(&b)
+	}
+
+	if satOnly {
+		body := strings.TrimSpace(b.String())
+		if body == "" {
+			body = "No CPU SAT results found. Run a test first."
+		}
+		return ActionResult{Title: "CPU SAT", Body: body}
+	}
+
+	raw, err := os.ReadFile(DefaultAuditJSONPath)
+	if err != nil {
+		return ActionResult{Title: "CPU", Body: strings.TrimSpace(b.String())}
+	}
+	var snap schema.HardwareIngestRequest
+	if err := json.Unmarshal(raw, &snap); err != nil {
+		return ActionResult{Title: "CPU", Body: strings.TrimSpace(b.String())}
+	}
+	if len(snap.Hardware.CPUs) == 0 {
+		return ActionResult{Title: "CPU", Body: strings.TrimSpace(b.String())}
+	}
+	fmt.Fprintln(&b, "=== Audit ===")
+	for i, cpu := range snap.Hardware.CPUs {
+		fmt.Fprintf(&b, "CPU %d\n", i)
+		if cpu.Model != nil {
+			fmt.Fprintf(&b, "  Model:    %s\n", *cpu.Model)
+		}
+		if cpu.Manufacturer != nil {
+			fmt.Fprintf(&b, "  Vendor:   %s\n", *cpu.Manufacturer)
+		}
+		if cpu.Cores != nil {
+			fmt.Fprintf(&b, "  Cores:    %d\n", *cpu.Cores)
+		}
+		if cpu.Threads != nil {
+			fmt.Fprintf(&b, "  Threads:  %d\n", *cpu.Threads)
+		}
+		if cpu.MaxFrequencyMHz != nil {
+			fmt.Fprintf(&b, "  Max freq: %d MHz\n", *cpu.MaxFrequencyMHz)
+		}
+		if cpu.TemperatureC != nil {
+			fmt.Fprintf(&b, "  Temp:     %.1f°C\n", *cpu.TemperatureC)
+		}
+		if cpu.Throttled != nil {
+			fmt.Fprintf(&b, "  Throttled: %v\n", *cpu.Throttled)
+		}
+		if cpu.CorrectableErrorCount != nil && *cpu.CorrectableErrorCount > 0 {
+			fmt.Fprintf(&b, "  ECC correctable:   %d\n", *cpu.CorrectableErrorCount)
+		}
+		if cpu.UncorrectableErrorCount != nil && *cpu.UncorrectableErrorCount > 0 {
+			fmt.Fprintf(&b, "  ECC uncorrectable: %d\n", *cpu.UncorrectableErrorCount)
+		}
+		if i < len(snap.Hardware.CPUs)-1 {
+			fmt.Fprintln(&b)
+		}
+	}
+	return ActionResult{Title: "CPU", Body: strings.TrimSpace(b.String())}
+}
+
+func (a *App) satDetailResult(statusKey, prefix, title string) ActionResult {
+	matches, err := filepath.Glob(filepath.Join(DefaultSATBaseDir, prefix+"*/summary.txt"))
+	if err != nil || len(matches) == 0 {
+		return ActionResult{Title: title, Body: "No test results found. Run a test first."}
+	}
+	sort.Strings(matches)
+	raw, err := os.ReadFile(matches[len(matches)-1])
+	if err != nil {
+		return ActionResult{Title: title, Body: "Could not read test results."}
+	}
+	return ActionResult{Title: title, Body: formatSATDetail(strings.TrimSpace(string(raw)))}
+}
+
+// formatSATDetail converts raw summary.txt key=value content to a human-readable per-step display.
+func formatSATDetail(raw string) string {
+	var b strings.Builder
+	kv := parseKeyValueSummary(raw)
+
+	if t, ok := kv["run_at_utc"]; ok {
+		fmt.Fprintf(&b, "Run: %s\n\n", t)
+	}
+
+	// Collect step names in order they appear in the file
+	lines := strings.Split(raw, "\n")
+	var stepKeys []string
+	seenStep := map[string]bool{}
+	for _, line := range lines {
+		if idx := strings.Index(line, "_status="); idx >= 0 {
+			key := line[:idx]
+			if !seenStep[key] && key != "overall" {
+				seenStep[key] = true
+				stepKeys = append(stepKeys, key)
+			}
+		}
+	}
+
+	for _, key := range stepKeys {
+		status := kv[key+"_status"]
+		display := cleanSummaryKey(key)
+		switch status {
+		case "OK":
+			fmt.Fprintf(&b, "PASS  %s\n", display)
+		case "FAILED":
+			fmt.Fprintf(&b, "FAIL  %s\n", display)
+		case "UNSUPPORTED":
+			fmt.Fprintf(&b, "SKIP  %s\n", display)
+		default:
+			fmt.Fprintf(&b, "?     %s\n", display)
+		}
+	}
+
+	if overall, ok := kv["overall_status"]; ok {
+		ok2 := kv["job_ok"]
+		failed := kv["job_failed"]
+		fmt.Fprintf(&b, "\nOverall: %s  (ok=%s  failed=%s)", overall, ok2, failed)
+	}
+
+	return strings.TrimSpace(b.String())
+}
+
+// cleanSummaryKey strips the leading numeric prefix from a SAT step key.
+// "1-lscpu" → "lscpu", "3-stress-ng" → "stress-ng"
+func cleanSummaryKey(key string) string {
+	idx := strings.Index(key, "-")
+	if idx <= 0 {
+		return key
+	}
+	prefix := key[:idx]
+	for _, c := range prefix {
+		if c < '0' || c > '9' {
+			return key
+		}
+	}
+	return key[idx+1:]
+}
+
+func (a *App) psuDetailResult() ActionResult {
+	raw, err := os.ReadFile(DefaultAuditJSONPath)
+	if err != nil {
+		return ActionResult{Title: "PSU", Body: "No audit data."}
+	}
+	var snap schema.HardwareIngestRequest
+	if err := json.Unmarshal(raw, &snap); err != nil {
+		return ActionResult{Title: "PSU", Body: "Audit data unreadable."}
+	}
+	if len(snap.Hardware.PowerSupplies) == 0 {
+		return ActionResult{Title: "PSU", Body: "No PSU data in last audit."}
+	}
+	var b strings.Builder
+	for i, psu := range snap.Hardware.PowerSupplies {
+		fmt.Fprintf(&b, "PSU %d\n", i)
+		if psu.Model != nil {
+			fmt.Fprintf(&b, "  Model:   %s\n", *psu.Model)
+		}
+		if psu.Vendor != nil {
+			fmt.Fprintf(&b, "  Vendor:  %s\n", *psu.Vendor)
+		}
+		if psu.WattageW != nil {
+			fmt.Fprintf(&b, "  Rated:   %d W\n", *psu.WattageW)
+		}
+		if psu.InputPowerW != nil {
+			fmt.Fprintf(&b, "  Input:   %.1f W\n", *psu.InputPowerW)
+		}
+		if psu.OutputPowerW != nil {
+			fmt.Fprintf(&b, "  Output:  %.1f W\n", *psu.OutputPowerW)
+		}
+		if psu.TemperatureC != nil {
+			fmt.Fprintf(&b, "  Temp:    %.1f°C\n", *psu.TemperatureC)
+		}
+		if i < len(snap.Hardware.PowerSupplies)-1 {
+			fmt.Fprintln(&b)
+		}
+	}
+	return ActionResult{Title: "PSU", Body: strings.TrimSpace(b.String())}
+}
+
+// satStatuses reads the latest summary.txt for each SAT type and returns
+// a map of component key ("gpu","memory","storage") → status ("PASS","FAIL","CANCEL","N/A").
+func satStatuses() map[string]string {
+	result := map[string]string{
+		"gpu":     "N/A",
+		"memory":  "N/A",
+		"storage": "N/A",
+		"cpu":     "N/A",
+	}
+	patterns := []struct {
+		key    string
+		prefix string
+	}{
+		{"gpu", "gpu-nvidia-"},
+		{"gpu", "gpu-amd-"},
+		{"memory", "memory-"},
+		{"storage", "storage-"},
+		{"cpu", "cpu-"},
+	}
+	for _, item := range patterns {
+		matches, err := filepath.Glob(filepath.Join(DefaultSATBaseDir, item.prefix+"*/summary.txt"))
+		if err != nil || len(matches) == 0 {
+			continue
+		}
+		sort.Strings(matches)
+		raw, err := os.ReadFile(matches[len(matches)-1])
+		if err != nil {
+			continue
+		}
+		values := parseKeyValueSummary(string(raw))
+		switch strings.ToUpper(strings.TrimSpace(values["overall_status"])) {
+		case "OK":
+			result[item.key] = "PASS"
+		case "FAILED":
+			result[item.key] = "FAIL"
+		case "CANCELED", "CANCELLED":
+			result[item.key] = "CANCEL"
+		}
+	}
+	return result
+}
+
+func formatPSULine(psus []schema.HardwarePowerSupply) string {
+	var present []schema.HardwarePowerSupply
+	for _, psu := range psus {
+		if psu.Present != nil && !*psu.Present {
+			continue
+		}
+		present = append(present, psu)
+	}
+	if len(present) == 0 {
+		return ""
+	}
+	firstW := 0
+	if present[0].WattageW != nil {
+		firstW = *present[0].WattageW
+	}
+	allSame := firstW > 0
+	for _, p := range present[1:] {
+		w := 0
+		if p.WattageW != nil {
+			w = *p.WattageW
+		}
+		if w != firstW {
+			allSame = false
+			break
+		}
+	}
+	if allSame && firstW > 0 {
+		return fmt.Sprintf("%dx %dW", len(present), firstW)
+	}
+	return fmt.Sprintf("%d PSU", len(present))
+}

audit/internal/collector/board.go

@@ -4,6 +4,7 @@ import (
 	"bee/audit/internal/schema"
 	"bufio"
 	"log/slog"
+	"os"
 	"os/exec"
 	"strings"
 )
@@ -16,6 +17,14 @@ var execDmidecode = func(typeNum string) (string, error) {
 	return string(out), nil
 }
 
+var execIpmitool = func(args ...string) (string, error) {
+	out, err := exec.Command("ipmitool", args...).Output()
+	if err != nil {
+		return "", err
+	}
+	return string(out), nil
+}
+
 // collectBoard runs dmidecode for types 0, 1, 2 and returns the board record
 // plus the BIOS firmware entry. Any failure is logged and returns zero values.
 func collectBoard() (schema.HardwareBoard, []schema.HardwareFirmwareRecord) {
@@ -69,6 +78,45 @@ func parseBoard(type1, type2 string) schema.HardwareBoard {
 	return board
 }
 
+// collectBMCFirmware collects BMC firmware version via ipmitool mc info.
+// Returns nil if ipmitool is missing, /dev/ipmi0 is absent, or any error occurs.
+func collectBMCFirmware() []schema.HardwareFirmwareRecord {
+	if _, err := exec.LookPath("ipmitool"); err != nil {
+		return nil
+	}
+	if _, err := os.Stat("/dev/ipmi0"); err != nil {
+		return nil
+	}
+	out, err := execIpmitool("mc", "info")
+	if err != nil {
+		slog.Info("bmc: ipmitool mc info unavailable", "err", err)
+		return nil
+	}
+	version := parseBMCFirmwareRevision(out)
+	if version == "" {
+		return nil
+	}
+	slog.Info("bmc: collected", "version", version)
+	return []schema.HardwareFirmwareRecord{
+		{DeviceName: "BMC", Version: version},
+	}
+}
+
+// parseBMCFirmwareRevision extracts the "Firmware Revision" field from ipmitool mc info output.
+func parseBMCFirmwareRevision(out string) string {
+	for _, line := range strings.Split(out, "\n") {
+		line = strings.TrimSpace(line)
+		key, val, ok := strings.Cut(line, ":")
+		if !ok {
+			continue
+		}
+		if strings.TrimSpace(key) == "Firmware Revision" {
+			return strings.TrimSpace(val)
+		}
+	}
+	return ""
+}
+
 // parseBIOSFirmware extracts BIOS version from dmidecode type 0 output.
 func parseBIOSFirmware(type0 string) []schema.HardwareFirmwareRecord {
 	fields := parseDMIFields(type0, "BIOS Information")

audit/internal/collector/collector.go

@@ -23,6 +23,7 @@ func Run(_ runtimeenv.Mode) schema.HardwareIngestRequest {
 	board, biosFW := collectBoard()
 	snap.Board = board
 	snap.Firmware = append(snap.Firmware, biosFW...)
+	snap.Firmware = append(snap.Firmware, collectBMCFirmware()...)
 
 	snap.CPUs = collectCPUs()
 

audit/internal/platform/sat.go

@@ -22,6 +22,56 @@ type NvidiaGPU struct {
 	MemoryMB int
 }
 
+// AMDGPUInfo holds basic info about an AMD GPU from rocm-smi.
+type AMDGPUInfo struct {
+	Index int
+	Name  string
+}
+
+// DetectGPUVendor returns "nvidia" if /dev/nvidia0 exists, "amd" if /dev/kfd exists, or "" otherwise.
+func (s *System) DetectGPUVendor() string {
+	if _, err := os.Stat("/dev/nvidia0"); err == nil {
+		return "nvidia"
+	}
+	if _, err := os.Stat("/dev/kfd"); err == nil {
+		return "amd"
+	}
+	return ""
+}
+
+// ListAMDGPUs returns AMD GPUs visible to rocm-smi.
+func (s *System) ListAMDGPUs() ([]AMDGPUInfo, error) {
+	out, err := exec.Command("rocm-smi", "--showproductname", "--csv").Output()
+	if err != nil {
+		return nil, fmt.Errorf("rocm-smi: %w", err)
+	}
+	var gpus []AMDGPUInfo
+	for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(strings.ToLower(line), "device") {
+			continue
+		}
+		parts := strings.SplitN(line, ",", 2)
+		name := ""
+		if len(parts) >= 2 {
+			name = strings.TrimSpace(parts[1])
+		}
+		idx := len(gpus)
+		gpus = append(gpus, AMDGPUInfo{Index: idx, Name: name})
+	}
+	return gpus, nil
+}
+
+// RunAMDAcceptancePack runs an AMD GPU diagnostic pack using rocm-smi.
+func (s *System) RunAMDAcceptancePack(baseDir string) (string, error) {
+	return runAcceptancePack(baseDir, "gpu-amd", []satJob{
+		{name: "01-rocm-smi.log", cmd: []string{"rocm-smi"}},
+		{name: "02-rocm-smi-showallinfo.log", cmd: []string{"rocm-smi", "--showallinfo"}},
+		{name: "03-dmidecode-baseboard.log", cmd: []string{"dmidecode", "-t", "baseboard"}},
+		{name: "04-dmidecode-system.log", cmd: []string{"dmidecode", "-t", "system"}},
+	})
+}
+
 // ListNvidiaGPUs returns GPUs visible to nvidia-smi.
 func (s *System) ListNvidiaGPUs() ([]NvidiaGPU, error) {
 	out, err := exec.Command("nvidia-smi",
@@ -74,6 +124,18 @@ func (s *System) RunMemoryAcceptancePack(baseDir string) (string, error) {
 	})
 }
 
+func (s *System) RunCPUAcceptancePack(baseDir string, durationSec int) (string, error) {
+	if durationSec <= 0 {
+		durationSec = 60
+	}
+	return runAcceptancePack(baseDir, "cpu", []satJob{
+		{name: "01-lscpu.log", cmd: []string{"lscpu"}},
+		{name: "02-sensors-before.log", cmd: []string{"sensors"}},
+		{name: "03-stress-ng.log", cmd: []string{"stress-ng", "--cpu", "0", "--cpu-method", "all", "--timeout", fmt.Sprintf("%d", durationSec)}},
+		{name: "04-sensors-after.log", cmd: []string{"sensors"}},
+	})
+}
+
 func (s *System) RunStorageAcceptancePack(baseDir string) (string, error) {
 	if baseDir == "" {
 		baseDir = "/var/log/bee-sat"
@@ -320,7 +382,7 @@ func storageSATCommands(devPath string) []satJob {
 		return []satJob{
 			{name: "nvme-id-ctrl", cmd: []string{"nvme", "id-ctrl", devPath, "-o", "json"}},
 			{name: "nvme-smart-log", cmd: []string{"nvme", "smart-log", devPath, "-o", "json"}},
-			{name: "nvme-device-self-test", cmd: []string{"nvme", "device-self-test", devPath, "--start", "1"}},
+			{name: "nvme-device-self-test", cmd: []string{"nvme", "device-self-test", devPath, "-s", "1", "--wait"}},
 		}
 	}
 	return []satJob{

audit/internal/tui/forms.go

@@ -1,6 +1,10 @@
 package tui
 
-import tea "github.com/charmbracelet/bubbletea"
+import (
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
 
 func (m model) updateStaticForm(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 	switch msg.String() {
@@ -63,7 +67,7 @@ func (m model) updateConfirm(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 		m.pendingAction = actionNone
 		return m, nil
 	case "enter":
-		if m.cursor == 1 {
+		if m.cursor == 1 { // Cancel
 			m.screen = m.confirmCancelTarget()
 			m.cursor = 0
 			m.pendingAction = actionNone
@@ -71,13 +75,6 @@ func (m model) updateConfirm(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 		}
 		m.busy = true
 		switch m.pendingAction {
-		case actionExportAudit:
-			m.busyTitle = "Export audit"
-			target := *m.selectedTarget
-			return m, func() tea.Msg {
-				result, err := m.app.ExportLatestAuditResult(target)
-				return resultMsg{title: result.Title, body: result.Body, err: err, back: screenMain}
-			}
 		case actionExportBundle:
 			m.busyTitle = "Export support bundle"
 			target := *m.selectedTarget
@@ -85,24 +82,61 @@ func (m model) updateConfirm(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 				result, err := m.app.ExportSupportBundleResult(target)
 				return resultMsg{title: result.Title, body: result.Body, err: err, back: screenMain}
 			}
-		case actionRunNvidiaSAT:
-			m.busyTitle = "NVIDIA SAT"
-			return m, func() tea.Msg {
-				result, err := m.app.RunNvidiaAcceptancePackResult("")
-				return resultMsg{title: result.Title, body: result.Body, err: err, back: screenAcceptance}
-			}
+		case actionRunAll:
+			return m.executeRunAll()
 		case actionRunMemorySAT:
-			m.busyTitle = "Memory SAT"
-			return m, func() tea.Msg {
-				result, err := m.app.RunMemoryAcceptancePackResult("")
-				return resultMsg{title: result.Title, body: result.Body, err: err, back: screenAcceptance}
-			}
+			m.busyTitle = "Memory test"
+			m.progressPrefix = "memory"
+			m.progressSince = time.Now()
+			m.progressLines = nil
+			since := m.progressSince
+			return m, tea.Batch(
+				func() tea.Msg {
+					result, err := m.app.RunMemoryAcceptancePackResult("")
+					return resultMsg{title: result.Title, body: result.Body, err: err, back: screenHealthCheck}
+				},
+				pollSATProgress("memory", since),
+			)
 		case actionRunStorageSAT:
-			m.busyTitle = "Storage SAT"
-			return m, func() tea.Msg {
-				result, err := m.app.RunStorageAcceptancePackResult("")
-				return resultMsg{title: result.Title, body: result.Body, err: err, back: screenAcceptance}
-			}
+			m.busyTitle = "Storage test"
+			m.progressPrefix = "storage"
+			m.progressSince = time.Now()
+			m.progressLines = nil
+			since := m.progressSince
+			return m, tea.Batch(
+				func() tea.Msg {
+					result, err := m.app.RunStorageAcceptancePackResult("")
+					return resultMsg{title: result.Title, body: result.Body, err: err, back: screenHealthCheck}
+				},
+				pollSATProgress("storage", since),
+			)
+		case actionRunCPUSAT:
+			m.busyTitle = "CPU test"
+			m.progressPrefix = "cpu"
+			m.progressSince = time.Now()
+			m.progressLines = nil
+			since := m.progressSince
+			durationSec := hcCPUDurations[m.hcMode]
+			return m, tea.Batch(
+				func() tea.Msg {
+					result, err := m.app.RunCPUAcceptancePackResult("", durationSec)
+					return resultMsg{title: result.Title, body: result.Body, err: err, back: screenHealthCheck}
+				},
+				pollSATProgress("cpu", since),
+			)
+		case actionRunAMDGPUSAT:
+			m.busyTitle = "AMD GPU test"
+			m.progressPrefix = "gpu-amd"
+			m.progressSince = time.Now()
+			m.progressLines = nil
+			since := m.progressSince
+			return m, tea.Batch(
+				func() tea.Msg {
+					result, err := m.app.RunAMDAcceptancePackResult("")
+					return resultMsg{title: result.Title, body: result.Body, err: err, back: screenHealthCheck}
+				},
+				pollSATProgress("gpu-amd", since),
+			)
 		}
 	case "ctrl+c":
 		return m, tea.Quit
@@ -112,16 +146,10 @@ func (m model) updateConfirm(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 
 func (m model) confirmCancelTarget() screen {
 	switch m.pendingAction {
-	case actionExportAudit:
-		return screenExportTargets
 	case actionExportBundle:
 		return screenExportTargets
-	case actionRunNvidiaSAT:
-		fallthrough
-	case actionRunMemorySAT:
-		fallthrough
-	case actionRunStorageSAT:
-		return screenAcceptance
+	case actionRunAll, actionRunMemorySAT, actionRunStorageSAT, actionRunCPUSAT, actionRunAMDGPUSAT:
+		return screenHealthCheck
 	default:
 		return screenMain
 	}

audit/internal/tui/messages.go

@@ -1,6 +1,9 @@
 package tui
 
-import "bee/audit/internal/platform"
+import (
+	"bee/audit/internal/app"
+	"bee/audit/internal/platform"
+)
 
 type resultMsg struct {
 	title string
@@ -24,8 +27,8 @@ type exportTargetsMsg struct {
 	err     error
 }
 
-type bannerMsg struct {
-	text string
+type panelMsg struct {
+	data app.HardwarePanelData
 }
 
 type nvidiaGPUsMsg struct {

audit/internal/tui/screen_acceptance.go

@@ -1,21 +0,0 @@
-package tui
-
-import tea "github.com/charmbracelet/bubbletea"
-
-func (m model) handleAcceptanceMenu() (tea.Model, tea.Cmd) {
-	if m.cursor == 3 {
-		m.screen = screenMain
-		m.cursor = 0
-		return m, nil
-	}
-	switch m.cursor {
-	case 0:
-		return m.enterNvidiaSATSetup()
-	case 1:
-		m.pendingAction = actionRunMemorySAT
-	case 2:
-		m.pendingAction = actionRunStorageSAT
-	}
-	m.screen = screenConfirm
-	return m, nil
-}

audit/internal/tui/screen_export.go

@@ -4,17 +4,11 @@ import tea "github.com/charmbracelet/bubbletea"
 
 func (m model) handleExportTargetsMenu() (tea.Model, tea.Cmd) {
 	if len(m.targets) == 0 {
-		title := "Export audit"
-		if m.pendingAction == actionExportBundle {
-			title = "Export support bundle"
-		}
-		return m, resultCmd(title, "No removable filesystems found", nil, screenMain)
+		return m, resultCmd("Export support bundle", "No removable filesystems found", nil, screenMain)
 	}
 	target := m.targets[m.cursor]
 	m.selectedTarget = &target
-	if m.pendingAction == actionNone {
-		m.pendingAction = actionExportAudit
-	}
+	m.pendingAction = actionExportBundle
 	m.screen = screenConfirm
 	return m, nil
 }

audit/internal/tui/screen_health_check.go

@@ -0,0 +1,307 @@
+package tui
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+// Component indices.
+const (
+	hcGPU     = 0
+	hcMemory  = 1
+	hcStorage = 2
+	hcCPU     = 3
+)
+
+// Cursor positions in Health Check screen.
+const (
+	hcCurGPU       = 0
+	hcCurMemory    = 1
+	hcCurStorage   = 2
+	hcCurCPU       = 3
+	hcCurSelectAll = 4
+	hcCurModeQuick = 5
+	hcCurModeStd   = 6
+	hcCurModeExpr  = 7
+	hcCurRunAll    = 8
+	hcCurTotal     = 9
+)
+
+// hcModeDurations maps mode index (0=Quick,1=Standard,2=Express) to GPU stress seconds.
+var hcModeDurations = [3]int{600, 3600, 28800}
+
+// hcCPUDurations maps mode index to CPU stress-ng seconds.
+var hcCPUDurations = [3]int{60, 300, 900}
+
+func (m model) enterHealthCheck() (tea.Model, tea.Cmd) {
+	m.screen = screenHealthCheck
+	if !m.hcInitialized {
+		m.hcSel = [4]bool{true, true, true, true}
+		m.hcMode = 0
+		m.hcCursor = 0
+		m.hcInitialized = true
+	}
+	return m, nil
+}
+
+func (m model) updateHealthCheck(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch msg.String() {
+	case "up", "k":
+		if m.hcCursor > 0 {
+			m.hcCursor--
+		}
+	case "down", "j":
+		if m.hcCursor < hcCurTotal-1 {
+			m.hcCursor++
+		}
+	case " ":
+		switch m.hcCursor {
+		case hcCurGPU, hcCurMemory, hcCurStorage, hcCurCPU:
+			m.hcSel[m.hcCursor] = !m.hcSel[m.hcCursor]
+		case hcCurSelectAll:
+			allOn := m.hcSel[0] && m.hcSel[1] && m.hcSel[2] && m.hcSel[3]
+			for i := range m.hcSel {
+				m.hcSel[i] = !allOn
+			}
+		case hcCurModeQuick, hcCurModeStd, hcCurModeExpr:
+			m.hcMode = m.hcCursor - hcCurModeQuick
+		}
+	case "enter":
+		switch m.hcCursor {
+		case hcCurGPU, hcCurMemory, hcCurStorage, hcCurCPU:
+			return m.hcRunSingle(m.hcCursor)
+		case hcCurSelectAll:
+			allOn := m.hcSel[0] && m.hcSel[1] && m.hcSel[2] && m.hcSel[3]
+			for i := range m.hcSel {
+				m.hcSel[i] = !allOn
+			}
+		case hcCurModeQuick, hcCurModeStd, hcCurModeExpr:
+			m.hcMode = m.hcCursor - hcCurModeQuick
+		case hcCurRunAll:
+			return m.hcRunAll()
+		}
+	case "g", "G":
+		return m.hcRunSingle(hcGPU)
+	case "m", "M":
+		return m.hcRunSingle(hcMemory)
+	case "s", "S":
+		return m.hcRunSingle(hcStorage)
+	case "c", "C":
+		return m.hcRunSingle(hcCPU)
+	case "r", "R":
+		return m.hcRunAll()
+	case "a", "A":
+		allOn := m.hcSel[0] && m.hcSel[1] && m.hcSel[2] && m.hcSel[3]
+		for i := range m.hcSel {
+			m.hcSel[i] = !allOn
+		}
+	case "1":
+		m.hcMode = 0
+	case "2":
+		m.hcMode = 1
+	case "3":
+		m.hcMode = 2
+	case "esc":
+		m.screen = screenMain
+		m.cursor = 0
+	case "q", "ctrl+c":
+		return m, tea.Quit
+	}
+	return m, nil
+}
+
+func (m model) hcRunSingle(idx int) (tea.Model, tea.Cmd) {
+	switch idx {
+	case hcGPU:
+		if m.app.DetectGPUVendor() == "amd" {
+			m.pendingAction = actionRunAMDGPUSAT
+			m.screen = screenConfirm
+			m.cursor = 0
+			return m, nil
+		}
+		m.nvidiaDurIdx = m.hcMode
+		return m.enterNvidiaSATSetup()
+	case hcMemory:
+		m.pendingAction = actionRunMemorySAT
+		m.screen = screenConfirm
+		m.cursor = 0
+		return m, nil
+	case hcStorage:
+		m.pendingAction = actionRunStorageSAT
+		m.screen = screenConfirm
+		m.cursor = 0
+		return m, nil
+	case hcCPU:
+		m.pendingAction = actionRunCPUSAT
+		m.screen = screenConfirm
+		m.cursor = 0
+		return m, nil
+	}
+	return m, nil
+}
+
+func (m model) hcRunAll() (tea.Model, tea.Cmd) {
+	for _, sel := range m.hcSel {
+		if sel {
+			m.pendingAction = actionRunAll
+			m.screen = screenConfirm
+			m.cursor = 0
+			return m, nil
+		}
+	}
+	return m, nil
+}
+
+func (m model) executeRunAll() (tea.Model, tea.Cmd) {
+	durationSec := hcModeDurations[m.hcMode]
+	durationIdx := m.hcMode
+	sel := m.hcSel
+	app := m.app
+	m.busy = true
+	m.busyTitle = "Health Check"
+	return m, func() tea.Msg {
+		var parts []string
+		if sel[hcGPU] {
+			vendor := app.DetectGPUVendor()
+			if vendor == "amd" {
+				r, err := app.RunAMDAcceptancePackResult("")
+				body := r.Body
+				if err != nil {
+					body += "\nERROR: " + err.Error()
+				}
+				parts = append(parts, "=== GPU (AMD) ===\n"+body)
+			} else {
+				gpus, err := app.ListNvidiaGPUs()
+				if err != nil || len(gpus) == 0 {
+					parts = append(parts, "=== GPU ===\nNo NVIDIA GPUs detected or driver not loaded.")
+				} else {
+					var indices []int
+					sizeMB := 0
+					for _, g := range gpus {
+						indices = append(indices, g.Index)
+						if sizeMB == 0 || g.MemoryMB < sizeMB {
+							sizeMB = g.MemoryMB
+						}
+					}
+					if sizeMB == 0 {
+						sizeMB = 64
+					}
+					r, err := app.RunNvidiaAcceptancePackWithOptions(context.Background(), "", durationSec, sizeMB, indices)
+					body := r.Body
+					if err != nil {
+						body += "\nERROR: " + err.Error()
+					}
+					parts = append(parts, "=== GPU ===\n"+body)
+				}
+			}
+		}
+		if sel[hcMemory] {
+			r, err := app.RunMemoryAcceptancePackResult("")
+			body := r.Body
+			if err != nil {
+				body += "\nERROR: " + err.Error()
+			}
+			parts = append(parts, "=== MEMORY ===\n"+body)
+		}
+		if sel[hcStorage] {
+			r, err := app.RunStorageAcceptancePackResult("")
+			body := r.Body
+			if err != nil {
+				body += "\nERROR: " + err.Error()
+			}
+			parts = append(parts, "=== STORAGE ===\n"+body)
+		}
+		if sel[hcCPU] {
+			cpuDur := hcCPUDurations[durationIdx]
+			r, err := app.RunCPUAcceptancePackResult("", cpuDur)
+			body := r.Body
+			if err != nil {
+				body += "\nERROR: " + err.Error()
+			}
+			parts = append(parts, "=== CPU ===\n"+body)
+		}
+		combined := strings.Join(parts, "\n\n")
+		if combined == "" {
+			combined = "No components selected."
+		}
+		return resultMsg{title: "Health Check", body: combined, back: screenHealthCheck}
+	}
+}
+
+func renderHealthCheck(m model) string {
+	var b strings.Builder
+
+	fmt.Fprintln(&b, "HEALTH CHECK")
+	fmt.Fprintln(&b)
+	fmt.Fprintln(&b, "  Diagnostics:")
+	fmt.Fprintln(&b)
+
+	type comp struct{ name, desc, key string }
+	comps := []comp{
+		{"GPU", "nvidia/amd auto-detect", "G"},
+		{"MEMORY", "memtester", "M"},
+		{"STORAGE", "smartctl + NVMe self-test", "S"},
+		{"CPU", "audit diagnostics", "C"},
+	}
+	for i, c := range comps {
+		pfx := "  "
+		if m.hcCursor == i {
+			pfx = "> "
+		}
+		ch := "[ ]"
+		if m.hcSel[i] {
+			ch = "[x]"
+		}
+		fmt.Fprintf(&b, "%s%s  %-8s  %-28s [%s]\n", pfx, ch, c.name, c.desc, c.key)
+	}
+
+	fmt.Fprintln(&b, "  ─────────────────────────────────────────────────")
+	{
+		pfx := "  "
+		if m.hcCursor == hcCurSelectAll {
+			pfx = "> "
+		}
+		allOn := m.hcSel[0] && m.hcSel[1] && m.hcSel[2] && m.hcSel[3]
+		ch := "[ ]"
+		if allOn {
+			ch = "[x]"
+		}
+		fmt.Fprintf(&b, "%s%s  Select / Deselect All                        [A]\n", pfx, ch)
+	}
+
+	fmt.Fprintln(&b)
+	fmt.Fprintln(&b, "  Mode:")
+	modes := []struct{ label, key string }{
+		{"Quick", "1"},
+		{"Standard", "2"},
+		{"Express", "3"},
+	}
+	for i, mode := range modes {
+		pfx := "  "
+		if m.hcCursor == hcCurModeQuick+i {
+			pfx = "> "
+		}
+		radio := "( )"
+		if m.hcMode == i {
+			radio = "(*)"
+		}
+		fmt.Fprintf(&b, "%s%s  %-10s  [%s]\n", pfx, radio, mode.label, mode.key)
+	}
+
+	fmt.Fprintln(&b)
+	{
+		pfx := "  "
+		if m.hcCursor == hcCurRunAll {
+			pfx = "> "
+		}
+		fmt.Fprintf(&b, "%s[ RUN ALL [R] ]\n", pfx)
+	}
+
+	fmt.Fprintln(&b)
+	fmt.Fprintln(&b, "─────────────────────────────────────────────────────────────────")
+	fmt.Fprint(&b, "[↑↓] move  [space/enter] toggle  [letter] single test  [R] run all  [Esc] back")
+	return b.String()
+}

audit/internal/tui/screen_main.go

@@ -6,44 +6,9 @@ import (
 
 func (m model) handleMainMenu() (tea.Model, tea.Cmd) {
 	switch m.cursor {
-	case 0:
-		m.screen = screenNetwork
-		m.cursor = 0
-		return m, nil
-	case 1:
-		m.busy = true
-		m.busyTitle = "Services"
-		return m, func() tea.Msg {
-			services, err := m.app.ListBeeServices()
-			return servicesMsg{services: services, err: err}
-		}
-	case 2:
-		m.screen = screenAcceptance
-		m.cursor = 0
-		return m, nil
-	case 3:
-		m.busy = true
-		m.busyTitle = "Run audit"
-		return m, func() tea.Msg {
-			result, err := m.app.RunAuditNow(m.runtimeMode)
-			return resultMsg{title: result.Title, body: result.Body, err: err, back: screenMain}
-		}
-	case 4:
-		m.busy = true
-		m.busyTitle = "Run self-check"
-		return m, func() tea.Msg {
-			result, err := m.app.RunRuntimePreflightResult()
-			return resultMsg{title: result.Title, body: result.Body, err: err, back: screenMain}
-		}
-	case 5:
-		m.pendingAction = actionExportAudit
-		m.busy = true
-		m.busyTitle = "Export audit"
-		return m, func() tea.Msg {
-			targets, err := m.app.ListRemovableTargets()
-			return exportTargetsMsg{targets: targets, err: err}
-		}
-	case 6:
+	case 0: // Health Check
+		return m.enterHealthCheck()
+	case 1: // Export support bundle
 		m.pendingAction = actionExportBundle
 		m.busy = true
 		m.busyTitle = "Export support bundle"
@@ -51,35 +16,11 @@ func (m model) handleMainMenu() (tea.Model, tea.Cmd) {
 			targets, err := m.app.ListRemovableTargets()
 			return exportTargetsMsg{targets: targets, err: err}
 		}
-	case 7:
-		m.busy = true
-		m.busyTitle = "Required tools"
-		return m, func() tea.Msg {
-			result := m.app.ToolCheckResult([]string{"dmidecode", "smartctl", "nvme", "ipmitool", "lspci", "ethtool", "bee", "nvidia-smi", "bee-gpu-stress", "memtester", "dhclient", "lsblk", "mount"})
-			return resultMsg{title: result.Title, body: result.Body, back: screenMain}
-		}
-	case 8:
-		m.busy = true
-		m.busyTitle = "Health summary"
-		return m, func() tea.Msg {
-			result := m.app.HealthSummaryResult()
-			return resultMsg{title: result.Title, body: result.Body, back: screenMain}
-		}
-	case 9:
-		m.busy = true
-		m.busyTitle = "Runtime issues"
-		return m, func() tea.Msg {
-			result := m.app.RuntimeHealthResult()
-			return resultMsg{title: result.Title, body: result.Body, back: screenMain}
-		}
-	case 10:
-		m.busy = true
-		m.busyTitle = "Audit logs"
-		return m, func() tea.Msg {
-			result := m.app.AuditLogTailResult()
-			return resultMsg{title: result.Title, body: result.Body, back: screenMain}
-		}
-	case 11:
+	case 2: // Settings
+		m.screen = screenSettings
+		m.cursor = 0
+		return m, nil
+	case 3: // Exit
 		return m, tea.Quit
 	}
 	return m, nil

audit/internal/tui/screen_network.go

@@ -39,7 +39,7 @@ func (m model) handleNetworkMenu() (tea.Model, tea.Cmd) {
 			return interfacesMsg{ifaces: ifaces, err: err}
 		}
 	case 4:
-		m.screen = screenMain
+		m.screen = screenSettings
 		m.cursor = 0
 		return m, nil
 	}

audit/internal/tui/screen_nvidia_sat.go

@@ -43,7 +43,7 @@ func (m model) handleNvidiaGPUsMsg(msg nvidiaGPUsMsg) (tea.Model, tea.Cmd) {
 	if msg.err != nil {
 		m.title = "NVIDIA SAT"
 		m.body = fmt.Sprintf("Failed to list GPUs: %v", msg.err)
-		m.prevScreen = screenAcceptance
+		m.prevScreen = screenHealthCheck
 		m.screen = screenOutput
 		return m, nil
 	}
@@ -90,11 +90,11 @@ func (m model) updateNvidiaSATSetup(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 		case m.nvidiaSATCursor == startIdx:
 			return m.startNvidiaSAT()
 		case m.nvidiaSATCursor == cancelIdx:
-			m.screen = screenAcceptance
+			m.screen = screenHealthCheck
 			m.cursor = 0
 		}
 	case "esc":
-		m.screen = screenAcceptance
+		m.screen = screenHealthCheck
 		m.cursor = 0
 	case "ctrl+c", "q":
 		return m, tea.Quit
@@ -173,7 +173,7 @@ func (m model) updateNvidiaSATRunning(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 			m.nvidiaSATCancel = nil
 		}
 		m.nvidiaSATAborted = true
-		m.screen = screenAcceptance
+		m.screen = screenHealthCheck
 		m.cursor = 0
 	case "ctrl+c":
 		return m, tea.Quit

audit/internal/tui/screen_services.go

@@ -8,7 +8,7 @@ import (
 
 func (m model) handleServicesMenu() (tea.Model, tea.Cmd) {
 	if len(m.services) == 0 {
-		return m, resultCmd("Services", "No bee-* services found.", nil, screenMain)
+		return m, resultCmd("Services", "No bee-* services found.", nil, screenSettings)
 	}
 	m.selectedService = m.services[m.cursor]
 	m.screen = screenServiceAction

audit/internal/tui/screen_settings.go

@@ -0,0 +1,64 @@
+package tui
+
+import tea "github.com/charmbracelet/bubbletea"
+
+func (m model) handleSettingsMenu() (tea.Model, tea.Cmd) {
+	switch m.cursor {
+	case 0: // Network
+		m.screen = screenNetwork
+		m.cursor = 0
+		return m, nil
+	case 1: // Services
+		m.busy = true
+		m.busyTitle = "Services"
+		return m, func() tea.Msg {
+			services, err := m.app.ListBeeServices()
+			return servicesMsg{services: services, err: err}
+		}
+	case 2: // Re-run audit
+		m.busy = true
+		m.busyTitle = "Re-run audit"
+		runtimeMode := m.runtimeMode
+		return m, func() tea.Msg {
+			result, err := m.app.RunAuditNow(runtimeMode)
+			return resultMsg{title: result.Title, body: result.Body, err: err, back: screenSettings}
+		}
+	case 3: // Run self-check
+		m.busy = true
+		m.busyTitle = "Self-check"
+		return m, func() tea.Msg {
+			result, err := m.app.RunRuntimePreflightResult()
+			return resultMsg{title: result.Title, body: result.Body, err: err, back: screenSettings}
+		}
+	case 4: // Runtime issues
+		m.busy = true
+		m.busyTitle = "Runtime issues"
+		return m, func() tea.Msg {
+			result := m.app.RuntimeHealthResult()
+			return resultMsg{title: result.Title, body: result.Body, back: screenSettings}
+		}
+	case 5: // Audit logs
+		m.busy = true
+		m.busyTitle = "Audit logs"
+		return m, func() tea.Msg {
+			result := m.app.AuditLogTailResult()
+			return resultMsg{title: result.Title, body: result.Body, back: screenSettings}
+		}
+	case 6: // Check tools
+		m.busy = true
+		m.busyTitle = "Check tools"
+		return m, func() tea.Msg {
+			result := m.app.ToolCheckResult([]string{
+				"dmidecode", "smartctl", "nvme", "ipmitool", "lspci",
+				"ethtool", "bee", "nvidia-smi", "bee-gpu-stress",
+				"memtester", "dhclient", "lsblk", "mount",
+			})
+			return resultMsg{title: result.Title, body: result.Body, back: screenSettings}
+		}
+	case 7: // Back
+		m.screen = screenMain
+		m.cursor = 0
+		return m, nil
+	}
+	return m, nil
+}

audit/internal/tui/tui_test.go

@@ -53,11 +53,10 @@ func TestUpdateMainMenuEnterActions(t *testing.T) {
 		wantBusy   bool
 		wantCmd    bool
 	}{
-		{name: "network", cursor: 0, wantScreen: screenNetwork},
-		{name: "services", cursor: 1, wantScreen: screenMain, wantBusy: true, wantCmd: true},
-		{name: "acceptance", cursor: 2, wantScreen: screenAcceptance},
-		{name: "run audit", cursor: 3, wantScreen: screenMain, wantBusy: true, wantCmd: true},
-		{name: "export", cursor: 4, wantScreen: screenMain, wantBusy: true, wantCmd: true},
+		{name: "health_check", cursor: 0, wantScreen: screenHealthCheck},
+		{name: "export", cursor: 1, wantScreen: screenMain, wantBusy: true, wantCmd: true},
+		{name: "settings", cursor: 2, wantScreen: screenSettings},
+		{name: "exit", cursor: 3, wantScreen: screenMain, wantCmd: true},
 	}
 
 	for _, test := range tests {
@@ -89,7 +88,7 @@ func TestUpdateConfirmCancelViaKeys(t *testing.T) {
 
 	m := newTestModel()
 	m.screen = screenConfirm
-	m.pendingAction = actionRunNvidiaSAT
+	m.pendingAction = actionRunMemorySAT
 
 	next, _ := m.Update(tea.KeyMsg{Type: tea.KeyRight})
 	got := next.(model)
@@ -99,8 +98,8 @@ func TestUpdateConfirmCancelViaKeys(t *testing.T) {
 
 	next, _ = got.Update(tea.KeyMsg{Type: tea.KeyEnter})
 	got = next.(model)
-	if got.screen != screenAcceptance {
-		t.Fatalf("screen=%q want %q", got.screen, screenAcceptance)
+	if got.screen != screenHealthCheck {
+		t.Fatalf("screen=%q want %q", got.screen, screenHealthCheck)
 	}
 	if got.cursor != 0 {
 		t.Fatalf("cursor=%d want 0 after cancel", got.cursor)
@@ -115,8 +114,8 @@ func TestMainMenuSimpleTransitions(t *testing.T) {
 		cursor     int
 		wantScreen screen
 	}{
-		{name: "network", cursor: 0, wantScreen: screenNetwork},
-		{name: "acceptance", cursor: 2, wantScreen: screenAcceptance},
+		{name: "health_check", cursor: 0, wantScreen: screenHealthCheck},
+		{name: "settings", cursor: 2, wantScreen: screenSettings},
 	}
 
 	for _, test := range tests {
@@ -143,57 +142,42 @@ func TestMainMenuSimpleTransitions(t *testing.T) {
 	}
 }
 
-func TestMainMenuAsyncActionsSetBusy(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name   string
-		cursor int
-	}{
-		{name: "services", cursor: 1},
-		{name: "run audit", cursor: 3},
-		{name: "export", cursor: 4},
-		{name: "check tools", cursor: 5},
-		{name: "health summary", cursor: 6},
-		{name: "log tail", cursor: 7},
-	}
-
-	for _, test := range tests {
-		test := test
-		t.Run(test.name, func(t *testing.T) {
-			t.Parallel()
-
-			m := newTestModel()
-			m.cursor = test.cursor
-
-			next, cmd := m.handleMainMenu()
-			got := next.(model)
-
-			if !got.busy {
-				t.Fatalf("busy=false for %s", test.name)
-			}
-			if cmd == nil {
-				t.Fatalf("expected async cmd for %s", test.name)
-			}
-		})
-	}
-}
-
-func TestMainViewIncludesBanner(t *testing.T) {
+func TestMainMenuExportSetsBusy(t *testing.T) {
 	t.Parallel()
 
 	m := newTestModel()
-	m.banner = "System: Test Server | S/N ABC123\nIP: 10.0.0.10"
+	m.cursor = 1 // Export support bundle
+
+	next, cmd := m.handleMainMenu()
+	got := next.(model)
+
+	if !got.busy {
+		t.Fatal("busy=false for export")
+	}
+	if cmd == nil {
+		t.Fatal("expected async cmd for export")
+	}
+}
+
+func TestMainViewRendersTwoColumns(t *testing.T) {
+	t.Parallel()
+
+	m := newTestModel()
+	m.cursor = 1
 
 	view := m.View()
-	if !strings.Contains(view, "System: Test Server | S/N ABC123") {
-		t.Fatalf("view missing system banner:\n%s", view)
-	}
-	if !strings.Contains(view, "IP: 10.0.0.10") {
-		t.Fatalf("view missing ip banner:\n%s", view)
-	}
-	if !strings.Contains(view, "Select action") {
-		t.Fatalf("view missing menu subtitle:\n%s", view)
+	for _, want := range []string{
+		"bee",
+		"Health Check",
+		"> Export support bundle",
+		"Settings",
+		"Exit",
+		"│",
+		"[↑↓] move",
+	} {
+		if !strings.Contains(view, want) {
+			t.Fatalf("view missing %q\nview:\n%s", want, view)
+		}
 	}
 }
 
@@ -205,9 +189,9 @@ func TestEscapeNavigation(t *testing.T) {
 		screen     screen
 		wantScreen screen
 	}{
-		{name: "network to main", screen: screenNetwork, wantScreen: screenMain},
-		{name: "services to main", screen: screenServices, wantScreen: screenMain},
-		{name: "acceptance to main", screen: screenAcceptance, wantScreen: screenMain},
+		{name: "network to settings", screen: screenNetwork, wantScreen: screenSettings},
+		{name: "services to settings", screen: screenServices, wantScreen: screenSettings},
+		{name: "settings to main", screen: screenSettings, wantScreen: screenMain},
 		{name: "service action to services", screen: screenServiceAction, wantScreen: screenServices},
 		{name: "export targets to main", screen: screenExportTargets, wantScreen: screenMain},
 		{name: "interface pick to network", screen: screenInterfacePick, wantScreen: screenNetwork},
@@ -235,6 +219,24 @@ func TestEscapeNavigation(t *testing.T) {
 	}
 }
 
+func TestHealthCheckEscReturnsToMain(t *testing.T) {
+	t.Parallel()
+
+	m := newTestModel()
+	m.screen = screenHealthCheck
+	m.hcCursor = 3
+
+	next, _ := m.updateHealthCheck(tea.KeyMsg{Type: tea.KeyEsc})
+	got := next.(model)
+
+	if got.screen != screenMain {
+		t.Fatalf("screen=%q want %q", got.screen, screenMain)
+	}
+	if got.cursor != 0 {
+		t.Fatalf("cursor=%d want 0", got.cursor)
+	}
+}
+
 func TestOutputScreenReturnsToPreviousScreen(t *testing.T) {
 	t.Parallel()
 
@@ -255,14 +257,15 @@ func TestOutputScreenReturnsToPreviousScreen(t *testing.T) {
 	}
 }
 
-func TestAcceptanceNvidiaSATOpensSetup(t *testing.T) {
+func TestHealthCheckGPUOpensNvidiaSATSetup(t *testing.T) {
 	t.Parallel()
 
 	m := newTestModel()
-	m.screen = screenAcceptance
-	m.cursor = 0
+	m.screen = screenHealthCheck
+	m.hcInitialized = true
+	m.hcSel = [4]bool{true, true, true, true}
 
-	next, cmd := m.handleAcceptanceMenu()
+	next, cmd := m.hcRunSingle(hcGPU)
 	got := next.(model)
 
 	if cmd == nil {
@@ -272,34 +275,37 @@ func TestAcceptanceNvidiaSATOpensSetup(t *testing.T) {
 		t.Fatalf("screen=%q want %q", got.screen, screenNvidiaSATSetup)
 	}
 
-	// esc from setup returns to acceptance
+	// esc from setup returns to health check
 	next, _ = got.updateNvidiaSATSetup(tea.KeyMsg{Type: tea.KeyEsc})
 	got = next.(model)
-	if got.screen != screenAcceptance {
-		t.Fatalf("screen after esc=%q want %q", got.screen, screenAcceptance)
+	if got.screen != screenHealthCheck {
+		t.Fatalf("screen after esc=%q want %q", got.screen, screenHealthCheck)
 	}
 }
 
-func TestAcceptanceMenuMapsNewTargets(t *testing.T) {
+func TestHealthCheckRunSingleMapsActions(t *testing.T) {
 	t.Parallel()
 
 	tests := []struct {
-		cursor int
-		want   actionKind
+		idx  int
+		want actionKind
 	}{
-		{cursor: 1, want: actionRunMemorySAT},
-		{cursor: 2, want: actionRunStorageSAT},
+		{idx: hcMemory, want: actionRunMemorySAT},
+		{idx: hcStorage, want: actionRunStorageSAT},
 	}
 
 	for _, test := range tests {
 		m := newTestModel()
-		m.screen = screenAcceptance
-		m.cursor = test.cursor
+		m.screen = screenHealthCheck
+		m.hcInitialized = true
 
-		next, _ := m.handleAcceptanceMenu()
+		next, _ := m.hcRunSingle(test.idx)
 		got := next.(model)
 		if got.pendingAction != test.want {
-			t.Fatalf("cursor=%d pendingAction=%q want %q", test.cursor, got.pendingAction, test.want)
+			t.Fatalf("idx=%d pendingAction=%q want %q", test.idx, got.pendingAction, test.want)
+		}
+		if got.screen != screenConfirm {
+			t.Fatalf("idx=%d screen=%q want %q", test.idx, got.screen, screenConfirm)
 		}
 	}
 }
@@ -320,8 +326,8 @@ func TestExportTargetSelectionOpensConfirm(t *testing.T) {
 	if got.screen != screenConfirm {
 		t.Fatalf("screen=%q want %q", got.screen, screenConfirm)
 	}
-	if got.pendingAction != actionExportAudit {
-		t.Fatalf("pendingAction=%q want %q", got.pendingAction, actionExportAudit)
+	if got.pendingAction != actionExportBundle {
+		t.Fatalf("pendingAction=%q want %q", got.pendingAction, actionExportBundle)
 	}
 	if got.selectedTarget == nil || got.selectedTarget.Device != "/dev/sdb1" {
 		t.Fatalf("selectedTarget=%+v want /dev/sdb1", got.selectedTarget)
@@ -374,14 +380,24 @@ func TestConfirmCancelTarget(t *testing.T) {
 
 	m := newTestModel()
 
-	m.pendingAction = actionExportAudit
+	m.pendingAction = actionExportBundle
 	if got := m.confirmCancelTarget(); got != screenExportTargets {
 		t.Fatalf("export cancel target=%q want %q", got, screenExportTargets)
 	}
 
-	m.pendingAction = actionRunNvidiaSAT
-	if got := m.confirmCancelTarget(); got != screenAcceptance {
-		t.Fatalf("sat cancel target=%q want %q", got, screenAcceptance)
+	m.pendingAction = actionRunAll
+	if got := m.confirmCancelTarget(); got != screenHealthCheck {
+		t.Fatalf("run all cancel target=%q want %q", got, screenHealthCheck)
+	}
+
+	m.pendingAction = actionRunMemorySAT
+	if got := m.confirmCancelTarget(); got != screenHealthCheck {
+		t.Fatalf("memory sat cancel target=%q want %q", got, screenHealthCheck)
+	}
+
+	m.pendingAction = actionRunStorageSAT
+	if got := m.confirmCancelTarget(); got != screenHealthCheck {
+		t.Fatalf("storage sat cancel target=%q want %q", got, screenHealthCheck)
 	}
 
 	m.pendingAction = actionNone
@@ -390,28 +406,6 @@ func TestConfirmCancelTarget(t *testing.T) {
 	}
 }
 
-func TestViewMainMenuRendersSelectedItem(t *testing.T) {
-	t.Parallel()
-
-	m := newTestModel()
-	m.cursor = 1
-
-	view := m.View()
-
-	for _, want := range []string{
-		"bee",
-		"Select action",
-		"  Network",
-		"> Services",
-		"Acceptance tests",
-		"[↑/↓] move  [enter] select  [esc] back  [ctrl+c] quit",
-	} {
-		if !strings.Contains(view, want) {
-			t.Fatalf("view missing %q\nview:\n%s", want, view)
-		}
-	}
-}
-
 func TestViewBusyStateIsMinimal(t *testing.T) {
 	t.Parallel()
 
@@ -430,12 +424,12 @@ func TestViewBusyStateUsesBusyTitle(t *testing.T) {
 
 	m := newTestModel()
 	m.busy = true
-	m.busyTitle = "Export audit"
+	m.busyTitle = "Export support bundle"
 
 	view := m.View()
 
 	for _, want := range []string{
-		"Export audit",
+		"Export support bundle",
 		"Working...",
 		"[ctrl+c] quit",
 	} {
@@ -484,7 +478,7 @@ func TestViewExportTargetsRendersDeviceMetadata(t *testing.T) {
 	view := m.View()
 
 	for _, want := range []string{
-		"Export audit",
+		"Export support bundle",
 		"Select removable filesystem",
 		"> /dev/sdb1 [vfat 29G] label=BEEUSB mounted=/media/bee",
 	} {
@@ -527,14 +521,14 @@ func TestViewConfirmScreenMatchesPendingExport(t *testing.T) {
 
 	m := newTestModel()
 	m.screen = screenConfirm
-	m.pendingAction = actionExportAudit
+	m.pendingAction = actionExportBundle
 	m.selectedTarget = &platform.RemovableTarget{Device: "/dev/sdb1"}
 
 	view := m.View()
 
 	for _, want := range []string{
-		"Export audit",
-		"Copy latest audit JSON to /dev/sdb1?",
+		"Export support bundle",
+		"Copy support bundle to /dev/sdb1?",
 		"> Confirm",
 		"  Cancel",
 	} {
@@ -549,11 +543,11 @@ func TestResultMsgClearsBusyAndPendingAction(t *testing.T) {
 
 	m := newTestModel()
 	m.busy = true
-	m.busyTitle = "Export audit"
-	m.pendingAction = actionExportAudit
+	m.busyTitle = "Export support bundle"
+	m.pendingAction = actionExportBundle
 	m.screen = screenConfirm
 
-	next, _ := m.Update(resultMsg{title: "Export audit", body: "done", back: screenMain})
+	next, _ := m.Update(resultMsg{title: "Export support bundle", body: "done", back: screenMain})
 	got := next.(model)
 
 	if got.busy {
@@ -572,7 +566,7 @@ func TestResultMsgErrorWithoutBodyFormatsCleanly(t *testing.T) {
 
 	m := newTestModel()
 
-	next, _ := m.Update(resultMsg{title: "Export audit", err: assertErr("boom"), back: screenMain})
+	next, _ := m.Update(resultMsg{title: "Export support bundle", err: assertErr("boom"), back: screenMain})
 	got := next.(model)
 
 	if got.body != "ERROR: boom" {

audit/internal/tui/types.go

@@ -1,12 +1,12 @@
 package tui
 
 import (
-	"context"
+	"strings"
+	"time"
 
 	"bee/audit/internal/app"
 	"bee/audit/internal/platform"
 	"bee/audit/internal/runtimeenv"
-	"strings"
 
 	tea "github.com/charmbracelet/bubbletea"
 )
@@ -15,11 +15,12 @@ type screen string
 
 const (
 	screenMain             screen = "main"
+	screenHealthCheck      screen = "health_check"
+	screenSettings         screen = "settings"
 	screenNetwork          screen = "network"
 	screenInterfacePick    screen = "interface_pick"
 	screenServices         screen = "services"
 	screenServiceAction    screen = "service_action"
-	screenAcceptance       screen = "acceptance"
 	screenExportTargets    screen = "export_targets"
 	screenOutput           screen = "output"
 	screenStaticForm       screen = "static_form"
@@ -31,14 +32,15 @@ const (
 type actionKind string
 
 const (
-	actionNone          actionKind = ""
-	actionDHCPOne       actionKind = "dhcp_one"
-	actionStaticIPv4    actionKind = "static_ipv4"
-	actionExportAudit   actionKind = "export_audit"
-	actionExportBundle  actionKind = "export_bundle"
-	actionRunNvidiaSAT  actionKind = "run_nvidia_sat"
-	actionRunMemorySAT  actionKind = "run_memory_sat"
-	actionRunStorageSAT actionKind = "run_storage_sat"
+	actionNone             actionKind = ""
+	actionDHCPOne          actionKind = "dhcp_one"
+	actionStaticIPv4       actionKind = "static_ipv4"
+	actionExportBundle     actionKind = "export_bundle"
+	actionRunAll           actionKind = "run_all"
+	actionRunMemorySAT     actionKind = "run_memory_sat"
+	actionRunStorageSAT    actionKind = "run_storage_sat"
+	actionRunCPUSAT        actionKind = "run_cpu_sat"
+	actionRunAMDGPUSAT     actionKind = "run_amd_gpu_sat"
 )
 
 type model struct {
@@ -52,8 +54,8 @@ type model struct {
 	busyTitle   string
 	title       string
 	body        string
-	banner      string
 	mainMenu    []string
+	settingsMenu []string
 	networkMenu []string
 	serviceMenu []string
 
@@ -68,15 +70,31 @@ type model struct {
 	formFields []formField
 	formIndex  int
 
+	// Hardware panel (right column)
+	panel       app.HardwarePanelData
+	panelFocus  bool
+	panelCursor int
+
+	// Health Check screen
+	hcSel         [4]bool
+	hcMode        int
+	hcCursor      int
+	hcInitialized bool
+
 	// NVIDIA SAT setup
-	nvidiaGPUs       []platform.NvidiaGPU
-	nvidiaGPUSel     []bool
-	nvidiaDurIdx     int // index into nvidiaDurationOptions
-	nvidiaSATCursor  int
+	nvidiaGPUs      []platform.NvidiaGPU
+	nvidiaGPUSel    []bool
+	nvidiaDurIdx    int
+	nvidiaSATCursor int
 
 	// NVIDIA SAT running
-	nvidiaSATCancel  context.CancelFunc
+	nvidiaSATCancel  func()
 	nvidiaSATAborted bool
+
+	// SAT verbose progress (CPU / Memory / Storage / AMD GPU)
+	progressLines  []string
+	progressPrefix string
+	progressSince  time.Time
 }
 
 type formField struct {
@@ -100,18 +118,20 @@ func newModel(application *app.App, runtimeMode runtimeenv.Mode) model {
 		runtimeMode: runtimeMode,
 		screen:      screenMain,
 		mainMenu: []string{
+			"Health Check",
+			"Export support bundle",
+			"Settings",
+			"Exit",
+		},
+		settingsMenu: []string{
 			"Network",
 			"Services",
-			"Acceptance tests",
-			"Run audit",
+			"Re-run audit",
 			"Run self-check",
-			"Export audit",
-			"Export support bundle",
+			"Runtime issues",
+			"Audit logs",
 			"Check tools",
-			"Show health summary",
-			"Show runtime issues",
-			"Show audit logs",
-			"Exit",
+			"Back",
 		},
 		networkMenu: []string{
 			"Show status",
@@ -132,6 +152,41 @@ func newModel(application *app.App, runtimeMode runtimeenv.Mode) model {
 
 func (m model) Init() tea.Cmd {
 	return func() tea.Msg {
-		return bannerMsg{text: strings.TrimSpace(m.app.MainBanner())}
+		return panelMsg{data: m.app.LoadHardwarePanel()}
+	}
+}
+
+func (m model) confirmBody() (string, string) {
+	switch m.pendingAction {
+	case actionExportBundle:
+		if m.selectedTarget == nil {
+			return "Export support bundle", "No target selected"
+		}
+		return "Export support bundle", "Copy support bundle to " + m.selectedTarget.Device + "?"
+	case actionRunAll:
+		modes := []string{"Quick", "Standard", "Express"}
+		mode := modes[m.hcMode]
+		var sel []string
+		names := []string{"GPU", "Memory", "Storage", "CPU"}
+		for i, on := range m.hcSel {
+			if on {
+				sel = append(sel, names[i])
+			}
+		}
+		if len(sel) == 0 {
+			return "Health Check", "No components selected."
+		}
+		return "Health Check", "Run: " + strings.Join(sel, " + ") + "\nMode: " + mode
+	case actionRunMemorySAT:
+		return "Memory test", "Run memtester?"
+	case actionRunStorageSAT:
+		return "Storage test", "Run storage diagnostic pack?"
+	case actionRunCPUSAT:
+		modes := []string{"Quick (60s)", "Standard (300s)", "Express (900s)"}
+		return "CPU test", "Run stress-ng? Mode: " + modes[m.hcMode]
+	case actionRunAMDGPUSAT:
+		return "AMD GPU test", "Run AMD GPU diagnostic pack (rocm-smi)?"
+	default:
+		return "Confirm", "Proceed?"
 	}
 }

audit/internal/tui/update.go

@@ -11,17 +11,25 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
 	case tea.KeyMsg:
 		if m.busy {
-			switch msg.String() {
-			case "ctrl+c":
+			if msg.String() == "ctrl+c" {
 				return m, tea.Quit
-			default:
-				return m, nil
 			}
+			return m, nil
 		}
 		return m.updateKey(msg)
+	case satProgressMsg:
+		if m.busy && m.progressPrefix != "" {
+			if len(msg.lines) > 0 {
+				m.progressLines = msg.lines
+			}
+			return m, pollSATProgress(m.progressPrefix, m.progressSince)
+		}
+		return m, nil
 	case resultMsg:
 		m.busy = false
 		m.busyTitle = ""
+		m.progressLines = nil
+		m.progressPrefix = ""
 		m.title = msg.title
 		if msg.err != nil {
 			body := strings.TrimSpace(msg.body)
@@ -48,7 +56,7 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		if msg.err != nil {
 			m.title = "Services"
 			m.body = msg.err.Error()
-			m.prevScreen = screenMain
+			m.prevScreen = screenSettings
 			m.screen = screenOutput
 			return m, nil
 		}
@@ -62,7 +70,7 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		if msg.err != nil {
 			m.title = "interfaces"
 			m.body = msg.err.Error()
-			m.prevScreen = screenMain
+			m.prevScreen = screenNetwork
 			m.screen = screenOutput
 			return m, nil
 		}
@@ -84,13 +92,12 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		m.screen = screenExportTargets
 		m.cursor = 0
 		return m, nil
-	case bannerMsg:
-		m.banner = strings.TrimSpace(msg.text)
+	case panelMsg:
+		m.panel = msg.data
 		return m, nil
 	case nvidiaGPUsMsg:
 		return m.handleNvidiaGPUsMsg(msg)
 	case nvtopClosedMsg:
-		// nvtop closed — stay on running screen (or result if SAT is already done)
 		return m, nil
 	case nvidiaSATDoneMsg:
 		if m.nvidiaSATAborted {
@@ -100,7 +107,7 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			m.nvidiaSATCancel()
 			m.nvidiaSATCancel = nil
 		}
-		m.prevScreen = screenAcceptance
+		m.prevScreen = screenHealthCheck
 		m.screen = screenOutput
 		m.title = msg.title
 		if msg.err != nil {
@@ -115,22 +122,23 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 		return m, nil
 	}
-
 	return m, nil
 }
 
 func (m model) updateKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 	switch m.screen {
 	case screenMain:
-		return m.updateMenu(msg, len(m.mainMenu), m.handleMainMenu)
+		return m.updateMain(msg)
+	case screenHealthCheck:
+		return m.updateHealthCheck(msg)
+	case screenSettings:
+		return m.updateMenu(msg, len(m.settingsMenu), m.handleSettingsMenu)
 	case screenNetwork:
 		return m.updateMenu(msg, len(m.networkMenu), m.handleNetworkMenu)
 	case screenServices:
 		return m.updateMenu(msg, len(m.services), m.handleServicesMenu)
 	case screenServiceAction:
 		return m.updateMenu(msg, len(m.serviceMenu), m.handleServiceActionMenu)
-	case screenAcceptance:
-		return m.updateMenu(msg, 4, m.handleAcceptanceMenu)
 	case screenNvidiaSATSetup:
 		return m.updateNvidiaSATSetup(msg)
 	case screenNvidiaSATRunning:
@@ -146,6 +154,10 @@ func (m model) updateKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 			m.body = ""
 			m.title = ""
 			m.pendingAction = actionNone
+			// Refresh panel when returning to main screen.
+			if m.prevScreen == screenMain {
+				return m, func() tea.Msg { return panelMsg{data: m.app.LoadHardwarePanel()} }
+			}
 			return m, nil
 		case "ctrl+c":
 			return m, tea.Quit
@@ -155,13 +167,54 @@ func (m model) updateKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 	case screenConfirm:
 		return m.updateConfirm(msg)
 	}
-
 	if msg.String() == "ctrl+c" {
 		return m, tea.Quit
 	}
 	return m, nil
 }
 
+// updateMain handles keys on the main (two-column) screen.
+func (m model) updateMain(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	if m.panelFocus {
+		return m.updateMainPanel(msg)
+	}
+	// Switch focus to right panel.
+	if (msg.String() == "tab" || msg.String() == "right" || msg.String() == "l") && len(m.panel.Rows) > 0 {
+		m.panelFocus = true
+		return m, nil
+	}
+	return m.updateMenu(msg, len(m.mainMenu), m.handleMainMenu)
+}
+
+// updateMainPanel handles keys when right panel has focus.
+func (m model) updateMainPanel(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch msg.String() {
+	case "up", "k":
+		if m.panelCursor > 0 {
+			m.panelCursor--
+		}
+	case "down", "j":
+		if m.panelCursor < len(m.panel.Rows)-1 {
+			m.panelCursor++
+		}
+	case "enter":
+		if m.panelCursor < len(m.panel.Rows) {
+			key := m.panel.Rows[m.panelCursor].Key
+			m.busy = true
+			m.busyTitle = key
+			return m, func() tea.Msg {
+				r := m.app.ComponentDetailResult(key)
+				return resultMsg{title: r.Title, body: r.Body, back: screenMain}
+			}
+		}
+	case "tab", "left", "h", "esc":
+		m.panelFocus = false
+	case "q", "ctrl+c":
+		return m, tea.Quit
+	}
+	return m, nil
+}
+
 func (m model) updateMenu(msg tea.KeyMsg, size int, onEnter func() (tea.Model, tea.Cmd)) (tea.Model, tea.Cmd) {
 	if size == 0 {
 		size = 1
@@ -179,7 +232,10 @@ func (m model) updateMenu(msg tea.KeyMsg, size int, onEnter func() (tea.Model, t
 		return onEnter()
 	case "esc":
 		switch m.screen {
-		case screenNetwork, screenServices, screenAcceptance:
+		case screenNetwork, screenServices:
+			m.screen = screenSettings
+			m.cursor = 0
+		case screenSettings:
 			m.screen = screenMain
 			m.cursor = 0
 		case screenServiceAction:

audit/internal/tui/view.go

@@ -6,36 +6,65 @@ import (
 
 	"bee/audit/internal/platform"
 
+	"github.com/charmbracelet/lipgloss"
 	tea "github.com/charmbracelet/bubbletea"
 )
 
+// Column widths for two-column main layout.
+const leftColWidth = 30
+
+var (
+	stylePass   = lipgloss.NewStyle().Foreground(lipgloss.Color("10")) // bright green
+	styleFail   = lipgloss.NewStyle().Foreground(lipgloss.Color("9"))  // bright red
+	styleCancel = lipgloss.NewStyle().Foreground(lipgloss.Color("11")) // bright yellow
+	styleNA     = lipgloss.NewStyle().Foreground(lipgloss.Color("8"))  // dark gray
+)
+
+func colorStatus(status string) string {
+	switch status {
+	case "PASS":
+		return stylePass.Render("PASS")
+	case "FAIL":
+		return styleFail.Render("FAIL")
+	case "CANCEL":
+		return styleCancel.Render("CANC")
+	default:
+		return styleNA.Render("N/A ")
+	}
+}
+
 func (m model) View() string {
 	if m.busy {
 		title := "bee"
 		if m.busyTitle != "" {
 			title = m.busyTitle
 		}
+		if len(m.progressLines) > 0 {
+			var b strings.Builder
+			fmt.Fprintf(&b, "%s\n\n", title)
+			for _, l := range m.progressLines {
+				fmt.Fprintf(&b, "  %s\n", l)
+			}
+			b.WriteString("\n[ctrl+c] quit\n")
+			return b.String()
+		}
 		return fmt.Sprintf("%s\n\nWorking...\n\n[ctrl+c] quit\n", title)
 	}
 	switch m.screen {
 	case screenMain:
-		return renderMainMenu("bee", m.banner, "Select action", m.mainMenu, m.cursor)
+		return renderTwoColumnMain(m)
+	case screenHealthCheck:
+		return renderHealthCheck(m)
+	case screenSettings:
+		return renderMenu("Settings", "Select action", m.settingsMenu, m.cursor)
 	case screenNetwork:
 		return renderMenu("Network", "Select action", m.networkMenu, m.cursor)
 	case screenServices:
 		return renderMenu("Services", "Select service", m.services, m.cursor)
 	case screenServiceAction:
-		items := make([]string, len(m.serviceMenu))
-		copy(items, m.serviceMenu)
-		return renderMenu("Service: "+m.selectedService, "Select action", items, m.cursor)
-	case screenAcceptance:
-		return renderMenu("Acceptance tests", "Select action", []string{"Run NVIDIA command pack", "Run memory test", "Run storage diagnostic pack", "Back"}, m.cursor)
+		return renderMenu("Service: "+m.selectedService, "Select action", m.serviceMenu, m.cursor)
 	case screenExportTargets:
-		title := "Export audit"
-		if m.pendingAction == actionExportBundle {
-			title = "Export support bundle"
-		}
-		return renderMenu(title, "Select removable filesystem", renderTargetItems(m.targets), m.cursor)
+		return renderMenu("Export support bundle", "Select removable filesystem", renderTargetItems(m.targets), m.cursor)
 	case screenInterfacePick:
 		return renderMenu("Interfaces", "Select interface", renderInterfaceItems(m.interfaces), m.cursor)
 	case screenStaticForm:
@@ -54,27 +83,73 @@ func (m model) View() string {
 	}
 }
 
-func (m model) confirmBody() (string, string) {
-	switch m.pendingAction {
-	case actionExportAudit:
-		if m.selectedTarget == nil {
-			return "Export audit", "No target selected"
+// renderTwoColumnMain renders the main screen with menu on the left and hardware panel on the right.
+func renderTwoColumnMain(m model) string {
+	// Left column lines
+	leftLines := []string{"bee", ""}
+	for i, item := range m.mainMenu {
+		pfx := "  "
+		if !m.panelFocus && m.cursor == i {
+			pfx = "> "
 		}
-		return "Export audit", fmt.Sprintf("Copy latest audit JSON to %s?", m.selectedTarget.Device)
-	case actionExportBundle:
-		if m.selectedTarget == nil {
-			return "Export support bundle", "No target selected"
-		}
-		return "Export support bundle", fmt.Sprintf("Copy support bundle archive to %s?", m.selectedTarget.Device)
-	case actionRunNvidiaSAT:
-		return "NVIDIA SAT", "Run NVIDIA acceptance command pack?"
-	case actionRunMemorySAT:
-		return "Memory SAT", "Run runtime memory test with memtester?"
-	case actionRunStorageSAT:
-		return "Storage SAT", "Run storage diagnostic pack and start short self-tests where supported?"
-	default:
-		return "Confirm", "Proceed?"
+		leftLines = append(leftLines, pfx+item)
 	}
+
+	// Right column lines
+	rightLines := buildPanelLines(m)
+
+	// Render side by side
+	var b strings.Builder
+	maxRows := max(len(leftLines), len(rightLines))
+	for i := 0; i < maxRows; i++ {
+		l := ""
+		if i < len(leftLines) {
+			l = leftLines[i]
+		}
+		r := ""
+		if i < len(rightLines) {
+			r = rightLines[i]
+		}
+		w := lipgloss.Width(l)
+		if w < leftColWidth {
+			l += strings.Repeat(" ", leftColWidth-w)
+		}
+		b.WriteString(l + " │ " + r + "\n")
+	}
+
+	sep := strings.Repeat("─", leftColWidth) + "─┴─" + strings.Repeat("─", 46)
+	b.WriteString(sep + "\n")
+
+	if m.panelFocus {
+		b.WriteString("[↑↓] move  [enter] details  [tab/←] menu  [ctrl+c] quit\n")
+	} else {
+		b.WriteString("[↑↓] move  [enter] select  [tab/→] panel  [ctrl+c] quit\n")
+	}
+
+	return b.String()
+}
+
+func buildPanelLines(m model) []string {
+	p := m.panel
+	var lines []string
+
+	for _, h := range p.Header {
+		lines = append(lines, h)
+	}
+	if len(p.Header) > 0 && len(p.Rows) > 0 {
+		lines = append(lines, "")
+	}
+
+	for i, row := range p.Rows {
+		pfx := "  "
+		if m.panelFocus && m.panelCursor == i {
+			pfx = "> "
+		}
+		status := colorStatus(row.Status)
+		lines = append(lines, fmt.Sprintf("%s%s  %-4s  %s", pfx, status, row.Key, row.Detail))
+	}
+
+	return lines
 }
 
 func renderTargetItems(targets []platform.RemovableTarget) []string {
@@ -122,30 +197,6 @@ func renderMenu(title, subtitle string, items []string, cursor int) string {
 	return body.String()
 }
 
-func renderMainMenu(title, banner, subtitle string, items []string, cursor int) string {
-	var body strings.Builder
-	fmt.Fprintf(&body, "%s\n\n", title)
-	if banner != "" {
-		body.WriteString(strings.TrimSpace(banner))
-		body.WriteString("\n\n")
-	}
-	body.WriteString(subtitle)
-	body.WriteString("\n\n")
-	if len(items) == 0 {
-		body.WriteString("(no items)\n")
-	} else {
-		for i, item := range items {
-			prefix := "  "
-			if i == cursor {
-				prefix = "> "
-			}
-			fmt.Fprintf(&body, "%s%s\n", prefix, item)
-		}
-	}
-	body.WriteString("\n[↑/↓] move  [enter] select  [esc] back  [ctrl+c] quit\n")
-	return body.String()
-}
-
 func renderForm(title string, fields []formField, idx int) string {
 	var body strings.Builder
 	fmt.Fprintf(&body, "%s\n\n", title)

bible-local/backlog.md

@@ -1,5 +1,26 @@
 # Backlog
 
+## BMC версия через IPMI
+
+**Статус:** реализовано.
+
+Добавить сбор версии BMC firmware в board collector:
+- Команда: `ipmitool mc info` → поле `Firmware Revision`
+- Записывать в `hardware.firmware[]` как `{device_name: "BMC", version: "..."}`
+- Показывать в TUI правой колонке рядом с BIOS версией
+- Graceful skip если `/dev/ipmi0` отсутствует (silent: same pattern as PSU collector)
+
+## CPU acceptance test через stress-ng
+
+**Статус:** реализовано. CPU в Health Check получает PASS/FAIL из summary.txt.
+
+Добавить CPU SAT на базе `stress-ng`:
+- Bake `stress-ng` в ISO (добавить в `bee.list.chroot`)
+- Новый `bee sat cpu` — запускает `stress-ng --cpu 0 --cpu-method all --timeout <N>` где N = duration из режима (Quick=60s, Standard=300s, Express=900s)
+- Параллельно снимает температуры через `sensors` и throttle-флаги из аудит JSON
+- Результат: SAT архив с summary.txt в формате других SAT (overall_status=OK/FAILED)
+- После реализации: CPU в Health Check получает реальный PASS/FAIL статус
+
 ## Real hardware validation
 
 **Статус:** ожидает доступа к железу.

iso/builder/Dockerfile

@@ -1,7 +1,6 @@
 FROM debian:12
 
 ARG GO_VERSION=1.24.0
-ARG DEBIAN_KERNEL_ABI=6.1.0-43
 
 ENV DEBIAN_FRONTEND=noninteractive
 
@@ -24,7 +23,7 @@ RUN apt-get update -qq && apt-get install -y \
     gcc \
     make \
     perl \
-    "linux-headers-${DEBIAN_KERNEL_ABI}-amd64" \
+    linux-headers-amd64 \
     && rm -rf /var/lib/apt/lists/*
 
 RUN arch="$(dpkg --print-architecture)" \

iso/builder/VERSIONS

@@ -1,5 +1,8 @@
 DEBIAN_VERSION=12
-DEBIAN_KERNEL_ABI=6.1.0-43
+DEBIAN_KERNEL_ABI=auto
 NVIDIA_DRIVER_VERSION=590.48.01
+NCCL_VERSION=2.28.9-1
+NCCL_CUDA_VERSION=13.0
+NCCL_SHA256=2e6faafd2c19cffc7738d9283976a3200ea9db9895907f337f0c7e5a25563186
 GO_VERSION=1.24.0
 AUDIT_VERSION=1.0.0

iso/builder/auto/config

@@ -7,6 +7,15 @@ set -e
 
 . "$(dirname "$0")/../VERSIONS"
 
+# Pin the exact kernel ABI detected by build.sh so the ISO kernel matches
+# the kernel headers used to compile NVIDIA modules. Falls back to meta-package
+# when lb config is run manually without the environment variable.
+if [ -n "${BEE_KERNEL_ABI:-}" ] && [ "${BEE_KERNEL_ABI}" != "auto" ]; then
+    LB_LINUX_PACKAGES="linux-image-${BEE_KERNEL_ABI}"
+else
+    LB_LINUX_PACKAGES="linux-image"
+fi
+
 lb config noauto \
     --distribution bookworm \
     --architectures amd64 \
@@ -19,10 +28,10 @@ lb config noauto \
     --mirror-binary "https://deb.debian.org/debian" \
     --security true \
     --linux-flavours "amd64" \
-    --linux-packages "linux-image-${DEBIAN_KERNEL_ABI}" \
+    --linux-packages "${LB_LINUX_PACKAGES}" \
     --memtest none \
-    --iso-volume "BEE" \
-    --iso-application "Bee Hardware Audit" \
+    --iso-volume "EASY-BEE" \
+    --iso-application "EASY-BEE" \
     --bootappend-live "boot=live components console=tty0 console=ttyS0,115200n8 username=bee user-fullname=Bee modprobe.blacklist=nouveau" \
     --apt-recommends false \
     "${@}"

iso/builder/build-in-container.sh

@@ -59,7 +59,6 @@ IMAGE_REF="${IMAGE_TAG}:debian${DEBIAN_VERSION}"
 if [ "$REBUILD_IMAGE" = "1" ] || ! "$CONTAINER_TOOL" image inspect "${IMAGE_REF}" >/dev/null 2>&1; then
     "$CONTAINER_TOOL" build \
         --build-arg GO_VERSION="${GO_VERSION}" \
-        --build-arg DEBIAN_KERNEL_ABI="${DEBIAN_KERNEL_ABI}" \
         -t "${IMAGE_REF}" \
         "${BUILDER_DIR}"
 else

iso/builder/build-nccl.sh

@@ -0,0 +1,94 @@
+#!/bin/sh
+# build-nccl.sh — download and extract NCCL shared library for the LiveCD.
+#
+# Downloads libnccl2 .deb from NVIDIA's CUDA apt repository (Debian 12, x86_64)
+# and extracts the shared library. Package integrity verified via sha256.
+#
+# Output is cached in DIST_DIR/nccl-<version>+cuda<cuda>/ so subsequent builds
+# are instant unless NCCL_VERSION or NCCL_CUDA_VERSION changes.
+#
+# Output layout:
+#   $CACHE_DIR/lib/   — libnccl.so.* files
+
+set -e
+
+NCCL_VERSION="$1"
+NCCL_CUDA_VERSION="$2"
+DIST_DIR="$3"
+EXPECTED_SHA256="$4"
+
+[ -n "$NCCL_VERSION" ]      || { echo "usage: $0 <nccl-version> <cuda-version> <dist-dir> [sha256]"; exit 1; }
+[ -n "$NCCL_CUDA_VERSION" ] || { echo "usage: $0 <nccl-version> <cuda-version> <dist-dir> [sha256]"; exit 1; }
+[ -n "$DIST_DIR" ]          || { echo "usage: $0 <nccl-version> <cuda-version> <dist-dir> [sha256]"; exit 1; }
+
+echo "=== NCCL ${NCCL_VERSION}+cuda${NCCL_CUDA_VERSION} ==="
+
+CACHE_DIR="${DIST_DIR}/nccl-${NCCL_VERSION}+cuda${NCCL_CUDA_VERSION}"
+CACHE_ROOT="${BEE_CACHE_DIR:-${DIST_DIR}/cache}"
+DOWNLOAD_CACHE_DIR="${CACHE_ROOT}/nccl-downloads"
+
+if [ -d "$CACHE_DIR/lib" ] && [ "$(ls "$CACHE_DIR/lib/"libnccl.so.* 2>/dev/null | wc -l)" -gt 0 ]; then
+    echo "=== NCCL cached, skipping download ==="
+    echo "cache: $CACHE_DIR"
+    echo "libs: $(ls "$CACHE_DIR/lib/" | wc -l) files"
+    exit 0
+fi
+
+REPO_BASE="https://developer.download.nvidia.com/compute/cuda/repos/debian12/x86_64"
+PKG_NAME="libnccl2_${NCCL_VERSION}+cuda${NCCL_CUDA_VERSION}_amd64.deb"
+PKG_URL="${REPO_BASE}/${PKG_NAME}"
+
+mkdir -p "$DOWNLOAD_CACHE_DIR"
+DEB_FILE="${DOWNLOAD_CACHE_DIR}/${PKG_NAME}"
+
+echo "=== downloading NCCL package ==="
+echo "URL: ${PKG_URL}"
+wget --show-progress -O "$DEB_FILE" "$PKG_URL"
+
+if [ -n "$EXPECTED_SHA256" ]; then
+    echo "=== verifying sha256 ==="
+    ACTUAL_SHA256=$(sha256sum "$DEB_FILE" | awk '{print $1}')
+    if [ "$ACTUAL_SHA256" != "$EXPECTED_SHA256" ]; then
+        echo "ERROR: sha256 mismatch"
+        echo "  expected: $EXPECTED_SHA256"
+        echo "  actual:   $ACTUAL_SHA256"
+        rm -f "$DEB_FILE"
+        exit 1
+    fi
+    echo "sha256 OK"
+fi
+
+echo "=== extracting NCCL libraries ==="
+EXTRACT_TMP=$(mktemp -d)
+trap 'rm -rf "$EXTRACT_TMP"' EXIT INT TERM
+
+# .deb is an ar archive; data.tar.* contains the actual files
+cd "$EXTRACT_TMP"
+ar x "$DEB_FILE"
+
+# Extract data tarball (xz, gz, or zst)
+DATA_TAR=$(ls data.tar.* 2>/dev/null | head -1)
+[ -n "$DATA_TAR" ] || { echo "ERROR: data.tar.* not found in .deb"; exit 1; }
+tar xf "$DATA_TAR"
+
+# Library lands in ./usr/lib/x86_64-linux-gnu/ or ./usr/lib/
+mkdir -p "$CACHE_DIR/lib"
+found=0
+for f in $(find . -name 'libnccl.so.*' -not -type d 2>/dev/null); do
+    cp "$f" "$CACHE_DIR/lib/"
+    found=$((found + 1))
+done
+
+[ "$found" -gt 0 ] || { echo "ERROR: libnccl.so.* not found in package"; exit 1; }
+
+# Create soname symlinks: libnccl.so.2 -> libnccl.so.<full>, libnccl.so -> libnccl.so.2
+versioned=$(ls "$CACHE_DIR/lib/libnccl.so."[0-9][0-9.]* 2>/dev/null | head -1)
+if [ -n "$versioned" ]; then
+    base=$(basename "$versioned")
+    ln -sf "$base" "$CACHE_DIR/lib/libnccl.so.2" 2>/dev/null || true
+    ln -sf "libnccl.so.2" "$CACHE_DIR/lib/libnccl.so" 2>/dev/null || true
+fi
+
+echo "=== NCCL extraction complete ==="
+echo "cache: $CACHE_DIR"
+ls -lh "$CACHE_DIR/lib/"

iso/builder/build.sh

@@ -34,6 +34,34 @@ mkdir -p "${CACHE_ROOT}"
 : "${GOMODCACHE:=${CACHE_ROOT}/go-mod}"
 export GOCACHE GOMODCACHE
 
+# Auto-detect kernel ABI: refresh apt index, then query current linux-image-amd64 dependency.
+# If headers for the detected ABI are not yet installed (kernel updated since image build),
+# install them on the fly so NVIDIA modules and ISO kernel always match.
+if [ -z "${DEBIAN_KERNEL_ABI}" ] || [ "${DEBIAN_KERNEL_ABI}" = "auto" ]; then
+    echo "=== refreshing apt index to detect current kernel ABI ==="
+    apt-get update -qq
+    DEBIAN_KERNEL_ABI=$(apt-cache depends linux-image-amd64 2>/dev/null \
+        | awk '/Depends:.*linux-image-[0-9]/{print $2}' \
+        | grep -oE '[0-9]+\.[0-9]+\.[0-9]+-[0-9]+' \
+        | head -1)
+    if [ -z "${DEBIAN_KERNEL_ABI}" ]; then
+        echo "ERROR: could not auto-detect kernel ABI from apt-cache" >&2
+        exit 1
+    fi
+    echo "=== kernel ABI: ${DEBIAN_KERNEL_ABI} ==="
+fi
+
+# Export detected ABI so that auto/config can pin the exact kernel package
+# (prevents NVIDIA module/kernel mismatch if linux-image-amd64 meta-package
+# gets updated between build.sh start and lb build chroot step)
+export BEE_KERNEL_ABI="${DEBIAN_KERNEL_ABI}"
+
+KVER="${DEBIAN_KERNEL_ABI}-amd64"
+if [ ! -d "/usr/src/linux-headers-${KVER}" ]; then
+    echo "=== installing linux-headers-${KVER} (kernel updated since image build) ==="
+    apt-get install -y "linux-headers-${KVER}"
+fi
+
 echo "=== bee ISO build ==="
 echo "Debian: ${DEBIAN_VERSION}, Kernel ABI: ${DEBIAN_KERNEL_ABI}, Go: ${GO_VERSION}"
 echo ""
@@ -186,6 +214,17 @@ if [ -d "${NVIDIA_CACHE}/firmware" ] && [ "$(ls -A "${NVIDIA_CACHE}/firmware" 2>
     echo "=== firmware: $(ls "${OVERLAY_STAGE_DIR}/lib/firmware/nvidia/${NVIDIA_DRIVER_VERSION}/" | wc -l) files injected ==="
 fi
 
+# --- build / download NCCL ---
+echo ""
+echo "=== downloading NCCL ${NCCL_VERSION}+cuda${NCCL_CUDA_VERSION} ==="
+sh "${BUILDER_DIR}/build-nccl.sh" "${NCCL_VERSION}" "${NCCL_CUDA_VERSION}" "${DIST_DIR}" "${NCCL_SHA256:-}"
+
+NCCL_CACHE="${DIST_DIR}/nccl-${NCCL_VERSION}+cuda${NCCL_CUDA_VERSION}"
+
+# Inject libnccl.so.* into overlay alongside other NVIDIA userspace libs
+cp "${NCCL_CACHE}/lib/"* "${OVERLAY_STAGE_DIR}/usr/lib/"
+echo "=== NCCL: $(ls "${NCCL_CACHE}/lib/" | wc -l) files injected into /usr/lib/ ==="
+
 # --- embed build metadata ---
 mkdir -p "${OVERLAY_STAGE_DIR}/etc"
 BUILD_DATE="$(date +%Y-%m-%d)"
@@ -198,6 +237,8 @@ GIT_COMMIT=${GIT_COMMIT}
 DEBIAN_VERSION=${DEBIAN_VERSION}
 DEBIAN_KERNEL_ABI=${DEBIAN_KERNEL_ABI}
 NVIDIA_DRIVER_VERSION=${NVIDIA_DRIVER_VERSION}
+NCCL_VERSION=${NCCL_VERSION}
+NCCL_CUDA_VERSION=${NCCL_CUDA_VERSION}
 EOF
 
 # Patch motd with build info

iso/builder/config/bootloaders/grub-pc/grub.cfg

@@ -1,11 +1,20 @@
 source /boot/grub/config.cfg
 
-menuentry "Bee Hardware Audit" {
+echo ""
+echo "  ███████╗ █████╗ ███████╗██╗   ██╗      ██████╗ ███████╗███████╗"
+echo "  ██╔════╝██╔══██╗██╔════╝╚██╗ ██╔╝      ██╔══██╗██╔════╝██╔════╝"
+echo "  █████╗  ███████║███████╗ ╚████╔╝ █████╗██████╔╝█████╗  █████╗"
+echo "  ██╔══╝  ██╔══██║╚════██║  ╚██╔╝  ╚════╝██╔══██╗██╔══╝  ██╔══╝"
+echo "  ███████╗██║  ██║███████║   ██║         ██████╔╝███████╗███████╗"
+echo "  ╚══════╝╚═╝  ╚═╝╚══════╝   ╚═╝         ╚═════╝ ╚══════╝╚══════╝"
+echo ""
+
+menuentry "EASY-BEE" {
     linux   @KERNEL_LIVE@ @APPEND_LIVE@
     initrd  @INITRD_LIVE@
 }
 
-menuentry "Bee Hardware Audit (fail-safe)" {
+menuentry "EASY-BEE (fail-safe)" {
     linux   @KERNEL_LIVE@ @APPEND_LIVE@ memtest noapic noapm nodma nomce nolapic nosmp vga=normal
     initrd  @INITRD_LIVE@
 }

iso/builder/config/bootloaders/grub-pc/live-theme/theme.txt

@@ -1,4 +1,4 @@
-desktop-image: "../splash.png"
+desktop-color: "#000000"
 title-color: "#f5a800"
 title-font: "Unifont Regular 16"
 title-text: ""

iso/builder/config/hooks/normal/9001-amd-rocm.hook.chroot

@@ -0,0 +1,39 @@
+#!/bin/sh
+# 9001-amd-rocm.hook.chroot — install AMD ROCm SMI tool for Instinct GPU monitoring.
+# Runs inside the live-build chroot. Adds AMD's apt repository and installs
+# rocm-smi-lib which provides the `rocm-smi` CLI (analogous to nvidia-smi).
+
+set -e
+
+ROCM_VERSION="6.4"
+ROCM_KEYRING="/etc/apt/keyrings/rocm.gpg"
+ROCM_LIST="/etc/apt/sources.list.d/rocm.list"
+
+echo "=== AMD ROCm ${ROCM_VERSION}: adding repository ==="
+
+mkdir -p /etc/apt/keyrings
+
+# Download and import AMD GPG key
+if ! wget -qO- "https://repo.radeon.com/rocm/rocm.gpg.key" \
+        | gpg --dearmor > "${ROCM_KEYRING}"; then
+    echo "WARN: failed to fetch AMD ROCm GPG key — skipping ROCm install"
+    exit 0
+fi
+
+cat > "${ROCM_LIST}" <<EOF
+deb [arch=amd64 signed-by=${ROCM_KEYRING}] https://repo.radeon.com/rocm/apt/${ROCM_VERSION} bookworm main
+EOF
+
+apt-get update -qq
+
+# rocm-smi-lib provides the rocm-smi CLI tool for GPU monitoring
+if apt-get install -y --no-install-recommends rocm-smi-lib 2>/dev/null; then
+    echo "=== AMD ROCm: rocm-smi installed ==="
+    rocm-smi --version 2>/dev/null || true
+else
+    echo "WARN: rocm-smi-lib install failed — GPU monitoring unavailable"
+fi
+
+# Clean up apt lists to keep ISO size down
+rm -f "${ROCM_LIST}"
+apt-get clean

iso/builder/config/package-lists/bee.list.chroot

@@ -18,6 +18,10 @@ qemu-guest-agent
 # SSH
 openssh-server
 
+# Filesystem support for USB export targets
+exfatprogs
+ntfs-3g
+
 # Utilities
 bash
 procps
@@ -32,12 +36,14 @@ sudo
 zstd
 mstflint
 memtester
+stress-ng
 
 # QR codes (for displaying audit results)
 qrencode
 
 # Firmware
 firmware-linux-free
+firmware-amd-graphics
 
 # glibc compat helpers (for any external binaries that need it)
 libc6

iso/overlay/etc/motd

@@ -1,10 +1,10 @@
 
-  ██████╗ ███████╗███████╗    ██████╗ ███████╗██████╗ ██╗   ██╗ ██████╗
-  ██╔══██╗██╔════╝██╔════╝    ██╔══██╗██╔════╝██╔══██╗██║   ██║██╔════╝
-  ██████╔╝█████╗  █████╗      ██║  ██║█████╗  ██████╔╝██║   ██║██║  ███╗
-  ██╔══██╗██╔══╝  ██╔══╝      ██║  ██║██╔══╝  ██╔══██╗██║   ██║██║   ██║
-  ██████╔╝███████╗███████╗    ██████╔╝███████╗██████╔╝╚██████╔╝╚██████╔╝
-  ╚═════╝ ╚══════╝╚══════╝    ╚═════╝ ╚══════╝╚═════╝  ╚═════╝  ╚═════╝
+  ███████╗ █████╗ ███████╗██╗   ██╗      ██████╗ ███████╗███████╗
+  ██╔════╝██╔══██╗██╔════╝╚██╗ ██╔╝      ██╔══██╗██╔════╝██╔════╝
+  █████╗  ███████║███████╗ ╚████╔╝ █████╗██████╔╝█████╗  █████╗
+  ██╔══╝  ██╔══██║╚════██║  ╚██╔╝  ╚════╝██╔══██╗██╔══╝  ██╔══╝
+  ███████╗██║  ██║███████║   ██║         ██████╔╝███████╗███████╗
+  ╚══════╝╚═╝  ╚═╝╚══════╝   ╚═╝         ╚═════╝ ╚══════╝╚══════╝
 
   Hardware Audit LiveCD
   Build: %%BUILD_INFO%%

iso/overlay/etc/systemd/system.conf.d/watchdog.conf

@@ -0,0 +1,4 @@
+[Manager]
+# Pet the hardware watchdog every 30s so the host doesn't reboot mid-audit.
+# Kernel watchdog timeout is typically 60s; 30s gives a safe 2× margin.
+RuntimeWatchdogSec=30s

iso/overlay/usr/local/bin/bee-nvidia-load

@@ -8,6 +8,12 @@ log() { echo "[bee-nvidia] $*"; }
 
 log "kernel: $(uname -r)"
 
+# Skip if no NVIDIA GPU present (PCI vendor 10de)
+if ! lspci -nn 2>/dev/null | grep -qi '10de:'; then
+    log "no NVIDIA GPU detected — skipping module load"
+    exit 0
+fi
+
 if [ ! -d "$NVIDIA_KO_DIR" ]; then
     log "ERROR: NVIDIA module dir missing: $NVIDIA_KO_DIR"
     exit 1

iso/overlay/usr/local/bin/bee-tui

@@ -1,5 +1,7 @@
 #!/bin/sh
 
+clear
+
 if [ "$(id -u)" -ne 0 ]; then
     exec sudo -n /usr/local/bin/bee tui --runtime livecd "$@"
 fi