platform/cmd/webui: add a scriptable test-scenario engine, load scenarios from blackbox USB, GPU status detail inventory fallback

Investigating the CG480-S6053 reboot needed a way to run an ad-hoc load
(nvbandwidth across a specific GPU set) while sampling IPMI/nvidia-smi
telemetry in the background — without hardcoding a one-off test into the
SAT pack code for a single investigation.

- audit/internal/platform/scenario.go: ScenarioSpec/ScenarioJob (JSON,
  no new dependency) + System.RunScenario. "command" jobs run sequential
  or parallel (per-job "parallel" flag); "sampler" jobs run concurrently
  in the background on their own interval until every command job
  finishes or the scenario's timeout elapses. "{{gpus}}" in a command's
  cmd is substituted from that job's gpu_indices. Command jobs are wired
  through the same satJobBoundaryHook/satSyncBracketHook seams the SAT
  job runner uses, so a scenario run gets the same durability treatment
  (evidence that a risky command started/finished reaches blackbox before
  a possible crash, not just whatever streamed to the RAM-backed export
  dir).
- export.go: ReadScenarioFromRemovableMedia mounts each removable target
  looking for scenarios/<name>.json — an air-gapped engineer can author a
  scenario elsewhere, drop it under scenarios/ on the same USB stick
  already plugged in for blackbox, and run it with no network path onto
  the host.
- cmd/bee: new `bee run <file.json|name>` (bare name = looked up on
  removable media); `bee scenario run <arg>` kept as a longer alias.
- scenarios/nvbandwidth-all-gpu-power-watch.json: the scenario that
  reproduced the actual reboot (full nvbandwidth across all GPUs, which
  crashed, vs. clean per-socket passes), with IPMI sensor + GPU power/temp
  sampling for a power-delivery correlation check.

Also: webui/page_topo.go — the /topo page's component-status-detail modal
(GET /api/component-detail/{type}) showed "No status data recorded yet"
for any component type ComponentStatusDB has no history for yet (e.g. GPU
before a SAT run this boot), even though the topology card for the same
component already showed "N OK" from the audit inventory snapshot.
inventoryFallbackRecords now synthesizes records from that same inventory
snapshot when StatusDB is empty, using the same device classifiers
(isGPUDeviceClass etc.) and severity mapping (classifyTopoSeverity) the
topology card itself uses, so the two views never disagree.

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

audit/internal/webui/api.go

@@ -1865,9 +1865,17 @@ func (h *handler) handleAPIComponentDetail(w http.ResponseWriter, r *http.Reques
 		records = matchedRecords(all, exact, prefixes)
 	}
 
+	fromInventory := false
+	if len(records) == 0 {
+		if fallback := inventoryFallbackRecords(compType, h.opts); len(fallback) > 0 {
+			records = fallback
+			fromInventory = true
+		}
+	}
+
 	w.Header().Set("Content-Type", "text/html; charset=utf-8")
 	w.Header().Set("Cache-Control", "no-store")
-	fmt.Fprint(w, renderComponentDetail(title, records))
+	fmt.Fprint(w, renderComponentDetail(title, records, fromInventory))
 }
 
 func (h *handler) rollbackPendingNetworkChange() error {

audit/internal/webui/page_topo.go

@@ -11,6 +11,7 @@ import (
 	"strconv"
 	"strings"
 
+	"bee/audit/internal/app"
 	"bee/audit/internal/schema"
 )
 
@@ -1221,3 +1222,126 @@ func errNoteSuffix(hasError bool) string {
 	}
 	return ""
 }
+
+// ---------------------------------------------------------------------------
+// Inventory fallback for the component-detail modal
+//
+// handleAPIComponentDetail normally sources records from app.ComponentStatusDB,
+// which only gains entries once something has actually written a status
+// observation (SAT run, watchdog tick, ...). On a freshly booted host that
+// hasn't run SAT yet, StatusDB can be entirely empty for a component type even
+// though the /topo card for it already shows "N OK" — that card reads
+// schema.HardwareComponentStatus.Status straight from the audit snapshot.
+// inventoryFallbackRecords bridges that gap by building synthetic records
+// from the same snapshot/classifiers the topology card uses, so the two
+// views never disagree about how many devices exist or their status.
+// ---------------------------------------------------------------------------
+
+// topoSeverityStatus renders classifyTopoSeverity's rank back into the status
+// string vocabulary renderComponentDetail/chipLetterClass expect ("OK",
+// "Warning", "Critical", "Unknown") — kept in lockstep with classifyTopoSeverity
+// so a device the topo card counts as "OK" is never shown here as "Unknown".
+func topoSeverityStatus(status *string) string {
+	switch classifyTopoSeverity(status) {
+	case 3:
+		return "Critical"
+	case 2:
+		return "Warning"
+	case 1:
+		return "OK"
+	default:
+		return "Unknown"
+	}
+}
+
+// pcieDeviceKind classifies a PCIe device the same way renderTopoMainDiagram
+// does, returning "" for devices that aren't GPU/NIC/RAID.
+func pcieDeviceKind(dev schema.HardwarePCIeDevice) string {
+	switch {
+	case dev.DeviceClass != nil && isGPUDeviceClass(*dev.DeviceClass):
+		return "gpu"
+	case isNICDeviceClassDev(dev):
+		return "nic"
+	case dev.DeviceClass != nil && isRAIDControllerClass(*dev.DeviceClass):
+		return "raid"
+	default:
+		return ""
+	}
+}
+
+// pcieDeviceKey builds a stable, human-readable component key for a PCIe
+// device: "<kind>:<bdf>" when a slot/BDF is known, else "<kind>:<index>".
+func pcieDeviceKey(kind string, index int, dev schema.HardwarePCIeDevice) string {
+	bdf := ""
+	if dev.Slot != nil {
+		bdf = normalizeTopoBDF(*dev.Slot)
+	} else if dev.BDF != nil {
+		bdf = normalizeTopoBDF(*dev.BDF)
+	}
+	if bdf != "" {
+		return kind + ":" + bdf
+	}
+	return fmt.Sprintf("%s:%d", kind, index)
+}
+
+// inventoryFallbackRecords builds ComponentStatusRecord entries straight from
+// the audit inventory (bee-audit.json) for the given component type, used
+// when ComponentStatusDB has no matching records yet. Records carry only
+// ComponentKey/Status — no LastCheckedAt/History — so renderComponentDetail
+// renders them without a "checked at" timestamp or sparkline.
+func inventoryFallbackRecords(compType string, opts HandlerOptions) []app.ComponentStatusRecord {
+	data, err := loadSnapshot(opts.AuditPath)
+	if err != nil {
+		return nil
+	}
+	var ingest schema.HardwareIngestRequest
+	if err := json.Unmarshal(data, &ingest); err != nil {
+		return nil
+	}
+	hw := ingest.Hardware
+
+	var records []app.ComponentStatusRecord
+	switch compType {
+	case "cpu":
+		for i, cpu := range hw.CPUs {
+			key := fmt.Sprintf("cpu:%d", i)
+			if cpu.Socket != nil {
+				key = fmt.Sprintf("cpu:socket%d", *cpu.Socket)
+			}
+			records = append(records, app.ComponentStatusRecord{ComponentKey: key, Status: topoSeverityStatus(cpu.Status)})
+		}
+	case "memory":
+		for i, m := range hw.Memory {
+			key := fmt.Sprintf("memory:%d", i)
+			if m.Slot != nil && strings.TrimSpace(*m.Slot) != "" {
+				key = "memory:" + strings.TrimSpace(*m.Slot)
+			}
+			records = append(records, app.ComponentStatusRecord{ComponentKey: key, Status: topoSeverityStatus(m.Status)})
+		}
+	case "storage":
+		for i, s := range hw.Storage {
+			key := fmt.Sprintf("storage:%d", i)
+			if s.Slot != nil && strings.TrimSpace(*s.Slot) != "" {
+				key = "storage:" + strings.TrimSpace(*s.Slot)
+			}
+			records = append(records, app.ComponentStatusRecord{ComponentKey: key, Status: topoSeverityStatus(s.Status)})
+		}
+	case "psu":
+		for i, p := range hw.PowerSupplies {
+			key := fmt.Sprintf("psu:%d", i)
+			if p.Slot != nil && strings.TrimSpace(*p.Slot) != "" {
+				key = "psu:" + strings.TrimSpace(*p.Slot)
+			}
+			records = append(records, app.ComponentStatusRecord{ComponentKey: key, Status: topoSeverityStatus(p.Status)})
+		}
+	case "gpu", "nic", "raid":
+		for i, dev := range hw.PCIeDevices {
+			if pcieDeviceKind(dev) != compType {
+				continue
+			}
+			key := pcieDeviceKey(compType, i, dev)
+			records = append(records, app.ComponentStatusRecord{ComponentKey: key, Status: topoSeverityStatus(dev.Status)})
+		}
+	}
+	return records
+}

audit/internal/webui/page_topo_test.go

@@ -576,6 +576,64 @@ GPU 1: NVIDIA H100 80GB HBM3 (UUID: GPU-603fe750-0516-9db5-86ec-ea61af3fce35)
 	}
 }
 
+// TestComponentDetailFallsBackToInventoryWhenStatusDBEmpty covers the bug where
+// a /topo card shows "3 OK" (from schema.HardwareComponentStatus.Status in the
+// audit snapshot) but clicking it opens a modal saying "No status data recorded
+// yet" (because ComponentStatusDB has no pcie:gpu:* entries — nothing has run a
+// SAT test on this boot yet). The modal must show the same 3 devices/status the
+// card does, not an empty state.
+func TestComponentDetailFallsBackToInventoryWhenStatusDBEmpty(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "audit.json")
+
+	okStatus := "OK"
+	warnStatus := "Warning"
+	deviceClass := "VideoController"
+	var gpus []schema.HardwarePCIeDevice
+	for i, st := range []*string{&okStatus, &okStatus, &warnStatus} {
+		slot := "0000:c" + strconv.Itoa(i) + ":00.0"
+		gpus = append(gpus, schema.HardwarePCIeDevice{
+			HardwareComponentStatus: schema.HardwareComponentStatus{Status: st},
+			DeviceClass:             &deviceClass,
+			Slot:                    &slot,
+		})
+	}
+
+	ingest := schema.HardwareIngestRequest{
+		Hardware: schema.HardwareSnapshot{PCIeDevices: gpus},
+	}
+	data, err := json.Marshal(ingest)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(path, data, 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	// No HandlerOptions.App / StatusDB set — matches a host where nothing has
+	// written to ComponentStatusDB yet.
+	handler := NewHandler(HandlerOptions{AuditPath: path})
+	rec := httptest.NewRecorder()
+	handler.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/api/components/gpu", nil))
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
+	}
+	body := rec.Body.String()
+
+	if strings.Contains(body, "No status data recorded yet") {
+		t.Fatalf("modal should not show empty state when inventory has GPUs: %s", body)
+	}
+	if strings.Count(body, "chip-ok") != 2 {
+		t.Fatalf("expected 2 OK chips from inventory fallback: %s", body)
+	}
+	if strings.Count(body, "chip-warn") != 1 {
+		t.Fatalf("expected 1 Warning chip from inventory fallback: %s", body)
+	}
+	if !strings.Contains(body, "No SAT-test history yet") {
+		t.Fatalf("expected fallback marker text: %s", body)
+	}
+}
+
 func TestParseTopoNVLinkErrors(t *testing.T) {
 	input := `GPU 0: NVIDIA H100 80GB HBM3 (UUID: GPU-a59f6931-c099-8fba-a0b3-08469d86f140)
 	 Link 0: Replay Errors: 0

audit/internal/webui/pages.go

@@ -1160,7 +1160,10 @@ func renderSparkline(history []app.ComponentStatusEntry) string {
 
 // renderComponentDetail renders a modal content fragment for one component type.
 // Called by handleAPIComponentDetail and displayed inside #component-detail-dialog.
-func renderComponentDetail(title string, records []app.ComponentStatusRecord) string {
+// fromInventory marks that records were synthesized from the audit inventory
+// snapshot (no ComponentStatusDB history yet) rather than real SAT/watchdog
+// observations — see inventoryFallbackRecords.
+func renderComponentDetail(title string, records []app.ComponentStatusRecord, fromInventory bool) string {
 	var b strings.Builder
 	fmt.Fprintf(&b, `<div style="padding:20px 24px 0">`)
 	fmt.Fprintf(&b, `<div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:16px">`)
@@ -1174,6 +1177,10 @@ func renderComponentDetail(title string, records []app.ComponentStatusRecord) st
 		return b.String()
 	}
 
+	if fromInventory {
+		b.WriteString(`<p style="color:var(--muted);font-size:12px;margin-top:-8px;margin-bottom:16px">No SAT-test history yet — showing latest inventory snapshot.</p>`)
+	}
+
 	sort.Slice(records, func(i, j int) bool {
 		return records[i].ComponentKey < records[j].ComponentKey
 	})