chore(hpe_ilo_ahs): normalize module version format — v1.0

- Add HPE iLO Redfish profile (priority 20): matches on manufacturer/OEM/iLO signals,
  adds SmartStorage/SmartStorageConfig to critical paths, sets realistic ETA baseline
  and rate policy for iLO's known slowness
- Fix post-probe hang on HPE iLO: skip numeric probing of collections where
  Members@odata.count == len(Members); add 4s postProbeClient timeout as safety net
- Exclude /WorkloadPerformanceAdvisor from crawl paths
- Fix replay parser: skip absent CPU sockets, absent DIMM slots, absent drive bays
- Filter N/A version entries from firmware inventory
- Remove drive firmware from general firmware list (already in Storage[].Firmware)
- Add HPE AHS (.ahs) archive parser with hybrid SMBIOS/Redfish extraction

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

bible-local/01-overview.md

@@ -27,8 +27,10 @@ All modes converge on the same normalized hardware model and exporter pipeline.
 ## Current vendor coverage
 
 - Dell TSR
+- Reanimator Easy Bee support bundles
 - H3C SDS G5/G6
 - Inspur / Kaytus
+- HPE iLO AHS
 - NVIDIA HGX Field Diagnostics
 - NVIDIA Bug Report
 - Unraid

bible-local/06-parsers.md

@@ -50,8 +50,10 @@ When `vendor_id` and `device_id` are known but the model name is missing or gene
 | Vendor ID | Input family | Notes |
 |-----------|--------------|-------|
 | `dell` | TSR ZIP archives | Broad hardware, firmware, sensors, lifecycle events |
+| `easy_bee` | `bee-support-*.tar.gz` | Imports embedded `export/bee-audit.json` snapshot from reanimator-easy-bee bundles |
 | `h3c_g5` | H3C SDS G5 bundles | INI/XML/CSV-driven hardware and event parsing |
 | `h3c_g6` | H3C SDS G6 bundles | Similar flow with G6-specific files |
+| `hpe_ilo_ahs` | HPE iLO Active Health System (`.ahs`) | Proprietary `ABJR` container with gzip-compressed `zbb` members; parser combines SMBIOS-style inventory strings and embedded Redfish storage JSON |
 | `inspur` | onekeylog archives | FRU/SDR plus optional Redis enrichment |
 | `nvidia` | HGX Field Diagnostics | GPU- and fabric-heavy diagnostic input |
 | `nvidia_bug_report` | `nvidia-bug-report-*.log.gz` | dmidecode, lspci, NVIDIA driver sections |
@@ -120,6 +122,32 @@ with content markers (e.g. `Unraid kernel build`, parity data markers).
 
 ---
 
+### HPE iLO AHS (`hpe_ilo_ahs`)
+
+**Status:** Ready (v1.0.0). Tested on HPE ProLiant Gen11 `.ahs` export from iLO 6.
+
+**Archive format:** `.ahs` single-file Active Health System export.
+
+**Detection:** Single-file input with `ABJR` container header and HPE AHS member names
+such as `CUST_INFO.DAT`, `*.zbb`, `ilo_boot_support.zbb`.
+
+**Extracted data (current):**
+- System board identity (manufacturer, model, serial, part number)
+- iLO / System ROM / SPS top-level firmware
+- CPU inventory (model-level)
+- Memory DIMM inventory for populated slots
+- PSU inventory
+- PCIe / OCP NIC inventory from SMBIOS-style slot records
+- Storage controller and physical drives from embedded Redfish JSON inside `zbb` members
+- Basic iLO event log entries with timestamps when present
+
+**Implementation note:** The format is proprietary. Parser support is intentionally hybrid:
+container parsing (`ABJR` + gzip) plus structured extraction from embedded Redfish objects and
+printable SMBIOS/FRU payloads. This is sufficient for inventory-grade parsing without decoding the
+entire internal `zbb` schema.
+
+---
+
 ### Generic text fallback (`generic`)
 
 **Status:** Ready (v1.0.0).
@@ -139,6 +167,8 @@ with content markers (e.g. `Unraid kernel build`, parity data markers).
 | Vendor | ID | Status | Tested on |
 |--------|----|--------|-----------|
 | Dell TSR | `dell` | Ready | TSR nested zip archives |
+| Reanimator Easy Bee | `easy_bee` | Ready | `bee-support-*.tar.gz` support bundles |
+| HPE iLO AHS | `hpe_ilo_ahs` | Ready | iLO 6 `.ahs` exports |
 | Inspur / Kaytus | `inspur` | Ready | KR4268X2 onekeylog |
 | NVIDIA HGX Field Diag | `nvidia` | Ready | Various HGX servers |
 | NVIDIA Bug Report | `nvidia_bug_report` | Ready | H100 systems |

bible-local/10-decisions.md

@@ -258,6 +258,9 @@ at parse time before storing in any model struct. Use the regex
 **Date:** 2026-03-12
 **Context:** `shouldAdaptiveNVMeProbe` was introduced in `2fa4a12` to recover NVMe drives on
 Supermicro BMCs that expose empty `Drives` collections but serve disks at direct `Disk.Bay.N`
+
+---
+
 paths. The function returns `true` for any chassis with an empty `Members` array. On
 Supermicro HGX systems (SYS-A21GE-NBRT and similar) ~35 sub-chassis (GPU, NVSwitch,
 PCIeRetimer, ERoT, IRoT, BMC, FPGA) all carry `ChassisType=Module/Component/Zone` and
@@ -949,3 +952,51 @@ strings forced such systems into fallback mode even when the platform shape was
   grammar rather than by explicit vendor strings.
 - Live collection gains a small amount of extra discovery I/O to harvest stable member IDs, but
   avoids slow deep probes such as `Assembly` just for profile selection.
+
+---
+
+## ADL-037 — easy-bee archives are parsed from the embedded bee-audit snapshot
+
+**Date:** 2026-03-25
+**Context:**
+`reanimator-easy-bee` support bundles already contain a normalized hardware snapshot in
+`export/bee-audit.json` plus supporting logs and techdump files. Rebuilding the same inventory
+from raw `techdump/` files inside LOGPile would duplicate parser logic and create drift between
+the producer utility and archive importer.
+
+**Decision:**
+- Add a dedicated `easy_bee` vendor parser for `bee-support-*.tar.gz` bundles.
+- Detect the bundle by `manifest.txt` (`bee_version=...`) plus `export/bee-audit.json`.
+- Parse the archive from the embedded snapshot first; treat `techdump/` and runtime files as
+  secondary context only.
+- Normalize snapshot-only fields needed by LOGPile, notably:
+  - flatten `hardware.sensors` groups into `[]SensorReading`
+  - turn runtime issues/status into `[]Event`
+  - synthesize a board FRU entry when the snapshot does not include FRU data
+
+**Consequences:**
+- LOGPile stays aligned with the schema emitted by `reanimator-easy-bee`.
+- Adding support required only a thin archive adapter instead of a full hardware parser.
+- If the upstream utility changes the embedded snapshot schema, the `easy_bee` adapter is the
+  only place that must be updated.
+
+---
+
+## ADL-038 — HPE AHS parser uses hybrid extraction instead of full `zbb` schema decoding
+
+**Date:** 2026-03-30
+**Context:** HPE iLO Active Health System exports (`.ahs`) are proprietary `ABJR` containers
+with gzip-compressed `zbb` payloads. The sample inventory data contains two practical signal
+families: printable SMBIOS/FRU-style strings and embedded Redfish JSON subtrees, especially for
+storage controllers and drives. Full `zbb` binary schema decoding is not documented and would add
+significant complexity before proving user value.
+**Decision:** Support HPE AHS with a hybrid parser:
+- decode the outer `ABJR` container
+- gunzip embedded members when applicable
+- extract inventory from printable SMBIOS/FRU payloads
+- extract storage/controller details from embedded Redfish JSON objects
+- do not attempt complete semantic decoding of the internal `zbb` record format
+**Consequences:**
+- Parser reaches inventory-grade usefulness quickly for HPE `.ahs` uploads.
+- Storage inventory is stronger than text-only parsing because it reuses structured Redfish data when present.
+- Future deeper `zbb` decoding can be added incrementally without replacing the current parser contract.

internal/collector/redfish.go

@@ -110,7 +110,7 @@ func (c *RedfishConnector) Probe(ctx context.Context, req Request) (*ProbeResult
 	if err != nil {
 		return nil, fmt.Errorf("redfish system: %w", err)
 	}
-	powerState := strings.TrimSpace(asString(systemDoc["PowerState"]))
+	powerState := redfishSystemPowerState(systemDoc)
 	return &ProbeResult{
 		Reachable:             true,
 		Protocol:              "redfish",
@@ -494,7 +494,7 @@ func (c *RedfishConnector) ensureHostPowerForCollection(ctx context.Context, cli
 		return false, false
 	}
 
-	powerState := strings.TrimSpace(asString(systemDoc["PowerState"]))
+	powerState := redfishSystemPowerState(systemDoc)
 	if isRedfishHostPoweredOn(powerState) {
 		if emit != nil {
 			emit(Progress{Status: "running", Progress: 18, Message: fmt.Sprintf("Redfish: host включен (%s)", firstNonEmpty(powerState, "On"))})
@@ -753,7 +753,7 @@ func (c *RedfishConnector) waitForHostPowerState(ctx context.Context, client *ht
 	for {
 		systemDoc, err := c.getJSON(ctx, client, req, baseURL, systemPath)
 		if err == nil {
-			if isRedfishHostPoweredOn(strings.TrimSpace(asString(systemDoc["PowerState"]))) == wantOn {
+			if isRedfishHostPoweredOn(redfishSystemPowerState(systemDoc)) == wantOn {
 				return true
 			}
 		}
@@ -786,6 +786,19 @@ func isRedfishHostPoweredOn(state string) bool {
 	}
 }
 
+func redfishSystemPowerState(systemDoc map[string]interface{}) string {
+	if len(systemDoc) == 0 {
+		return ""
+	}
+	if state := strings.TrimSpace(asString(systemDoc["PowerState"])); state != "" {
+		return state
+	}
+	if summary, ok := systemDoc["PowerSummary"].(map[string]interface{}); ok {
+		return strings.TrimSpace(asString(summary["PowerState"]))
+	}
+	return ""
+}
+
 func redfishResetActionTarget(systemDoc map[string]interface{}) string {
 	if systemDoc == nil {
 		return ""
@@ -1593,6 +1606,7 @@ func (c *RedfishConnector) collectRawRedfishTree(ctx context.Context, client *ht
 	crawlStart := time.Now()
 	memoryClient := c.httpClientWithTimeout(req, redfishSnapshotMemoryRequestTimeout())
 	memoryGate := make(chan struct{}, redfishSnapshotMemoryConcurrency())
+	postProbeClient := c.httpClientWithTimeout(req, redfishSnapshotPostProbeRequestTimeout())
 	branchLimiter := newRedfishSnapshotBranchLimiter(redfishSnapshotBranchConcurrency())
 	branchRetryPause := redfishSnapshotBranchRequeueBackoff()
 	timings := newRedfishPathTimingCollector(4)
@@ -1895,7 +1909,7 @@ func (c *RedfishConnector) collectRawRedfishTree(ctx context.Context, client *ht
 				ETASeconds:   int(estimateProgressETA(postProbeStart, i, len(postProbeCollections), 3*time.Second).Seconds()),
 			})
 		}
-		for childPath, doc := range c.probeDirectRedfishCollectionChildren(ctx, client, req, baseURL, path) {
+		for childPath, doc := range c.probeDirectRedfishCollectionChildren(ctx, postProbeClient, req, baseURL, path) {
 			if _, exists := out[childPath]; exists {
 				continue
 			}
@@ -2145,6 +2159,12 @@ func shouldAdaptivePostProbeCollectionPath(path string, collectionDoc map[string
 	if len(memberRefs) == 0 {
 		return true
 	}
+	// If the collection reports an explicit non-zero member count that already
+	// matches the number of discovered member refs, every member is accounted
+	// for and numeric probing cannot find anything new.
+	if odataCount := asInt(collectionDoc["Members@odata.count"]); odataCount > 0 && odataCount == len(memberRefs) {
+		return false
+	}
 	return redfishCollectionHasNumericMemberRefs(memberRefs)
 }
 
@@ -2337,6 +2357,18 @@ func redfishSnapshotRequestTimeout() time.Duration {
 	return 12 * time.Second
 }
 
+func redfishSnapshotPostProbeRequestTimeout() time.Duration {
+	if v := strings.TrimSpace(os.Getenv("LOGPILE_REDFISH_POSTPROBE_TIMEOUT")); v != "" {
+		if d, err := time.ParseDuration(v); err == nil && d > 0 {
+			return d
+		}
+	}
+	// Post-probe probes non-existent numeric paths expecting fast 404s.
+	// A short timeout prevents BMCs that hang on unknown paths from stalling
+	// the entire collection for minutes (e.g. HPE iLO on NetworkAdapters Ports).
+	return 4 * time.Second
+}
+
 func redfishSnapshotWorkers(tuning redfishprofile.AcquisitionTuning) int {
 	if tuning.SnapshotWorkers >= 1 && tuning.SnapshotWorkers <= 16 {
 		return tuning.SnapshotWorkers
@@ -2839,6 +2871,8 @@ func shouldCrawlPath(path string) bool {
 		"/GetServerAllUSBStatus",
 		"/Oem/Public/KVM",
 		"/SecureBoot/SecureBootDatabases",
+		// HPE iLO WorkloadPerformanceAdvisor — operational/advisory data, not inventory.
+		"/WorkloadPerformanceAdvisor",
 	} {
 		if strings.Contains(normalized, part) {
 			return false
@@ -5034,6 +5068,16 @@ func isVirtualStorageDrive(doc map[string]interface{}) bool {
 	return false
 }
 
+// isAbsentDriveDoc returns true when the drive document represents an empty bay
+// with no installed media (Status.State == "Absent"). These should be excluded
+// from the storage inventory.
+func isAbsentDriveDoc(doc map[string]interface{}) bool {
+	if status, ok := doc["Status"].(map[string]interface{}); ok {
+		return strings.EqualFold(asString(status["State"]), "Absent")
+	}
+	return strings.EqualFold(asString(doc["Status"]), "Absent")
+}
+
 func looksLikeDrive(doc map[string]interface{}) bool {
 	if asString(doc["MediaType"]) != "" {
 		return true

internal/collector/redfish_replay.go

@@ -96,17 +96,24 @@ func ReplayRedfishFromRawPayloads(rawPayloads map[string]any, emit ProgressFn) (
 	networkProtocolDoc, _ := r.getJSON(joinPath(primaryManager, "/NetworkProtocol"))
 	firmware := parseFirmware(systemDoc, biosDoc, managerDoc, networkProtocolDoc)
 	firmware = dedupeFirmwareInfo(append(firmware, r.collectFirmwareInventory()...))
-	boardInfo.BMCMACAddress = r.collectBMCMAC(managerPaths)
+	firmware = filterStorageDriveFirmware(firmware, storageDevices)
+	bmcManagementSummary := r.collectBMCManagementSummary(managerPaths)
+	boardInfo.BMCMACAddress = strings.TrimSpace(firstNonEmpty(
+		asString(bmcManagementSummary["mac_address"]),
+		r.collectBMCMAC(managerPaths),
+	))
 	assemblyFRU := r.collectAssemblyFRU(chassisPaths)
 	collectedAt, sourceTimezone := inferRedfishCollectionTime(managerDoc, rawPayloads)
 	inventoryLastModifiedAt := inferInventoryLastModifiedTime(r.tree)
 	logEntryEvents := parseRedfishLogEntries(rawPayloads, collectedAt)
+	sensorHintSummary, sensorHintEvents := r.collectSensorsListHints(chassisPaths, collectedAt)
+	bmcManagementEvent := buildBMCManagementSummaryEvent(bmcManagementSummary, collectedAt)
 
 	result := &models.AnalysisResult{
 		CollectedAt:             collectedAt,
 		InventoryLastModifiedAt: inventoryLastModifiedAt,
 		SourceTimezone:          sourceTimezone,
-		Events:                  append(append(append(append(make([]models.Event, 0, len(discreteEvents)+len(healthEvents)+len(driveFetchWarningEvents)+len(logEntryEvents)+1), healthEvents...), discreteEvents...), driveFetchWarningEvents...), logEntryEvents...),
+		Events:                  append(append(append(append(append(append(make([]models.Event, 0, len(discreteEvents)+len(healthEvents)+len(driveFetchWarningEvents)+len(logEntryEvents)+len(sensorHintEvents)+2), healthEvents...), discreteEvents...), driveFetchWarningEvents...), logEntryEvents...), sensorHintEvents...), bmcManagementEvent...),
 		FRU:                     assemblyFRU,
 		Sensors:                 dedupeSensorReadings(append(append(thresholdSensors, thermalSensors...), powerSensors...)),
 		RawPayloads:             cloneRawPayloads(rawPayloads),
@@ -155,6 +162,12 @@ func ReplayRedfishFromRawPayloads(rawPayloads map[string]any, emit ProgressFn) (
 	if strings.TrimSpace(sourceTimezone) != "" {
 		result.RawPayloads["source_timezone"] = sourceTimezone
 	}
+	if len(sensorHintSummary) > 0 {
+		result.RawPayloads["redfish_sensor_hints"] = sensorHintSummary
+	}
+	if len(bmcManagementSummary) > 0 {
+		result.RawPayloads["redfish_bmc_network_summary"] = bmcManagementSummary
+	}
 	appendMissingServerModelWarning(result, systemDoc, joinPath(primarySystem, "/Oem/Public/FRU"), joinPath(primaryChassis, "/Oem/Public/FRU"))
 	return result, nil
 }
@@ -324,6 +337,153 @@ func buildDriveFetchWarningEvents(rawPayloads map[string]any) []models.Event {
 	}
 }
 
+func (r redfishSnapshotReader) collectSensorsListHints(chassisPaths []string, collectedAt time.Time) (map[string]any, []models.Event) {
+	summary := make(map[string]any)
+	var events []models.Event
+	var presentDIMMs []string
+	dimmTotal := 0
+	dimmPresent := 0
+	physicalDriveSlots := 0
+	activePhysicalDriveSlots := 0
+	logicalDriveStatus := ""
+
+	for _, chassisPath := range chassisPaths {
+		doc, err := r.getJSON(joinPath(chassisPath, "/SensorsList"))
+		if err != nil || len(doc) == 0 {
+			continue
+		}
+		sensors, ok := doc["SensorsList"].([]interface{})
+		if !ok {
+			continue
+		}
+		for _, item := range sensors {
+			sensor, ok := item.(map[string]interface{})
+			if !ok {
+				continue
+			}
+			name := strings.TrimSpace(asString(sensor["SensorName"]))
+			sensorType := strings.TrimSpace(asString(sensor["SensorType"]))
+			status := strings.TrimSpace(asString(sensor["Status"]))
+			switch {
+			case strings.HasPrefix(name, "DIMM") && strings.HasSuffix(name, "_Status") && strings.EqualFold(sensorType, "Memory"):
+				dimmTotal++
+				if redfishSlotStatusLooksPresent(status) {
+					dimmPresent++
+					presentDIMMs = append(presentDIMMs, strings.TrimSuffix(name, "_Status"))
+				}
+			case strings.EqualFold(sensorType, "Drive Slot"):
+				if strings.EqualFold(name, "Logical_Drive") {
+					logicalDriveStatus = firstNonEmpty(logicalDriveStatus, status)
+					continue
+				}
+				physicalDriveSlots++
+				if redfishSlotStatusLooksPresent(status) {
+					activePhysicalDriveSlots++
+				}
+			}
+		}
+	}
+
+	if dimmTotal > 0 {
+		sort.Strings(presentDIMMs)
+		summary["memory_slots"] = map[string]any{
+			"total":         dimmTotal,
+			"present_count": dimmPresent,
+			"present_slots": presentDIMMs,
+			"source":        "SensorsList",
+		}
+		events = append(events, models.Event{
+			Timestamp:   replayEventTimestamp(collectedAt),
+			Source:      "Redfish",
+			EventType:   "Collection Info",
+			Severity:    models.SeverityInfo,
+			Description: fmt.Sprintf("Memory slot sensors report %d populated positions out of %d", dimmPresent, dimmTotal),
+			RawData:     firstNonEmpty(strings.Join(presentDIMMs, ", "), "no populated DIMM slots reported"),
+		})
+	}
+	if physicalDriveSlots > 0 || logicalDriveStatus != "" {
+		summary["drive_slots"] = map[string]any{
+			"physical_total":        physicalDriveSlots,
+			"physical_active_count": activePhysicalDriveSlots,
+			"logical_drive_status":  logicalDriveStatus,
+			"source":                "SensorsList",
+		}
+		rawParts := []string{
+			fmt.Sprintf("physical_active=%d/%d", activePhysicalDriveSlots, physicalDriveSlots),
+		}
+		if logicalDriveStatus != "" {
+			rawParts = append(rawParts, "logical_drive="+logicalDriveStatus)
+		}
+		events = append(events, models.Event{
+			Timestamp:   replayEventTimestamp(collectedAt),
+			Source:      "Redfish",
+			EventType:   "Collection Info",
+			Severity:    models.SeverityInfo,
+			Description: fmt.Sprintf("Drive slot sensors report %d active physical slots out of %d", activePhysicalDriveSlots, physicalDriveSlots),
+			RawData:     strings.Join(rawParts, "; "),
+		})
+	}
+
+	return summary, events
+}
+
+func buildBMCManagementSummaryEvent(summary map[string]any, collectedAt time.Time) []models.Event {
+	if len(summary) == 0 {
+		return nil
+	}
+	desc := fmt.Sprintf(
+		"BMC management interface %s link=%s ip=%s",
+		firstNonEmpty(asString(summary["interface_id"]), "unknown"),
+		firstNonEmpty(asString(summary["link_status"]), "unknown"),
+		firstNonEmpty(asString(summary["ipv4_address"]), "n/a"),
+	)
+	rawParts := make([]string, 0, 8)
+	for _, part := range []string{
+		"mac_address=" + strings.TrimSpace(asString(summary["mac_address"])),
+		"speed_mbps=" + strings.TrimSpace(asString(summary["speed_mbps"])),
+		"lldp_chassis_name=" + strings.TrimSpace(asString(summary["lldp_chassis_name"])),
+		"lldp_port_desc=" + strings.TrimSpace(asString(summary["lldp_port_desc"])),
+		"lldp_port_id=" + strings.TrimSpace(asString(summary["lldp_port_id"])),
+		"ipv4_gateway=" + strings.TrimSpace(asString(summary["ipv4_gateway"])),
+	} {
+		if !strings.HasSuffix(part, "=") {
+			rawParts = append(rawParts, part)
+		}
+	}
+	if vlan := asInt(summary["lldp_vlan_id"]); vlan > 0 {
+		rawParts = append(rawParts, fmt.Sprintf("lldp_vlan_id=%d", vlan))
+	}
+	if asBool(summary["ncsi_enabled"]) {
+		rawParts = append(rawParts, "ncsi_enabled=true")
+	}
+	return []models.Event{
+		{
+			Timestamp:   replayEventTimestamp(collectedAt),
+			Source:      "Redfish",
+			EventType:   "Collection Info",
+			Severity:    models.SeverityInfo,
+			Description: desc,
+			RawData:     strings.Join(rawParts, "; "),
+		},
+	}
+}
+
+func redfishSlotStatusLooksPresent(status string) bool {
+	switch strings.ToLower(strings.TrimSpace(status)) {
+	case "ok", "enabled", "present", "warning", "critical":
+		return true
+	default:
+		return false
+	}
+}
+
+func replayEventTimestamp(collectedAt time.Time) time.Time {
+	if !collectedAt.IsZero() {
+		return collectedAt
+	}
+	return time.Now()
+}
+
 func (r redfishSnapshotReader) collectFirmwareInventory() []models.FirmwareInfo {
 	docs, err := r.getCollectionMembers("/redfish/v1/UpdateService/FirmwareInventory")
 	if err != nil || len(docs) == 0 {
@@ -339,6 +499,10 @@ func (r redfishSnapshotReader) collectFirmwareInventory() []models.FirmwareInfo
 		if strings.TrimSpace(version) == "" {
 			continue
 		}
+		// Skip placeholder version strings that carry no useful information.
+		if strings.EqualFold(strings.TrimSpace(version), "N/A") {
+			continue
+		}
 		name := firmwareInventoryDeviceName(doc)
 		name = strings.TrimSpace(name)
 		if name == "" {
@@ -391,6 +555,32 @@ func dedupeFirmwareInfo(items []models.FirmwareInfo) []models.FirmwareInfo {
 	return out
 }
 
+// filterStorageDriveFirmware removes from fw any entries whose DeviceName+Version
+// already appear as a storage drive's Model+Firmware. Drive firmware is already
+// represented in the Storage section and should not be duplicated in the general
+// firmware list.
+func filterStorageDriveFirmware(fw []models.FirmwareInfo, storage []models.Storage) []models.FirmwareInfo {
+	if len(storage) == 0 {
+		return fw
+	}
+	driveFW := make(map[string]struct{}, len(storage))
+	for _, d := range storage {
+		model := strings.ToLower(strings.TrimSpace(d.Model))
+		rev := strings.ToLower(strings.TrimSpace(d.Firmware))
+		if model != "" && rev != "" {
+			driveFW[model+"|"+rev] = struct{}{}
+		}
+	}
+	out := fw[:0:0]
+	for _, f := range fw {
+		key := strings.ToLower(strings.TrimSpace(f.DeviceName)) + "|" + strings.ToLower(strings.TrimSpace(f.Version))
+		if _, skip := driveFW[key]; !skip {
+			out = append(out, f)
+		}
+	}
+	return out
+}
+
 func (r redfishSnapshotReader) collectThresholdSensors(chassisPaths []string) []models.SensorReading {
 	out := make([]models.SensorReading, 0)
 	seen := make(map[string]struct{})
@@ -856,6 +1046,9 @@ func (r redfishSnapshotReader) fallbackCollectionMembers(collectionPath string,
 		if err != nil {
 			continue
 		}
+		if redfishFallbackMemberLooksLikePlaceholder(collectionPath, doc) {
+			continue
+		}
 		if strings.TrimSpace(asString(doc["@odata.id"])) == "" {
 			doc["@odata.id"] = normalizeRedfishPath(p)
 		}
@@ -864,6 +1057,135 @@ func (r redfishSnapshotReader) fallbackCollectionMembers(collectionPath string,
 	return out, nil
 }
 
+func redfishFallbackMemberLooksLikePlaceholder(collectionPath string, doc map[string]interface{}) bool {
+	if len(doc) == 0 {
+		return true
+	}
+	path := normalizeRedfishPath(collectionPath)
+	switch {
+	case strings.HasSuffix(path, "/NetworkAdapters"):
+		return redfishNetworkAdapterPlaceholderDoc(doc)
+	case strings.HasSuffix(path, "/PCIeDevices"):
+		return redfishPCIePlaceholderDoc(doc)
+	case strings.Contains(path, "/Storage"):
+		return redfishStoragePlaceholderDoc(doc)
+	default:
+		return false
+	}
+}
+
+func redfishNetworkAdapterPlaceholderDoc(doc map[string]interface{}) bool {
+	if normalizeRedfishIdentityField(asString(doc["Model"])) != "" ||
+		normalizeRedfishIdentityField(asString(doc["Manufacturer"])) != "" ||
+		normalizeRedfishIdentityField(asString(doc["SerialNumber"])) != "" ||
+		normalizeRedfishIdentityField(asString(doc["PartNumber"])) != "" ||
+		normalizeRedfishIdentityField(asString(doc["BDF"])) != "" ||
+		asHexOrInt(doc["VendorId"]) != 0 ||
+		asHexOrInt(doc["DeviceId"]) != 0 {
+		return false
+	}
+	return redfishDocHasOnlyAllowedKeys(doc,
+		"@odata.context",
+		"@odata.id",
+		"@odata.type",
+		"Id",
+		"Name",
+	)
+}
+
+func redfishPCIePlaceholderDoc(doc map[string]interface{}) bool {
+	if normalizeRedfishIdentityField(asString(doc["Model"])) != "" ||
+		normalizeRedfishIdentityField(asString(doc["Manufacturer"])) != "" ||
+		normalizeRedfishIdentityField(asString(doc["SerialNumber"])) != "" ||
+		normalizeRedfishIdentityField(asString(doc["PartNumber"])) != "" ||
+		normalizeRedfishIdentityField(asString(doc["BDF"])) != "" ||
+		asHexOrInt(doc["VendorId"]) != 0 ||
+		asHexOrInt(doc["DeviceId"]) != 0 {
+		return false
+	}
+	return redfishDocHasOnlyAllowedKeys(doc,
+		"@odata.context",
+		"@odata.id",
+		"@odata.type",
+		"Id",
+		"Name",
+	)
+}
+
+func redfishStoragePlaceholderDoc(doc map[string]interface{}) bool {
+	if normalizeRedfishIdentityField(asString(doc["Model"])) != "" ||
+		normalizeRedfishIdentityField(asString(doc["Manufacturer"])) != "" ||
+		normalizeRedfishIdentityField(asString(doc["SerialNumber"])) != "" ||
+		normalizeRedfishIdentityField(asString(doc["PartNumber"])) != "" ||
+		normalizeRedfishIdentityField(asString(doc["BDF"])) != "" ||
+		asHexOrInt(doc["VendorId"]) != 0 ||
+		asHexOrInt(doc["DeviceId"]) != 0 {
+		return false
+	}
+	if !redfishDocHasOnlyAllowedKeys(doc,
+		"@odata.id",
+		"@odata.type",
+		"Drives",
+		"Drives@odata.count",
+		"LogicalDisk",
+		"PhysicalDisk",
+		"Name",
+	) {
+		return false
+	}
+	return redfishFieldIsEmptyCollection(doc["Drives"]) &&
+		redfishFieldIsZeroLike(doc["Drives@odata.count"]) &&
+		redfishFieldIsEmptyCollection(doc["LogicalDisk"]) &&
+		redfishFieldIsEmptyCollection(doc["PhysicalDisk"])
+}
+
+func redfishDocHasOnlyAllowedKeys(doc map[string]interface{}, allowed ...string) bool {
+	if len(doc) == 0 {
+		return false
+	}
+	allowedSet := make(map[string]struct{}, len(allowed))
+	for _, key := range allowed {
+		allowedSet[key] = struct{}{}
+	}
+	for key := range doc {
+		if _, ok := allowedSet[key]; !ok {
+			return false
+		}
+	}
+	return true
+}
+
+func redfishFieldIsEmptyCollection(v any) bool {
+	switch x := v.(type) {
+	case nil:
+		return true
+	case []interface{}:
+		return len(x) == 0
+	default:
+		return false
+	}
+}
+
+func redfishFieldIsZeroLike(v any) bool {
+	switch x := v.(type) {
+	case nil:
+		return true
+	case int:
+		return x == 0
+	case int32:
+		return x == 0
+	case int64:
+		return x == 0
+	case float64:
+		return x == 0
+	case string:
+		x = strings.TrimSpace(x)
+		return x == "" || x == "0"
+	default:
+		return false
+	}
+}
+
 func cloneRawPayloads(src map[string]any) map[string]any {
 	if len(src) == 0 {
 		return nil
@@ -970,6 +1292,12 @@ func (r redfishSnapshotReader) collectProcessors(systemPath string) []models.CPU
 			!strings.EqualFold(pt, "CPU") && !strings.EqualFold(pt, "General") {
 			continue
 		}
+		// Skip absent processor sockets — empty slots with no CPU installed.
+		if status, ok := doc["Status"].(map[string]interface{}); ok {
+			if strings.EqualFold(asString(status["State"]), "Absent") {
+				continue
+			}
+		}
 		cpu := parseCPUs([]map[string]interface{}{doc})[0]
 		if cpu.Socket == 0 && socketIdx > 0 && strings.TrimSpace(asString(doc["Socket"])) == "" {
 			cpu.Socket = socketIdx
@@ -996,6 +1324,10 @@ func (r redfishSnapshotReader) collectMemory(systemPath string) []models.MemoryD
 	out := make([]models.MemoryDIMM, 0, len(memberDocs))
 	for _, doc := range memberDocs {
 		dimm := parseMemory([]map[string]interface{}{doc})[0]
+		// Skip empty DIMM slots — no installed memory.
+		if !dimm.Present {
+			continue
+		}
 		supplementalDocs := r.getLinkedSupplementalDocs(doc, "MemoryMetrics", "EnvironmentMetrics", "Metrics")
 		if len(supplementalDocs) > 0 {
 			dimm.Details = mergeGenericDetails(dimm.Details, redfishMemoryDetailsAcrossDocs(doc, supplementalDocs...))

internal/collector/redfish_replay_inventory.go

@@ -165,12 +165,25 @@ func (r redfishSnapshotReader) getChassisScopedPCIeSupplementalDocs(doc map[stri
 	return out
 }
 
-// collectBMCMAC returns the MAC address of the first active BMC management
-// interface found in Managers/*/EthernetInterfaces. Returns empty string if
-// no MAC is available.
+// collectBMCMAC returns the MAC address of the best BMC management interface
+// found in Managers/*/EthernetInterfaces. Prefer an active link with an IP
+// address over a passive sideband interface.
 func (r redfishSnapshotReader) collectBMCMAC(managerPaths []string) string {
+	summary := r.collectBMCManagementSummary(managerPaths)
+	if len(summary) == 0 {
+		return ""
+	}
+	return strings.ToUpper(strings.TrimSpace(asString(summary["mac_address"])))
+}
+
+func (r redfishSnapshotReader) collectBMCManagementSummary(managerPaths []string) map[string]any {
+	bestScore := -1
+	var best map[string]any
 	for _, managerPath := range managerPaths {
-		members, err := r.getCollectionMembers(joinPath(managerPath, "/EthernetInterfaces"))
+		collectionPath := joinPath(managerPath, "/EthernetInterfaces")
+		collectionDoc, _ := r.getJSON(collectionPath)
+		ncsiEnabled, lldpMode, lldpByEth := redfishManagerEthernetCollectionHints(collectionDoc)
+		members, err := r.getCollectionMembers(collectionPath)
 		if err != nil || len(members) == 0 {
 			continue
 		}
@@ -182,12 +195,141 @@ func (r redfishSnapshotReader) collectBMCMAC(managerPaths []string) string {
 			if mac == "" || strings.EqualFold(mac, "00:00:00:00:00:00") {
 				continue
 			}
-			return strings.ToUpper(mac)
+			ifaceID := strings.TrimSpace(firstNonEmpty(asString(doc["Id"]), asString(doc["Name"])))
+			summary := map[string]any{
+				"manager_path":    managerPath,
+				"interface_id":    ifaceID,
+				"hostname":        strings.TrimSpace(asString(doc["HostName"])),
+				"fqdn":            strings.TrimSpace(asString(doc["FQDN"])),
+				"mac_address":     strings.ToUpper(mac),
+				"link_status":     strings.TrimSpace(asString(doc["LinkStatus"])),
+				"speed_mbps":      asInt(doc["SpeedMbps"]),
+				"interface_name":  strings.TrimSpace(asString(doc["Name"])),
+				"interface_desc":  strings.TrimSpace(asString(doc["Description"])),
+				"ncsi_enabled":    ncsiEnabled,
+				"lldp_mode":       lldpMode,
+				"ipv4_address":    redfishManagerIPv4Field(doc, "Address"),
+				"ipv4_gateway":    redfishManagerIPv4Field(doc, "Gateway"),
+				"ipv4_subnet":     redfishManagerIPv4Field(doc, "SubnetMask"),
+				"ipv6_address":    redfishManagerIPv6Field(doc, "Address"),
+				"link_is_active":  strings.EqualFold(strings.TrimSpace(asString(doc["LinkStatus"])), "LinkActive"),
+				"interface_score": 0,
+			}
+			if lldp, ok := lldpByEth[strings.ToLower(ifaceID)]; ok {
+				summary["lldp_chassis_name"] = lldp["ChassisName"]
+				summary["lldp_port_desc"] = lldp["PortDesc"]
+				summary["lldp_port_id"] = lldp["PortId"]
+				if vlan := asInt(lldp["VlanId"]); vlan > 0 {
+					summary["lldp_vlan_id"] = vlan
+				}
+			}
+			score := redfishManagerInterfaceScore(summary)
+			summary["interface_score"] = score
+			if score > bestScore {
+				bestScore = score
+				best = summary
+			}
+		}
+	}
+	return best
+}
+
+func redfishManagerEthernetCollectionHints(collectionDoc map[string]interface{}) (bool, string, map[string]map[string]interface{}) {
+	lldpByEth := make(map[string]map[string]interface{})
+	if len(collectionDoc) == 0 {
+		return false, "", lldpByEth
+	}
+	oem, _ := collectionDoc["Oem"].(map[string]interface{})
+	public, _ := oem["Public"].(map[string]interface{})
+	ncsiEnabled := asBool(public["NcsiEnabled"])
+	lldp, _ := public["LLDP"].(map[string]interface{})
+	lldpMode := strings.TrimSpace(asString(lldp["LLDPMode"]))
+	if members, ok := lldp["Members"].([]interface{}); ok {
+		for _, item := range members {
+			member, ok := item.(map[string]interface{})
+			if !ok {
+				continue
+			}
+			ethIndex := strings.ToLower(strings.TrimSpace(asString(member["EthIndex"])))
+			if ethIndex == "" {
+				continue
+			}
+			lldpByEth[ethIndex] = member
+		}
+	}
+	return ncsiEnabled, lldpMode, lldpByEth
+}
+
+func redfishManagerIPv4Field(doc map[string]interface{}, key string) string {
+	if len(doc) == 0 {
+		return ""
+	}
+	for _, field := range []string{"IPv4Addresses", "IPv4StaticAddresses"} {
+		list, ok := doc[field].([]interface{})
+		if !ok {
+			continue
+		}
+		for _, item := range list {
+			entry, ok := item.(map[string]interface{})
+			if !ok {
+				continue
+			}
+			value := strings.TrimSpace(asString(entry[key]))
+			if value != "" {
+				return value
+			}
 		}
 	}
 	return ""
 }
 
+func redfishManagerIPv6Field(doc map[string]interface{}, key string) string {
+	if len(doc) == 0 {
+		return ""
+	}
+	list, ok := doc["IPv6Addresses"].([]interface{})
+	if !ok {
+		return ""
+	}
+	for _, item := range list {
+		entry, ok := item.(map[string]interface{})
+		if !ok {
+			continue
+		}
+		value := strings.TrimSpace(asString(entry[key]))
+		if value != "" {
+			return value
+		}
+	}
+	return ""
+}
+
+func redfishManagerInterfaceScore(summary map[string]any) int {
+	score := 0
+	if strings.EqualFold(strings.TrimSpace(asString(summary["link_status"])), "LinkActive") {
+		score += 100
+	}
+	if strings.TrimSpace(asString(summary["ipv4_address"])) != "" {
+		score += 40
+	}
+	if strings.TrimSpace(asString(summary["ipv6_address"])) != "" {
+		score += 10
+	}
+	if strings.TrimSpace(asString(summary["mac_address"])) != "" {
+		score += 10
+	}
+	if asInt(summary["speed_mbps"]) > 0 {
+		score += 5
+	}
+	if ifaceID := strings.ToLower(strings.TrimSpace(asString(summary["interface_id"]))); ifaceID != "" && !strings.HasPrefix(ifaceID, "usb") {
+		score += 3
+	}
+	if asBool(summary["ncsi_enabled"]) {
+		score += 1
+	}
+	return score
+}
+
 // findNICIndexByLinkedNetworkAdapter resolves a NetworkInterface document to an
 // existing NIC in bySlot by following Links.NetworkAdapter → the Chassis
 // NetworkAdapter doc → its slot label. Returns -1 if no match is found.

internal/collector/redfish_replay_storage.go

@@ -14,13 +14,16 @@ func (r redfishSnapshotReader) collectStorage(systemPath string, plan redfishpro
 				driveDocs, err := r.getCollectionMembers(driveCollectionPath)
 				if err == nil {
 					for _, driveDoc := range driveDocs {
-						if !isVirtualStorageDrive(driveDoc) {
+						if !isAbsentDriveDoc(driveDoc) && !isVirtualStorageDrive(driveDoc) {
 							supplementalDocs := r.getLinkedSupplementalDocs(driveDoc, "DriveMetrics", "EnvironmentMetrics", "Metrics")
 							out = append(out, parseDriveWithSupplementalDocs(driveDoc, supplementalDocs...))
 						}
 					}
 					if len(driveDocs) == 0 {
 						for _, driveDoc := range r.probeDirectDiskBayChildren(driveCollectionPath) {
+							if isAbsentDriveDoc(driveDoc) {
+								continue
+							}
 							supplementalDocs := r.getLinkedSupplementalDocs(driveDoc, "DriveMetrics", "EnvironmentMetrics", "Metrics")
 							out = append(out, parseDriveWithSupplementalDocs(driveDoc, supplementalDocs...))
 						}
@@ -43,7 +46,7 @@ func (r redfishSnapshotReader) collectStorage(systemPath string, plan redfishpro
 				if err != nil {
 					continue
 				}
-				if !isVirtualStorageDrive(driveDoc) {
+				if !isAbsentDriveDoc(driveDoc) && !isVirtualStorageDrive(driveDoc) {
 					supplementalDocs := r.getLinkedSupplementalDocs(driveDoc, "DriveMetrics", "EnvironmentMetrics", "Metrics")
 					out = append(out, parseDriveWithSupplementalDocs(driveDoc, supplementalDocs...))
 				}
@@ -51,7 +54,7 @@ func (r redfishSnapshotReader) collectStorage(systemPath string, plan redfishpro
 			continue
 		}
 		if looksLikeDrive(member) {
-			if isVirtualStorageDrive(member) {
+			if isAbsentDriveDoc(member) || isVirtualStorageDrive(member) {
 				continue
 			}
 			supplementalDocs := r.getLinkedSupplementalDocs(member, "DriveMetrics", "EnvironmentMetrics", "Metrics")
@@ -63,14 +66,14 @@ func (r redfishSnapshotReader) collectStorage(systemPath string, plan redfishpro
 				driveDocs, err := r.getCollectionMembers(joinPath(enclosurePath, "/Drives"))
 				if err == nil {
 					for _, driveDoc := range driveDocs {
-						if looksLikeDrive(driveDoc) && !isVirtualStorageDrive(driveDoc) {
+						if looksLikeDrive(driveDoc) && !isAbsentDriveDoc(driveDoc) && !isVirtualStorageDrive(driveDoc) {
 							supplementalDocs := r.getLinkedSupplementalDocs(driveDoc, "DriveMetrics", "EnvironmentMetrics", "Metrics")
 							out = append(out, parseDriveWithSupplementalDocs(driveDoc, supplementalDocs...))
 						}
 					}
 					if len(driveDocs) == 0 {
 						for _, driveDoc := range r.probeDirectDiskBayChildren(joinPath(enclosurePath, "/Drives")) {
-							if isVirtualStorageDrive(driveDoc) {
+							if isAbsentDriveDoc(driveDoc) || isVirtualStorageDrive(driveDoc) {
 								continue
 							}
 							out = append(out, parseDrive(driveDoc))
@@ -83,7 +86,7 @@ func (r redfishSnapshotReader) collectStorage(systemPath string, plan redfishpro
 
 	if len(plan.KnownStorageDriveCollections) > 0 {
 		for _, driveDoc := range r.collectKnownStorageMembers(systemPath, plan.KnownStorageDriveCollections) {
-			if looksLikeDrive(driveDoc) && !isVirtualStorageDrive(driveDoc) {
+			if looksLikeDrive(driveDoc) && !isAbsentDriveDoc(driveDoc) && !isVirtualStorageDrive(driveDoc) {
 				supplementalDocs := r.getLinkedSupplementalDocs(driveDoc, "DriveMetrics", "EnvironmentMetrics", "Metrics")
 				out = append(out, parseDriveWithSupplementalDocs(driveDoc, supplementalDocs...))
 			}
@@ -98,7 +101,7 @@ func (r redfishSnapshotReader) collectStorage(systemPath string, plan redfishpro
 		}
 		for _, devAny := range devices {
 			devDoc, ok := devAny.(map[string]interface{})
-			if !ok || !looksLikeDrive(devDoc) || isVirtualStorageDrive(devDoc) {
+			if !ok || !looksLikeDrive(devDoc) || isAbsentDriveDoc(devDoc) || isVirtualStorageDrive(devDoc) {
 				continue
 			}
 			out = append(out, parseDrive(devDoc))
@@ -112,7 +115,7 @@ func (r redfishSnapshotReader) collectStorage(systemPath string, plan redfishpro
 			continue
 		}
 		for _, driveDoc := range driveDocs {
-			if !looksLikeDrive(driveDoc) || isVirtualStorageDrive(driveDoc) {
+			if !looksLikeDrive(driveDoc) || isAbsentDriveDoc(driveDoc) || isVirtualStorageDrive(driveDoc) {
 				continue
 			}
 			out = append(out, parseDrive(driveDoc))
@@ -124,7 +127,7 @@ func (r redfishSnapshotReader) collectStorage(systemPath string, plan redfishpro
 				continue
 			}
 			for _, driveDoc := range r.probeSupermicroNVMeDiskBays(chassisPath) {
-				if !looksLikeDrive(driveDoc) || isVirtualStorageDrive(driveDoc) {
+				if !looksLikeDrive(driveDoc) || isAbsentDriveDoc(driveDoc) || isVirtualStorageDrive(driveDoc) {
 					continue
 				}
 				out = append(out, parseDrive(driveDoc))

internal/collector/redfish_test.go

@@ -270,6 +270,71 @@ func TestRedfishConnectorProbe(t *testing.T) {
 	}
 }
 
+func TestRedfishConnectorProbe_FallsBackToPowerSummary(t *testing.T) {
+	mux := http.NewServeMux()
+	register := func(path string, payload interface{}) {
+		mux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			_ = json.NewEncoder(w).Encode(payload)
+		})
+	}
+
+	register("/redfish/v1", map[string]interface{}{"Name": "ServiceRoot"})
+	register("/redfish/v1/Systems", map[string]interface{}{
+		"Members": []interface{}{
+			map[string]interface{}{"@odata.id": "/redfish/v1/Systems/1"},
+		},
+	})
+	register("/redfish/v1/Systems/1", map[string]interface{}{
+		"@odata.id": "/redfish/v1/Systems/1",
+		"PowerSummary": map[string]interface{}{
+			"PowerState": "On",
+		},
+		"Actions": map[string]interface{}{
+			"#ComputerSystem.Reset": map[string]interface{}{
+				"target":                            "/redfish/v1/Systems/1/Actions/ComputerSystem.Reset",
+				"ResetType@Redfish.AllowableValues": []interface{}{"On", "ForceOff"},
+			},
+		},
+	})
+	ts := httptest.NewTLSServer(mux)
+	defer ts.Close()
+
+	connector := NewRedfishConnector()
+	port := 443
+	host := ""
+	if u, err := url.Parse(ts.URL); err == nil {
+		host = u.Hostname()
+		if p := u.Port(); p != "" {
+			fmt.Sscanf(p, "%d", &port)
+		}
+	}
+	got, err := connector.Probe(context.Background(), Request{
+		Host:     host,
+		Protocol: "redfish",
+		Port:     port,
+		Username: "admin",
+		AuthType: "password",
+		Password: "secret",
+		TLSMode:  "insecure",
+	})
+	if err != nil {
+		t.Fatalf("probe failed: %v", err)
+	}
+	if got == nil || !got.Reachable {
+		t.Fatalf("expected reachable probe result, got %+v", got)
+	}
+	if !got.HostPoweredOn {
+		t.Fatalf("expected powered on host from PowerSummary")
+	}
+	if got.HostPowerState != "On" {
+		t.Fatalf("expected power state On, got %q", got.HostPowerState)
+	}
+	if !got.PowerControlAvailable {
+		t.Fatalf("expected power control available")
+	}
+}
+
 func TestEnsureHostPowerForCollection_WaitsForStablePowerOn(t *testing.T) {
 	t.Setenv("LOGPILE_REDFISH_POWERON_STABILIZATION", "1ms")
 	t.Setenv("LOGPILE_REDFISH_BMC_READY_WAITS", "1ms,1ms")
@@ -388,6 +453,104 @@ func TestEnsureHostPowerForCollection_FailsIfHostDoesNotStayOnAfterStabilization
 	}
 }
 
+func TestEnsureHostPowerForCollection_UsesPowerSummaryState(t *testing.T) {
+	t.Setenv("LOGPILE_REDFISH_POWERON_STABILIZATION", "1ms")
+	t.Setenv("LOGPILE_REDFISH_BMC_READY_WAITS", "1ms,1ms")
+
+	powerState := "On"
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/redfish/v1/Systems/1", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(map[string]interface{}{
+			"@odata.id": "/redfish/v1/Systems/1",
+			"PowerSummary": map[string]interface{}{
+				"PowerState": powerState,
+			},
+			"MemorySummary": map[string]interface{}{
+				"TotalSystemMemoryGiB": 128,
+			},
+			"Actions": map[string]interface{}{
+				"#ComputerSystem.Reset": map[string]interface{}{
+					"target":                            "/redfish/v1/Systems/1/Actions/ComputerSystem.Reset",
+					"ResetType@Redfish.AllowableValues": []interface{}{"On"},
+				},
+			},
+		})
+	})
+
+	ts := httptest.NewTLSServer(mux)
+	defer ts.Close()
+
+	u, err := url.Parse(ts.URL)
+	if err != nil {
+		t.Fatalf("parse server url: %v", err)
+	}
+	port := 443
+	if u.Port() != "" {
+		fmt.Sscanf(u.Port(), "%d", &port)
+	}
+
+	c := NewRedfishConnector()
+	hostOn, changed := c.ensureHostPowerForCollection(context.Background(), c.httpClientWithTimeout(Request{TLSMode: "insecure"}, 5*time.Second), Request{
+		Host:             u.Hostname(),
+		Protocol:         "redfish",
+		Port:             port,
+		Username:         "admin",
+		AuthType:         "password",
+		Password:         "secret",
+		TLSMode:          "insecure",
+		PowerOnIfHostOff: true,
+	}, ts.URL, "/redfish/v1/Systems/1", nil)
+	if !hostOn || changed {
+		t.Fatalf("expected already-on host from PowerSummary, got hostOn=%v changed=%v", hostOn, changed)
+	}
+}
+
+func TestWaitForHostPowerState_UsesPowerSummaryState(t *testing.T) {
+	powerState := "Off"
+	mux := http.NewServeMux()
+	mux.HandleFunc("/redfish/v1/Systems/1", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		current := powerState
+		if powerState == "Off" {
+			powerState = "On"
+		}
+		_ = json.NewEncoder(w).Encode(map[string]interface{}{
+			"@odata.id": "/redfish/v1/Systems/1",
+			"PowerSummary": map[string]interface{}{
+				"PowerState": current,
+			},
+		})
+	})
+
+	ts := httptest.NewTLSServer(mux)
+	defer ts.Close()
+
+	u, err := url.Parse(ts.URL)
+	if err != nil {
+		t.Fatalf("parse server url: %v", err)
+	}
+	port := 443
+	if u.Port() != "" {
+		fmt.Sscanf(u.Port(), "%d", &port)
+	}
+
+	c := NewRedfishConnector()
+	ok := c.waitForHostPowerState(context.Background(), c.httpClientWithTimeout(Request{TLSMode: "insecure"}, 5*time.Second), Request{
+		Host:     u.Hostname(),
+		Protocol: "redfish",
+		Port:     port,
+		Username: "admin",
+		AuthType: "password",
+		Password: "secret",
+		TLSMode:  "insecure",
+	}, ts.URL, "/redfish/v1/Systems/1", true, 3*time.Second)
+	if !ok {
+		t.Fatalf("expected waitForHostPowerState to use PowerSummary")
+	}
+}
+
 func TestParsePCIeDeviceSlot_FromNestedRedfishSlotLocation(t *testing.T) {
 	doc := map[string]interface{}{
 		"Id": "NIC1",
@@ -488,6 +651,271 @@ func TestReplayRedfishFromRawPayloads_FallbackCollectionMembersByPrefix(t *testi
 	}
 }
 
+func TestReplayRedfishFromRawPayloads_FallbackCollectionMembersSkipsPlaceholderNumericDocs(t *testing.T) {
+	raw := map[string]any{
+		"redfish_tree": map[string]interface{}{
+			"/redfish/v1": map[string]interface{}{
+				"Systems":  map[string]interface{}{"@odata.id": "/redfish/v1/Systems"},
+				"Chassis":  map[string]interface{}{"@odata.id": "/redfish/v1/Chassis"},
+				"Managers": map[string]interface{}{"@odata.id": "/redfish/v1/Managers"},
+			},
+			"/redfish/v1/Systems": map[string]interface{}{
+				"Members": []interface{}{
+					map[string]interface{}{"@odata.id": "/redfish/v1/Systems/1"},
+				},
+			},
+			"/redfish/v1/Systems/1": map[string]interface{}{
+				"Manufacturer": "Multillect",
+				"Model":        "MLT-S06",
+				"SerialNumber": "430044262001626",
+				"Storage":      map[string]interface{}{"@odata.id": "/redfish/v1/Systems/1/Storage"},
+			},
+			"/redfish/v1/Systems/1/Storage": map[string]interface{}{
+				"@odata.id":           "/redfish/v1/Systems/1/Storage",
+				"Members":             []interface{}{},
+				"Members@odata.count": 0,
+			},
+			"/redfish/v1/Systems/1/Storage/1": map[string]interface{}{
+				"@odata.id":          "/redfish/v1/Systems/1/Storage/1",
+				"@odata.type":        "#Storage.v1_7_1.Storage",
+				"Drives":             []interface{}{},
+				"Drives@odata.count": "0",
+				"LogicalDisk":        []interface{}{},
+				"PhysicalDisk":       []interface{}{},
+			},
+			"/redfish/v1/Chassis": map[string]interface{}{
+				"Members": []interface{}{
+					map[string]interface{}{"@odata.id": "/redfish/v1/Chassis/1"},
+				},
+			},
+			"/redfish/v1/Chassis/1": map[string]interface{}{
+				"Id":              "1",
+				"NetworkAdapters": map[string]interface{}{"@odata.id": "/redfish/v1/Chassis/1/NetworkAdapters"},
+				"PCIeDevices":     map[string]interface{}{"@odata.id": "/redfish/v1/Chassis/1/PCIeDevices"},
+			},
+			"/redfish/v1/Chassis/1/NetworkAdapters": map[string]interface{}{
+				"@odata.id":           "/redfish/v1/Chassis/1/NetworkAdapters",
+				"Members":             []interface{}{},
+				"Members@odata.count": 0,
+			},
+			"/redfish/v1/Chassis/1/NetworkAdapters/1": map[string]interface{}{
+				"@odata.context": "/redfish/v1/$metadata#Chassis/Members/1/NetworkAdapters/Members/$entity",
+				"@odata.id":      "/redfish/v1/Chassis/1/NetworkAdapters/1",
+				"@odata.type":    "#NetworkAdapter.v1_0_0.Networkadapter",
+				"Id":             "1",
+				"Name":           "1",
+			},
+			"/redfish/v1/Chassis/1/PCIeDevices": map[string]interface{}{
+				"@odata.id":           "/redfish/v1/Chassis/1/PCIeDevices",
+				"Members":             []interface{}{},
+				"Members@odata.count": 0,
+			},
+			"/redfish/v1/Chassis/1/PCIeDevices/1": map[string]interface{}{
+				"@odata.context": "/redfish/v1/$metadata#PCIeDevice.PCIeDevice",
+				"@odata.id":      "/redfish/v1/Chassis/1/PCIeDevices/1",
+				"@odata.type":    "#PCIeDevice.v1_4_0.PCIeDevice",
+				"Id":             "1",
+				"Name":           "PCIe Device",
+			},
+			"/redfish/v1/Managers": map[string]interface{}{
+				"Members": []interface{}{
+					map[string]interface{}{"@odata.id": "/redfish/v1/Managers/1"},
+				},
+			},
+			"/redfish/v1/Managers/1": map[string]interface{}{
+				"Id": "1",
+			},
+		},
+	}
+
+	got, err := ReplayRedfishFromRawPayloads(raw, nil)
+	if err != nil {
+		t.Fatalf("replay failed: %v", err)
+	}
+	if got.Hardware == nil {
+		t.Fatalf("expected hardware")
+	}
+	if len(got.Hardware.NetworkAdapters) != 0 {
+		t.Fatalf("expected placeholder network adapters to be skipped, got %d", len(got.Hardware.NetworkAdapters))
+	}
+	if len(got.Hardware.PCIeDevices) != 0 {
+		t.Fatalf("expected placeholder PCIe devices to be skipped, got %d", len(got.Hardware.PCIeDevices))
+	}
+	if len(got.Hardware.Storage) != 0 {
+		t.Fatalf("expected placeholder storage members to be skipped, got %d", len(got.Hardware.Storage))
+	}
+}
+
+func TestReplayRedfishFromRawPayloads_PrefersActiveBMCInterfaceForBoardMAC(t *testing.T) {
+	raw := map[string]any{
+		"redfish_tree": map[string]interface{}{
+			"/redfish/v1": map[string]interface{}{
+				"Systems":  map[string]interface{}{"@odata.id": "/redfish/v1/Systems"},
+				"Chassis":  map[string]interface{}{"@odata.id": "/redfish/v1/Chassis"},
+				"Managers": map[string]interface{}{"@odata.id": "/redfish/v1/Managers"},
+			},
+			"/redfish/v1/Systems": map[string]interface{}{
+				"Members": []interface{}{map[string]interface{}{"@odata.id": "/redfish/v1/Systems/1"}},
+			},
+			"/redfish/v1/Systems/1": map[string]interface{}{
+				"Manufacturer": "Multillect",
+				"Model":        "MLT-S06",
+				"SerialNumber": "430044262001626",
+			},
+			"/redfish/v1/Chassis": map[string]interface{}{
+				"Members": []interface{}{map[string]interface{}{"@odata.id": "/redfish/v1/Chassis/1"}},
+			},
+			"/redfish/v1/Chassis/1": map[string]interface{}{"Id": "1"},
+			"/redfish/v1/Managers": map[string]interface{}{
+				"Members": []interface{}{map[string]interface{}{"@odata.id": "/redfish/v1/Managers/1"}},
+			},
+			"/redfish/v1/Managers/1": map[string]interface{}{
+				"Id": "1",
+			},
+			"/redfish/v1/Managers/1/EthernetInterfaces": map[string]interface{}{
+				"Members": []interface{}{
+					map[string]interface{}{"@odata.id": "/redfish/v1/Managers/1/EthernetInterfaces/eth0"},
+					map[string]interface{}{"@odata.id": "/redfish/v1/Managers/1/EthernetInterfaces/eth1"},
+				},
+				"Oem": map[string]interface{}{
+					"Public": map[string]interface{}{
+						"NcsiEnabled": true,
+						"LLDP": map[string]interface{}{
+							"LLDPMode": "Rx",
+							"Members": []interface{}{
+								map[string]interface{}{
+									"EthIndex":    "eth1",
+									"ChassisName": "castor.netwell.local",
+									"PortDesc":    "ge-0/0/17",
+									"PortId":      "531",
+									"VlanId":      20,
+								},
+							},
+						},
+					},
+				},
+			},
+			"/redfish/v1/Managers/1/EthernetInterfaces/eth0": map[string]interface{}{
+				"Id":         "eth0",
+				"MACAddress": "00:25:6c:70:00:13",
+				"LinkStatus": "NoLink",
+				"SpeedMbps":  65535,
+			},
+			"/redfish/v1/Managers/1/EthernetInterfaces/eth1": map[string]interface{}{
+				"Id":         "eth1",
+				"MACAddress": "00:25:6c:70:00:12",
+				"LinkStatus": "LinkActive",
+				"SpeedMbps":  1000,
+				"IPv4Addresses": []interface{}{
+					map[string]interface{}{
+						"Address":    "172.16.41.42",
+						"Gateway":    "172.16.41.1",
+						"SubnetMask": "255.255.255.0",
+					},
+				},
+			},
+		},
+	}
+
+	got, err := ReplayRedfishFromRawPayloads(raw, nil)
+	if err != nil {
+		t.Fatalf("replay failed: %v", err)
+	}
+	if got.Hardware == nil {
+		t.Fatalf("expected hardware")
+	}
+	if got.Hardware.BoardInfo.BMCMACAddress != "00:25:6C:70:00:12" {
+		t.Fatalf("expected active BMC MAC from eth1, got %q", got.Hardware.BoardInfo.BMCMACAddress)
+	}
+	summary, ok := got.RawPayloads["redfish_bmc_network_summary"].(map[string]any)
+	if !ok {
+		t.Fatalf("expected redfish_bmc_network_summary")
+	}
+	if summary["interface_id"] != "eth1" {
+		t.Fatalf("expected eth1 summary, got %#v", summary["interface_id"])
+	}
+}
+
+func TestReplayRedfishFromRawPayloads_AddsSensorsListHintSummary(t *testing.T) {
+	raw := map[string]any{
+		"redfish_tree": map[string]interface{}{
+			"/redfish/v1": map[string]interface{}{
+				"Systems":  map[string]interface{}{"@odata.id": "/redfish/v1/Systems"},
+				"Chassis":  map[string]interface{}{"@odata.id": "/redfish/v1/Chassis"},
+				"Managers": map[string]interface{}{"@odata.id": "/redfish/v1/Managers"},
+			},
+			"/redfish/v1/Systems": map[string]interface{}{
+				"Members": []interface{}{map[string]interface{}{"@odata.id": "/redfish/v1/Systems/1"}},
+			},
+			"/redfish/v1/Systems/1": map[string]interface{}{
+				"Manufacturer": "Multillect",
+				"Model":        "MLT-S06",
+				"SerialNumber": "430044262001626",
+			},
+			"/redfish/v1/Chassis": map[string]interface{}{
+				"Members": []interface{}{map[string]interface{}{"@odata.id": "/redfish/v1/Chassis/1"}},
+			},
+			"/redfish/v1/Chassis/1": map[string]interface{}{"Id": "1"},
+			"/redfish/v1/Chassis/1/SensorsList": map[string]interface{}{
+				"SensorsList": []interface{}{
+					map[string]interface{}{"SensorName": "DIMM000_Status", "SensorType": "Memory", "Status": "OK"},
+					map[string]interface{}{"SensorName": "DIMM001_Status", "SensorType": "Memory", "Status": "nop"},
+					map[string]interface{}{"SensorName": "DIMM100_Status", "SensorType": "Memory", "Status": "OK"},
+					map[string]interface{}{"SensorName": "HDD0_F_Status", "SensorType": "Drive Slot", "Status": "nop"},
+					map[string]interface{}{"SensorName": "NVME0_F_Status", "SensorType": "Drive Slot", "Status": "nop"},
+					map[string]interface{}{"SensorName": "Logical_Drive", "SensorType": "Drive Slot", "Status": "OK"},
+				},
+			},
+			"/redfish/v1/Managers": map[string]interface{}{
+				"Members": []interface{}{map[string]interface{}{"@odata.id": "/redfish/v1/Managers/1"}},
+			},
+			"/redfish/v1/Managers/1": map[string]interface{}{"Id": "1"},
+		},
+	}
+
+	got, err := ReplayRedfishFromRawPayloads(raw, nil)
+	if err != nil {
+		t.Fatalf("replay failed: %v", err)
+	}
+	hints, ok := got.RawPayloads["redfish_sensor_hints"].(map[string]any)
+	if !ok {
+		t.Fatalf("expected redfish_sensor_hints")
+	}
+	memHints, ok := hints["memory_slots"].(map[string]any)
+	if !ok {
+		t.Fatalf("expected memory_slots hint")
+	}
+	if asInt(memHints["present_count"]) != 2 {
+		t.Fatalf("expected 2 present memory slot hints, got %#v", memHints["present_count"])
+	}
+	driveHints, ok := hints["drive_slots"].(map[string]any)
+	if !ok {
+		t.Fatalf("expected drive_slots hint")
+	}
+	if asInt(driveHints["physical_total"]) != 2 {
+		t.Fatalf("expected 2 physical drive slots, got %#v", driveHints["physical_total"])
+	}
+	if driveHints["logical_drive_status"] != "OK" {
+		t.Fatalf("expected logical drive status OK, got %#v", driveHints["logical_drive_status"])
+	}
+	foundMemoryEvent := false
+	foundDriveEvent := false
+	for _, ev := range got.Events {
+		if strings.Contains(ev.Description, "Memory slot sensors report 2 populated positions out of 3") {
+			foundMemoryEvent = true
+		}
+		if strings.Contains(ev.Description, "Drive slot sensors report 0 active physical slots out of 2") {
+			foundDriveEvent = true
+		}
+	}
+	if !foundMemoryEvent {
+		t.Fatalf("expected memory slot hint event")
+	}
+	if !foundDriveEvent {
+		t.Fatalf("expected drive slot hint event")
+	}
+}
+
 func TestReplayRedfishFromRawPayloads_PreservesSourceTimezoneAndUTCCollectedAt(t *testing.T) {
 	raw := map[string]any{
 		"redfish_tree": map[string]interface{}{

internal/collector/redfishprofile/profile_hpe.go

@@ -0,0 +1,67 @@
+package redfishprofile
+
+func hpeProfile() Profile {
+	return staticProfile{
+		name:            "hpe",
+		priority:        20,
+		safeForFallback: true,
+		matchFn: func(s MatchSignals) int {
+			score := 0
+			if containsFold(s.SystemManufacturer, "hpe") ||
+				containsFold(s.SystemManufacturer, "hewlett packard") ||
+				containsFold(s.ChassisManufacturer, "hpe") ||
+				containsFold(s.ChassisManufacturer, "hewlett packard") {
+				score += 80
+			}
+			for _, ns := range s.OEMNamespaces {
+				if containsFold(ns, "hpe") {
+					score += 30
+					break
+				}
+			}
+			if containsFold(s.ServiceRootProduct, "ilo") {
+				score += 30
+			}
+			if containsFold(s.ManagerManufacturer, "hpe") || containsFold(s.ManagerManufacturer, "ilo") {
+				score += 20
+			}
+			return min(score, 100)
+		},
+		extendAcquisition: func(plan *AcquisitionPlan, _ MatchSignals) {
+			// HPE ProLiant SmartStorage RAID controller inventory is not reachable
+			// via standard Redfish Storage paths — it requires the HPE OEM SmartStorage tree.
+			ensureScopedPathPolicy(plan, AcquisitionScopedPathPolicy{
+				SystemCriticalSuffixes: []string{
+					"/SmartStorage",
+					"/SmartStorageConfig",
+				},
+				ManagerCriticalSuffixes: []string{
+					"/LicenseService",
+				},
+			})
+			// HPE iLO responds more slowly than average BMCs under load; give the
+			// ETA estimator a realistic baseline so progress reports are accurate.
+			ensureETABaseline(plan, AcquisitionETABaseline{
+				DiscoverySeconds:     12,
+				SnapshotSeconds:      180,
+				PrefetchSeconds:      30,
+				CriticalPlanBSeconds: 40,
+				ProfilePlanBSeconds:  25,
+			})
+			ensureRecoveryPolicy(plan, AcquisitionRecoveryPolicy{
+				EnableProfilePlanB: true,
+			})
+			// HPE iLO starts throttling under high request rates.  Setting a higher
+			// latency tolerance prevents the adaptive throttler from treating normal
+			// iLO slowness as a reason to stall the collection.
+			ensureRatePolicy(plan, AcquisitionRatePolicy{
+				TargetP95LatencyMS:      1200,
+				ThrottleP95LatencyMS:    2500,
+				MinSnapshotWorkers:      2,
+				MinPrefetchWorkers:      1,
+				DisablePrefetchOnErrors: true,
+			})
+			addPlanNote(plan, "hpe ilo acquisition extensions enabled")
+		},
+	}
+}

internal/collector/redfishprofile/profiles_common.go

@@ -55,6 +55,7 @@ func BuiltinProfiles() []Profile {
 		msiProfile(),
 		supermicroProfile(),
 		dellProfile(),
+		hpeProfile(),
 		inspurGroupOEMPlatformsProfile(),
 		hgxProfile(),
 		xfusionProfile(),

internal/parser/archive.go

@@ -19,6 +19,7 @@ const maxZipArchiveSize = 50 * 1024 * 1024
 const maxGzipDecompressedSize = 50 * 1024 * 1024
 
 var supportedArchiveExt = map[string]struct{}{
+	".ahs": {},
 	".gz":  {},
 	".tgz": {},
 	".tar": {},
@@ -45,6 +46,8 @@ func ExtractArchive(archivePath string) ([]ExtractedFile, error) {
 	ext := strings.ToLower(filepath.Ext(archivePath))
 
 	switch ext {
+	case ".ahs":
+		return extractSingleFile(archivePath)
 	case ".gz", ".tgz":
 		return extractTarGz(archivePath)
 	case ".tar", ".sds":
@@ -66,6 +69,8 @@ func ExtractArchiveFromReader(r io.Reader, filename string) ([]ExtractedFile, er
 	ext := strings.ToLower(filepath.Ext(filename))
 
 	switch ext {
+	case ".ahs":
+		return extractSingleFileFromReader(r, filename)
 	case ".gz", ".tgz":
 		return extractTarGzFromReader(r, filename)
 	case ".tar", ".sds":

internal/parser/archive_test.go

@@ -76,6 +76,7 @@ func TestIsSupportedArchiveFilename(t *testing.T) {
 		name string
 		want bool
 	}{
+		{name: "HPE_CZ2D1X0GS3_20260330.ahs", want: true},
 		{name: "dump.tar.gz", want: true},
 		{name: "nvidia-bug-report-1651124000923.log.gz", want: true},
 		{name: "snapshot.zip", want: true},
@@ -124,3 +125,20 @@ func TestExtractArchiveFromReaderSDS(t *testing.T) {
 		t.Fatalf("expected bmc/pack.info, got %q", files[0].Path)
 	}
 }
+
+func TestExtractArchiveFromReaderAHS(t *testing.T) {
+	payload := []byte("ABJRtest")
+	files, err := ExtractArchiveFromReader(bytes.NewReader(payload), "sample.ahs")
+	if err != nil {
+		t.Fatalf("extract ahs from reader: %v", err)
+	}
+	if len(files) != 1 {
+		t.Fatalf("expected 1 extracted file, got %d", len(files))
+	}
+	if files[0].Path != "sample.ahs" {
+		t.Fatalf("expected sample.ahs, got %q", files[0].Path)
+	}
+	if string(files[0].Content) != string(payload) {
+		t.Fatalf("content mismatch")
+	}
+}

internal/parser/vendors/easy_bee/parser.go

@@ -0,0 +1,601 @@
+package easy_bee
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"time"
+
+	"git.mchus.pro/mchus/logpile/internal/models"
+	"git.mchus.pro/mchus/logpile/internal/parser"
+)
+
+const parserVersion = "1.0"
+
+func init() {
+	parser.Register(&Parser{})
+}
+
+// Parser imports support bundles produced by reanimator-easy-bee.
+// These archives embed a ready-to-use hardware snapshot in export/bee-audit.json.
+type Parser struct{}
+
+func (p *Parser) Name() string {
+	return "Reanimator Easy Bee Parser"
+}
+
+func (p *Parser) Vendor() string {
+	return "easy_bee"
+}
+
+func (p *Parser) Version() string {
+	return parserVersion
+}
+
+func (p *Parser) Detect(files []parser.ExtractedFile) int {
+	confidence := 0
+	hasManifest := false
+	hasBeeAudit := false
+	hasRuntimeHealth := false
+	hasTechdump := false
+	hasBundlePrefix := false
+
+	for _, f := range files {
+		path := strings.ToLower(strings.TrimSpace(f.Path))
+		content := strings.ToLower(string(f.Content))
+
+		if !hasBundlePrefix && strings.Contains(path, "bee-support-") {
+			hasBundlePrefix = true
+			confidence += 5
+		}
+
+		if (strings.HasSuffix(path, "/manifest.txt") || path == "manifest.txt") &&
+			strings.Contains(content, "bee_version=") {
+			hasManifest = true
+			confidence += 35
+			if strings.Contains(content, "export_dir=") {
+				confidence += 10
+			}
+		}
+
+		if strings.HasSuffix(path, "/export/bee-audit.json") || path == "bee-audit.json" {
+			hasBeeAudit = true
+			confidence += 55
+		}
+
+		if hasBundlePrefix && (strings.HasSuffix(path, "/export/runtime-health.json") || path == "runtime-health.json") {
+			hasRuntimeHealth = true
+			confidence += 10
+		}
+
+		if hasBundlePrefix && !hasTechdump && strings.Contains(path, "/export/techdump/") {
+			hasTechdump = true
+			confidence += 10
+		}
+	}
+
+	if hasManifest && hasBeeAudit {
+		return 100
+	}
+	if hasBeeAudit && (hasRuntimeHealth || hasTechdump) {
+		confidence += 10
+	}
+	if confidence > 100 {
+		return 100
+	}
+	return confidence
+}
+
+func (p *Parser) Parse(files []parser.ExtractedFile) (*models.AnalysisResult, error) {
+	snapshotFile := findSnapshotFile(files)
+	if snapshotFile == nil {
+		return nil, fmt.Errorf("easy-bee snapshot not found")
+	}
+
+	var snapshot beeSnapshot
+	if err := json.Unmarshal(snapshotFile.Content, &snapshot); err != nil {
+		return nil, fmt.Errorf("decode %s: %w", snapshotFile.Path, err)
+	}
+
+	manifest := parseManifest(files)
+
+	result := &models.AnalysisResult{
+		SourceType:              strings.TrimSpace(snapshot.SourceType),
+		Protocol:                strings.TrimSpace(snapshot.Protocol),
+		TargetHost:              firstNonEmpty(snapshot.TargetHost, manifest.Host),
+		SourceTimezone:          strings.TrimSpace(snapshot.SourceTimezone),
+		CollectedAt:             chooseCollectedAt(snapshot, manifest),
+		InventoryLastModifiedAt: snapshot.InventoryLastModifiedAt,
+		RawPayloads:             snapshot.RawPayloads,
+		Events:                  make([]models.Event, 0),
+		FRU:                     append([]models.FRUInfo(nil), snapshot.FRU...),
+		Sensors:                 make([]models.SensorReading, 0),
+		Hardware: &models.HardwareConfig{
+			Firmware:        append([]models.FirmwareInfo(nil), snapshot.Hardware.Firmware...),
+			BoardInfo:       snapshot.Hardware.Board,
+			Devices:         append([]models.HardwareDevice(nil), snapshot.Hardware.Devices...),
+			CPUs:            append([]models.CPU(nil), snapshot.Hardware.CPUs...),
+			Memory:          append([]models.MemoryDIMM(nil), snapshot.Hardware.Memory...),
+			Storage:         append([]models.Storage(nil), snapshot.Hardware.Storage...),
+			Volumes:         append([]models.StorageVolume(nil), snapshot.Hardware.Volumes...),
+			PCIeDevices:     normalizePCIeDevices(snapshot.Hardware.PCIeDevices),
+			GPUs:            append([]models.GPU(nil), snapshot.Hardware.GPUs...),
+			NetworkCards:    append([]models.NIC(nil), snapshot.Hardware.NetworkCards...),
+			NetworkAdapters: normalizeNetworkAdapters(snapshot.Hardware.NetworkAdapters),
+			PowerSupply:     append([]models.PSU(nil), snapshot.Hardware.PowerSupply...),
+		},
+	}
+
+	result.Events = append(result.Events, snapshot.Events...)
+	result.Events = append(result.Events, convertRuntimeToEvents(snapshot.Runtime, result.CollectedAt)...)
+	result.Events = append(result.Events, convertEventLogs(snapshot.Hardware.EventLogs)...)
+
+	result.Sensors = append(result.Sensors, snapshot.Sensors...)
+	result.Sensors = append(result.Sensors, flattenSensorGroups(snapshot.Hardware.Sensors)...)
+
+	if len(result.FRU) == 0 {
+		if boardFRU, ok := buildBoardFRU(snapshot.Hardware.Board); ok {
+			result.FRU = append(result.FRU, boardFRU)
+		}
+	}
+
+	if result.Hardware == nil || (result.Hardware.BoardInfo.SerialNumber == "" &&
+		len(result.Hardware.CPUs) == 0 &&
+		len(result.Hardware.Memory) == 0 &&
+		len(result.Hardware.Storage) == 0 &&
+		len(result.Hardware.PCIeDevices) == 0 &&
+		len(result.Hardware.Devices) == 0) {
+		return nil, fmt.Errorf("unsupported easy-bee snapshot format")
+	}
+
+	return result, nil
+}
+
+type beeSnapshot struct {
+	SourceType              string                 `json:"source_type,omitempty"`
+	Protocol                string                 `json:"protocol,omitempty"`
+	TargetHost              string                 `json:"target_host,omitempty"`
+	SourceTimezone          string                 `json:"source_timezone,omitempty"`
+	CollectedAt             time.Time              `json:"collected_at,omitempty"`
+	InventoryLastModifiedAt time.Time              `json:"inventory_last_modified_at,omitempty"`
+	RawPayloads             map[string]any         `json:"raw_payloads,omitempty"`
+	Events                  []models.Event         `json:"events,omitempty"`
+	FRU                     []models.FRUInfo       `json:"fru,omitempty"`
+	Sensors                 []models.SensorReading `json:"sensors,omitempty"`
+	Hardware                beeHardware            `json:"hardware"`
+	Runtime                 beeRuntime             `json:"runtime,omitempty"`
+}
+
+type beeHardware struct {
+	Board           models.BoardInfo        `json:"board"`
+	Firmware        []models.FirmwareInfo   `json:"firmware,omitempty"`
+	Devices         []models.HardwareDevice `json:"devices,omitempty"`
+	CPUs            []models.CPU            `json:"cpus,omitempty"`
+	Memory          []models.MemoryDIMM     `json:"memory,omitempty"`
+	Storage         []models.Storage        `json:"storage,omitempty"`
+	Volumes         []models.StorageVolume  `json:"volumes,omitempty"`
+	PCIeDevices     []models.PCIeDevice     `json:"pcie_devices,omitempty"`
+	GPUs            []models.GPU            `json:"gpus,omitempty"`
+	NetworkCards    []models.NIC            `json:"network_cards,omitempty"`
+	NetworkAdapters []models.NetworkAdapter `json:"network_adapters,omitempty"`
+	PowerSupply     []models.PSU            `json:"power_supplies,omitempty"`
+	Sensors         beeSensorGroups         `json:"sensors,omitempty"`
+	EventLogs       []beeEventLog           `json:"event_logs,omitempty"`
+}
+
+type beeSensorGroups struct {
+	Fans         []beeFanSensor         `json:"fans,omitempty"`
+	Power        []beePowerSensor       `json:"power,omitempty"`
+	Temperatures []beeTemperatureSensor `json:"temperatures,omitempty"`
+	Other        []beeOtherSensor       `json:"other,omitempty"`
+}
+
+type beeFanSensor struct {
+	Name     string `json:"name"`
+	Location string `json:"location,omitempty"`
+	RPM      int    `json:"rpm,omitempty"`
+	Status   string `json:"status,omitempty"`
+}
+
+type beePowerSensor struct {
+	Name     string  `json:"name"`
+	Location string  `json:"location,omitempty"`
+	VoltageV float64 `json:"voltage_v,omitempty"`
+	CurrentA float64 `json:"current_a,omitempty"`
+	PowerW   float64 `json:"power_w,omitempty"`
+	Status   string  `json:"status,omitempty"`
+}
+
+type beeTemperatureSensor struct {
+	Name                     string  `json:"name"`
+	Location                 string  `json:"location,omitempty"`
+	Celsius                  float64 `json:"celsius,omitempty"`
+	ThresholdWarningCelsius  float64 `json:"threshold_warning_celsius,omitempty"`
+	ThresholdCriticalCelsius float64 `json:"threshold_critical_celsius,omitempty"`
+	Status                   string  `json:"status,omitempty"`
+}
+
+type beeOtherSensor struct {
+	Name     string  `json:"name"`
+	Location string  `json:"location,omitempty"`
+	Value    float64 `json:"value,omitempty"`
+	Unit     string  `json:"unit,omitempty"`
+	Status   string  `json:"status,omitempty"`
+}
+
+type beeRuntime struct {
+	Status        string             `json:"status,omitempty"`
+	CheckedAt     time.Time          `json:"checked_at,omitempty"`
+	NetworkStatus string             `json:"network_status,omitempty"`
+	Issues        []beeRuntimeIssue  `json:"issues,omitempty"`
+	Services      []beeRuntimeStatus `json:"services,omitempty"`
+	Interfaces    []beeInterface     `json:"interfaces,omitempty"`
+}
+
+type beeRuntimeIssue struct {
+	Code        string `json:"code,omitempty"`
+	Severity    string `json:"severity,omitempty"`
+	Description string `json:"description,omitempty"`
+}
+
+type beeRuntimeStatus struct {
+	Name   string `json:"name,omitempty"`
+	Status string `json:"status,omitempty"`
+}
+
+type beeInterface struct {
+	Name    string   `json:"name,omitempty"`
+	State   string   `json:"state,omitempty"`
+	IPv4    []string `json:"ipv4,omitempty"`
+	Outcome string   `json:"outcome,omitempty"`
+}
+
+type beeEventLog struct {
+	Source     string         `json:"source,omitempty"`
+	EventTime  string         `json:"event_time,omitempty"`
+	Severity   string         `json:"severity,omitempty"`
+	MessageID  string         `json:"message_id,omitempty"`
+	Message    string         `json:"message,omitempty"`
+	RawPayload map[string]any `json:"raw_payload,omitempty"`
+}
+
+type manifestMetadata struct {
+	Host           string
+	GeneratedAtUTC time.Time
+}
+
+func findSnapshotFile(files []parser.ExtractedFile) *parser.ExtractedFile {
+	for i := range files {
+		path := strings.ToLower(strings.TrimSpace(files[i].Path))
+		if strings.HasSuffix(path, "/export/bee-audit.json") || path == "bee-audit.json" {
+			return &files[i]
+		}
+	}
+	for i := range files {
+		path := strings.ToLower(strings.TrimSpace(files[i].Path))
+		if strings.HasSuffix(path, ".json") && strings.Contains(path, "reanimator") {
+			return &files[i]
+		}
+	}
+	return nil
+}
+
+func parseManifest(files []parser.ExtractedFile) manifestMetadata {
+	var meta manifestMetadata
+
+	for _, f := range files {
+		path := strings.ToLower(strings.TrimSpace(f.Path))
+		if !(strings.HasSuffix(path, "/manifest.txt") || path == "manifest.txt") {
+			continue
+		}
+
+		lines := strings.Split(string(f.Content), "\n")
+		for _, line := range lines {
+			key, value, ok := strings.Cut(strings.TrimSpace(line), "=")
+			if !ok {
+				continue
+			}
+			switch strings.TrimSpace(key) {
+			case "host":
+				meta.Host = strings.TrimSpace(value)
+			case "generated_at_utc":
+				if ts, err := time.Parse(time.RFC3339, strings.TrimSpace(value)); err == nil {
+					meta.GeneratedAtUTC = ts.UTC()
+				}
+			}
+		}
+		break
+	}
+
+	return meta
+}
+
+func chooseCollectedAt(snapshot beeSnapshot, manifest manifestMetadata) time.Time {
+	switch {
+	case !snapshot.CollectedAt.IsZero():
+		return snapshot.CollectedAt.UTC()
+	case !snapshot.Runtime.CheckedAt.IsZero():
+		return snapshot.Runtime.CheckedAt.UTC()
+	case !manifest.GeneratedAtUTC.IsZero():
+		return manifest.GeneratedAtUTC.UTC()
+	default:
+		return time.Time{}
+	}
+}
+
+func convertRuntimeToEvents(runtime beeRuntime, fallback time.Time) []models.Event {
+	events := make([]models.Event, 0)
+	ts := runtime.CheckedAt
+	if ts.IsZero() {
+		ts = fallback
+	}
+
+	if status := strings.TrimSpace(runtime.Status); status != "" {
+		desc := "Bee runtime status: " + status
+		if networkStatus := strings.TrimSpace(runtime.NetworkStatus); networkStatus != "" {
+			desc += " (network: " + networkStatus + ")"
+		}
+		events = append(events, models.Event{
+			Timestamp:   ts,
+			Source:      "Bee Runtime",
+			EventType:   "Runtime Status",
+			Severity:    mapSeverity(status),
+			Description: desc,
+		})
+	}
+
+	for _, issue := range runtime.Issues {
+		desc := strings.TrimSpace(issue.Description)
+		if desc == "" {
+			desc = "Bee runtime issue"
+		}
+		events = append(events, models.Event{
+			Timestamp:   ts,
+			Source:      "Bee Runtime",
+			EventType:   "Runtime Issue",
+			Severity:    mapSeverity(issue.Severity),
+			Description: desc,
+			RawData:     strings.TrimSpace(issue.Code),
+		})
+	}
+
+	for _, svc := range runtime.Services {
+		status := strings.TrimSpace(svc.Status)
+		if status == "" || strings.EqualFold(status, "active") {
+			continue
+		}
+		events = append(events, models.Event{
+			Timestamp:   ts,
+			Source:      "systemd",
+			EventType:   "Service Status",
+			Severity:    mapSeverity(status),
+			Description: fmt.Sprintf("%s is %s", strings.TrimSpace(svc.Name), status),
+		})
+	}
+
+	for _, iface := range runtime.Interfaces {
+		state := strings.TrimSpace(iface.State)
+		outcome := strings.TrimSpace(iface.Outcome)
+		if state == "" && outcome == "" {
+			continue
+		}
+		if strings.EqualFold(state, "up") && strings.EqualFold(outcome, "lease_acquired") {
+			continue
+		}
+		desc := fmt.Sprintf("interface %s state=%s outcome=%s", strings.TrimSpace(iface.Name), state, outcome)
+		events = append(events, models.Event{
+			Timestamp:   ts,
+			Source:      "network",
+			EventType:   "Interface Status",
+			Severity:    models.SeverityWarning,
+			Description: strings.TrimSpace(desc),
+		})
+	}
+
+	return events
+}
+
+func convertEventLogs(items []beeEventLog) []models.Event {
+	events := make([]models.Event, 0, len(items))
+	for _, item := range items {
+		message := strings.TrimSpace(item.Message)
+		if message == "" {
+			continue
+		}
+		ts := parseEventTime(item.EventTime)
+		rawData := strings.TrimSpace(item.MessageID)
+		events = append(events, models.Event{
+			Timestamp:   ts,
+			Source:      firstNonEmpty(strings.TrimSpace(item.Source), "Reanimator"),
+			EventType:   "Event Log",
+			Severity:    mapSeverity(item.Severity),
+			Description: message,
+			RawData:     rawData,
+		})
+	}
+	return events
+}
+
+func parseEventTime(raw string) time.Time {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return time.Time{}
+	}
+	layouts := []string{time.RFC3339Nano, time.RFC3339}
+	for _, layout := range layouts {
+		if ts, err := time.Parse(layout, raw); err == nil {
+			return ts.UTC()
+		}
+	}
+	return time.Time{}
+}
+
+func flattenSensorGroups(groups beeSensorGroups) []models.SensorReading {
+	result := make([]models.SensorReading, 0, len(groups.Fans)+len(groups.Power)+len(groups.Temperatures)+len(groups.Other))
+
+	for _, fan := range groups.Fans {
+		result = append(result, models.SensorReading{
+			Name:   sensorName(fan.Name, fan.Location),
+			Type:   "fan",
+			Value:  float64(fan.RPM),
+			Unit:   "RPM",
+			Status: strings.TrimSpace(fan.Status),
+		})
+	}
+
+	for _, power := range groups.Power {
+		name := sensorName(power.Name, power.Location)
+		status := strings.TrimSpace(power.Status)
+		if power.PowerW != 0 {
+			result = append(result, models.SensorReading{
+				Name:   name,
+				Type:   "power",
+				Value:  power.PowerW,
+				Unit:   "W",
+				Status: status,
+			})
+		}
+		if power.VoltageV != 0 {
+			result = append(result, models.SensorReading{
+				Name:   name + " Voltage",
+				Type:   "voltage",
+				Value:  power.VoltageV,
+				Unit:   "V",
+				Status: status,
+			})
+		}
+		if power.CurrentA != 0 {
+			result = append(result, models.SensorReading{
+				Name:   name + " Current",
+				Type:   "current",
+				Value:  power.CurrentA,
+				Unit:   "A",
+				Status: status,
+			})
+		}
+	}
+
+	for _, temp := range groups.Temperatures {
+		result = append(result, models.SensorReading{
+			Name:   sensorName(temp.Name, temp.Location),
+			Type:   "temperature",
+			Value:  temp.Celsius,
+			Unit:   "C",
+			Status: strings.TrimSpace(temp.Status),
+		})
+	}
+
+	for _, other := range groups.Other {
+		result = append(result, models.SensorReading{
+			Name:   sensorName(other.Name, other.Location),
+			Type:   "other",
+			Value:  other.Value,
+			Unit:   strings.TrimSpace(other.Unit),
+			Status: strings.TrimSpace(other.Status),
+		})
+	}
+
+	return result
+}
+
+func sensorName(name, location string) string {
+	name = strings.TrimSpace(name)
+	location = strings.TrimSpace(location)
+	if name == "" {
+		return location
+	}
+	if location == "" {
+		return name
+	}
+	return name + " [" + location + "]"
+}
+
+func normalizePCIeDevices(items []models.PCIeDevice) []models.PCIeDevice {
+	out := append([]models.PCIeDevice(nil), items...)
+	for i := range out {
+		slot := strings.TrimSpace(out[i].Slot)
+		if out[i].BDF == "" && looksLikeBDF(slot) {
+			out[i].BDF = slot
+		}
+		if out[i].Slot == "" && out[i].BDF != "" {
+			out[i].Slot = out[i].BDF
+		}
+	}
+	return out
+}
+
+func normalizeNetworkAdapters(items []models.NetworkAdapter) []models.NetworkAdapter {
+	out := append([]models.NetworkAdapter(nil), items...)
+	for i := range out {
+		slot := strings.TrimSpace(out[i].Slot)
+		if out[i].BDF == "" && looksLikeBDF(slot) {
+			out[i].BDF = slot
+		}
+		if out[i].Slot == "" && out[i].BDF != "" {
+			out[i].Slot = out[i].BDF
+		}
+	}
+	return out
+}
+
+func looksLikeBDF(value string) bool {
+	value = strings.TrimSpace(value)
+	if len(value) != len("0000:00:00.0") {
+		return false
+	}
+	for i, r := range value {
+		switch i {
+		case 4, 7:
+			if r != ':' {
+				return false
+			}
+		case 10:
+			if r != '.' {
+				return false
+			}
+		default:
+			if !((r >= '0' && r <= '9') || (r >= 'a' && r <= 'f') || (r >= 'A' && r <= 'F')) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func buildBoardFRU(board models.BoardInfo) (models.FRUInfo, bool) {
+	if strings.TrimSpace(board.SerialNumber) == "" &&
+		strings.TrimSpace(board.Manufacturer) == "" &&
+		strings.TrimSpace(board.ProductName) == "" &&
+		strings.TrimSpace(board.PartNumber) == "" {
+		return models.FRUInfo{}, false
+	}
+
+	return models.FRUInfo{
+		Description:  "System Board",
+		Manufacturer: strings.TrimSpace(board.Manufacturer),
+		ProductName:  strings.TrimSpace(board.ProductName),
+		SerialNumber: strings.TrimSpace(board.SerialNumber),
+		PartNumber:   strings.TrimSpace(board.PartNumber),
+	}, true
+}
+
+func mapSeverity(raw string) models.Severity {
+	switch strings.ToLower(strings.TrimSpace(raw)) {
+	case "critical", "crit", "error", "failed", "failure":
+		return models.SeverityCritical
+	case "warning", "warn", "partial", "degraded", "inactive", "activating", "deactivating":
+		return models.SeverityWarning
+	default:
+		return models.SeverityInfo
+	}
+}
+
+func firstNonEmpty(values ...string) string {
+	for _, value := range values {
+		value = strings.TrimSpace(value)
+		if value != "" {
+			return value
+		}
+	}
+	return ""
+}

internal/parser/vendors/easy_bee/parser_test.go

@@ -0,0 +1,219 @@
+package easy_bee
+
+import (
+	"testing"
+	"time"
+
+	"git.mchus.pro/mchus/logpile/internal/parser"
+)
+
+func TestDetectBeeSupportArchive(t *testing.T) {
+	p := &Parser{}
+	files := []parser.ExtractedFile{
+		{
+			Path:    "bee-support-debian-20260325-162030/manifest.txt",
+			Content: []byte("bee_version=1.0.0\nhost=debian\ngenerated_at_utc=2026-03-25T16:20:30Z\nexport_dir=/appdata/bee/export\n"),
+		},
+		{
+			Path:    "bee-support-debian-20260325-162030/export/bee-audit.json",
+			Content: []byte(`{"hardware":{"board":{"serial_number":"SN-BEE-001"}}}`),
+		},
+		{
+			Path:    "bee-support-debian-20260325-162030/export/runtime-health.json",
+			Content: []byte(`{"status":"PARTIAL"}`),
+		},
+	}
+
+	if got := p.Detect(files); got < 90 {
+		t.Fatalf("expected high confidence detect score, got %d", got)
+	}
+}
+
+func TestDetectRejectsNonBeeArchive(t *testing.T) {
+	p := &Parser{}
+	files := []parser.ExtractedFile{
+		{
+			Path:    "random/manifest.txt",
+			Content: []byte("host=test\n"),
+		},
+		{
+			Path:    "random/export/runtime-health.json",
+			Content: []byte(`{"status":"OK"}`),
+		},
+	}
+
+	if got := p.Detect(files); got != 0 {
+		t.Fatalf("expected detect score 0, got %d", got)
+	}
+}
+
+func TestParseBeeAuditSnapshot(t *testing.T) {
+	p := &Parser{}
+	files := []parser.ExtractedFile{
+		{
+			Path:    "bee-support-debian-20260325-162030/manifest.txt",
+			Content: []byte("bee_version=1.0.0\nhost=debian\ngenerated_at_utc=2026-03-25T16:20:30Z\nexport_dir=/appdata/bee/export\n"),
+		},
+		{
+			Path: "bee-support-debian-20260325-162030/export/bee-audit.json",
+			Content: []byte(`{
+  "source_type": "manual",
+  "target_host": "debian",
+  "collected_at": "2026-03-25T16:08:09Z",
+  "runtime": {
+    "status": "PARTIAL",
+    "checked_at": "2026-03-25T16:07:56Z",
+    "network_status": "OK",
+    "issues": [
+      {
+        "code": "nvidia_kernel_module_missing",
+        "severity": "warning",
+        "description": "NVIDIA kernel module is not loaded."
+      }
+    ],
+    "services": [
+      {
+        "name": "bee-web",
+        "status": "inactive"
+      }
+    ]
+  },
+  "hardware": {
+    "board": {
+      "manufacturer": "Supermicro",
+      "product_name": "AS-4124GQ-TNMI",
+      "serial_number": "S490387X4418273",
+      "part_number": "H12DGQ-NT6",
+      "uuid": "d868ae00-a61f-11ee-8000-7cc255e10309"
+    },
+    "firmware": [
+      {
+        "device_name": "BIOS",
+        "version": "2.8"
+      }
+    ],
+    "cpus": [
+      {
+        "status": "OK",
+        "status_checked_at": "2026-03-25T16:08:09Z",
+        "socket": 1,
+        "model": "AMD EPYC 7763 64-Core Processor",
+        "cores": 64,
+        "threads": 128,
+        "frequency_mhz": 2450,
+        "max_frequency_mhz": 3525
+      }
+    ],
+    "memory": [
+      {
+        "status": "OK",
+        "status_checked_at": "2026-03-25T16:08:09Z",
+        "slot": "P1-DIMMA1",
+        "location": "P0_Node0_Channel0_Dimm0",
+        "present": true,
+        "size_mb": 32768,
+        "type": "DDR4",
+        "max_speed_mhz": 3200,
+        "current_speed_mhz": 2933,
+        "manufacturer": "SK Hynix",
+        "serial_number": "80AD01224887286666",
+        "part_number": "HMA84GR7DJR4N-XN"
+      }
+    ],
+    "storage": [
+      {
+        "status": "Unknown",
+        "status_checked_at": "2026-03-25T16:08:09Z",
+        "slot": "nvme0n1",
+        "type": "NVMe",
+        "model": "KCD6XLUL960G",
+        "serial_number": "2470A00XT5M8",
+        "interface": "NVMe",
+        "present": true
+      }
+    ],
+    "pcie_devices": [
+      {
+        "status": "OK",
+        "status_checked_at": "2026-03-25T16:08:09Z",
+        "slot": "0000:05:00.0",
+        "vendor_id": 5555,
+        "device_id": 4123,
+        "device_class": "EthernetController",
+        "manufacturer": "Mellanox Technologies",
+        "model": "MT28908 Family [ConnectX-6]",
+        "link_width": 16,
+        "link_speed": "Gen4",
+        "max_link_width": 16,
+        "max_link_speed": "Gen4",
+        "mac_addresses": ["94:6d:ae:9a:75:4a"],
+        "present": true
+      }
+    ],
+    "sensors": {
+      "power": [
+        {
+          "name": "PPT",
+          "location": "amdgpu-pci-1100",
+          "power_w": 95
+        }
+      ],
+      "temperatures": [
+        {
+          "name": "Composite",
+          "location": "nvme-pci-0600",
+          "celsius": 28.85,
+          "threshold_warning_celsius": 72.85,
+          "threshold_critical_celsius": 81.85,
+          "status": "OK"
+        }
+      ]
+    }
+  }
+}`),
+		},
+	}
+
+	result, err := p.Parse(files)
+	if err != nil {
+		t.Fatalf("parse failed: %v", err)
+	}
+
+	if result.Hardware == nil {
+		t.Fatal("expected hardware to be populated")
+	}
+	if result.TargetHost != "debian" {
+		t.Fatalf("expected target host debian, got %q", result.TargetHost)
+	}
+	wantCollectedAt := time.Date(2026, 3, 25, 16, 8, 9, 0, time.UTC)
+	if !result.CollectedAt.Equal(wantCollectedAt) {
+		t.Fatalf("expected collected_at %s, got %s", wantCollectedAt, result.CollectedAt)
+	}
+	if result.Hardware.BoardInfo.SerialNumber != "S490387X4418273" {
+		t.Fatalf("unexpected board serial %q", result.Hardware.BoardInfo.SerialNumber)
+	}
+	if len(result.Hardware.CPUs) != 1 {
+		t.Fatalf("expected 1 cpu, got %d", len(result.Hardware.CPUs))
+	}
+	if len(result.Hardware.Memory) != 1 {
+		t.Fatalf("expected 1 dimm, got %d", len(result.Hardware.Memory))
+	}
+	if len(result.Hardware.Storage) != 1 {
+		t.Fatalf("expected 1 storage device, got %d", len(result.Hardware.Storage))
+	}
+	if len(result.Hardware.PCIeDevices) != 1 {
+		t.Fatalf("expected 1 pcie device, got %d", len(result.Hardware.PCIeDevices))
+	}
+	if result.Hardware.PCIeDevices[0].BDF != "0000:05:00.0" {
+		t.Fatalf("expected BDF to be normalized from slot, got %q", result.Hardware.PCIeDevices[0].BDF)
+	}
+	if len(result.Sensors) != 2 {
+		t.Fatalf("expected 2 flattened sensors, got %d", len(result.Sensors))
+	}
+	if len(result.Events) < 3 {
+		t.Fatalf("expected runtime events to be created, got %d", len(result.Events))
+	}
+	if len(result.FRU) == 0 {
+		t.Fatal("expected board FRU fallback to be populated")
+	}
+}

internal/parser/vendors/hpe_ilo_ahs/parser_test.go

@@ -0,0 +1,255 @@
+package hpe_ilo_ahs
+
+import (
+	"bytes"
+	"compress/gzip"
+	"encoding/binary"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"git.mchus.pro/mchus/logpile/internal/parser"
+)
+
+func TestDetectAHS(t *testing.T) {
+	p := &Parser{}
+	score := p.Detect([]parser.ExtractedFile{{
+		Path:    "HPE_CZ2D1X0GS3_20260330.ahs",
+		Content: makeAHSArchive(t, []ahsTestEntry{{Name: "CUST_INFO.DAT", Payload: []byte("x")}}),
+	}})
+	if score < 80 {
+		t.Fatalf("expected high confidence detect, got %d", score)
+	}
+}
+
+func TestParseAHSInventory(t *testing.T) {
+	p := &Parser{}
+	content := makeAHSArchive(t, []ahsTestEntry{
+		{Name: "CUST_INFO.DAT", Payload: make([]byte, 16)},
+		{Name: "0000088-2026-03-30.zbb", Payload: gzipBytes(t, []byte(sampleInventoryBlob()))},
+	})
+
+	result, err := p.Parse([]parser.ExtractedFile{{
+		Path:    "HPE_CZ2D1X0GS3_20260330.ahs",
+		Content: content,
+	}})
+	if err != nil {
+		t.Fatalf("parse failed: %v", err)
+	}
+	if result.Hardware == nil {
+		t.Fatalf("expected hardware section")
+	}
+
+	board := result.Hardware.BoardInfo
+	if board.Manufacturer != "HPE" {
+		t.Fatalf("unexpected board manufacturer: %q", board.Manufacturer)
+	}
+	if board.ProductName != "ProLiant DL380 Gen11" {
+		t.Fatalf("unexpected board product: %q", board.ProductName)
+	}
+	if board.SerialNumber != "CZ2D1X0GS3" {
+		t.Fatalf("unexpected board serial: %q", board.SerialNumber)
+	}
+	if board.PartNumber != "P52560-421" {
+		t.Fatalf("unexpected board part number: %q", board.PartNumber)
+	}
+
+	if len(result.Hardware.CPUs) != 1 || result.Hardware.CPUs[0].Model != "Intel(R) Xeon(R) Gold 6444Y" {
+		t.Fatalf("unexpected CPUs: %+v", result.Hardware.CPUs)
+	}
+	if len(result.Hardware.Memory) != 1 {
+		t.Fatalf("expected one DIMM, got %d", len(result.Hardware.Memory))
+	}
+	if result.Hardware.Memory[0].PartNumber != "HMCG88AEBRA115N" {
+		t.Fatalf("unexpected DIMM part number: %q", result.Hardware.Memory[0].PartNumber)
+	}
+
+	if len(result.Hardware.NetworkAdapters) != 2 {
+		t.Fatalf("expected two network adapters, got %d", len(result.Hardware.NetworkAdapters))
+	}
+	if len(result.Hardware.PowerSupply) != 1 {
+		t.Fatalf("expected one PSU, got %d", len(result.Hardware.PowerSupply))
+	}
+	if result.Hardware.PowerSupply[0].SerialNumber != "5XUWB0C4DJG4BV" {
+		t.Fatalf("unexpected PSU serial: %q", result.Hardware.PowerSupply[0].SerialNumber)
+	}
+
+	if len(result.Hardware.Storage) != 1 {
+		t.Fatalf("expected one physical drive, got %d", len(result.Hardware.Storage))
+	}
+	drive := result.Hardware.Storage[0]
+	if drive.Model != "SAMSUNGMZ7L3480HCHQ-00A07" {
+		t.Fatalf("unexpected drive model: %q", drive.Model)
+	}
+	if drive.SerialNumber != "S664NC0Y502720" {
+		t.Fatalf("unexpected drive serial: %q", drive.SerialNumber)
+	}
+	if drive.SizeGB != 480 {
+		t.Fatalf("unexpected drive size: %d", drive.SizeGB)
+	}
+
+	if len(result.Hardware.Firmware) == 0 {
+		t.Fatalf("expected firmware inventory")
+	}
+	foundILO := false
+	foundControllerFW := false
+	for _, item := range result.Hardware.Firmware {
+		if item.DeviceName == "iLO 6" && item.Version == "v1.63p20" {
+			foundILO = true
+		}
+		if item.DeviceName == "HPE MR408i-o Gen11" && item.Version == "52.26.3-5379" {
+			foundControllerFW = true
+		}
+	}
+	if !foundILO {
+		t.Fatalf("expected iLO firmware entry")
+	}
+	if !foundControllerFW {
+		t.Fatalf("expected controller firmware entry")
+	}
+
+	if len(result.Hardware.Devices) < 6 {
+		t.Fatalf("expected canonical devices, got %d", len(result.Hardware.Devices))
+	}
+	if len(result.Events) == 0 {
+		t.Fatalf("expected parsed events")
+	}
+}
+
+func TestParseExampleAHS(t *testing.T) {
+	path := filepath.Join("..", "..", "..", "..", "example", "HPE_CZ2D1X0GS3_20260330.ahs")
+	content, err := os.ReadFile(path)
+	if err != nil {
+		t.Skipf("example fixture unavailable: %v", err)
+	}
+
+	p := &Parser{}
+	result, err := p.Parse([]parser.ExtractedFile{{
+		Path:    filepath.Base(path),
+		Content: content,
+	}})
+	if err != nil {
+		t.Fatalf("parse example failed: %v", err)
+	}
+	if result.Hardware == nil {
+		t.Fatalf("expected hardware section")
+	}
+
+	board := result.Hardware.BoardInfo
+	if board.ProductName != "ProLiant DL380 Gen11" {
+		t.Fatalf("unexpected board product: %q", board.ProductName)
+	}
+	if board.SerialNumber != "CZ2D1X0GS3" {
+		t.Fatalf("unexpected board serial: %q", board.SerialNumber)
+	}
+
+	if len(result.Hardware.Storage) < 2 {
+		t.Fatalf("expected at least two drives, got %d", len(result.Hardware.Storage))
+	}
+
+	foundController := false
+	for _, device := range result.Hardware.Devices {
+		if device.Model == "HPE MR408i-o Gen11" && device.SerialNumber == "PXSFQ0BBIJY3B3" {
+			foundController = true
+			break
+		}
+	}
+	if !foundController {
+		t.Fatalf("expected MR408i-o controller in canonical devices")
+	}
+}
+
+type ahsTestEntry struct {
+	Name    string
+	Payload []byte
+	Flag    uint32
+}
+
+func makeAHSArchive(t *testing.T, entries []ahsTestEntry) []byte {
+	t.Helper()
+
+	var buf bytes.Buffer
+	for _, entry := range entries {
+		header := make([]byte, ahsHeaderSize)
+		copy(header[:4], []byte("ABJR"))
+		binary.LittleEndian.PutUint16(header[4:6], 0x0300)
+		binary.LittleEndian.PutUint16(header[6:8], 0x0002)
+		binary.LittleEndian.PutUint32(header[8:12], uint32(len(entry.Payload)))
+		flag := entry.Flag
+		if flag == 0 {
+			flag = 0x80000002
+			if len(entry.Payload) >= 2 && entry.Payload[0] == 0x1f && entry.Payload[1] == 0x8b {
+				flag = 0x80000001
+			}
+		}
+		binary.LittleEndian.PutUint32(header[16:20], flag)
+		copy(header[20:52], []byte(entry.Name))
+		buf.Write(header)
+		buf.Write(entry.Payload)
+	}
+	return buf.Bytes()
+}
+
+func gzipBytes(t *testing.T, payload []byte) []byte {
+	t.Helper()
+
+	var buf bytes.Buffer
+	zw := gzip.NewWriter(&buf)
+	if _, err := zw.Write(payload); err != nil {
+		t.Fatalf("gzip payload: %v", err)
+	}
+	if err := zw.Close(); err != nil {
+		t.Fatalf("close gzip writer: %v", err)
+	}
+	return buf.Bytes()
+}
+
+func sampleInventoryBlob() string {
+	return stringsJoin(
+		"iLO 6 v1.63p20 built on Sep 13 2024",
+		"HPE",
+		"ProLiant DL380 Gen11",
+		"CZ2D1X0GS3",
+		"P52560-421",
+		"Proc 1",
+		"Intel(R) Corporation",
+		"Intel(R) Xeon(R) Gold 6444Y",
+		"PROC 1 DIMM 3",
+		"Hynix",
+		"HMCG88AEBRA115N",
+		"2B5F92C6",
+		"Power Supply 1",
+		"5XUWB0C4DJG4BV",
+		"P03178-B21",
+		"PciRoot(0x1)/Pci(0x5,0x0)/Pci(0x0,0x0)",
+		"NIC.Slot.1.1",
+		"Network Controller",
+		"Slot 1",
+		"MCX512A-ACAT",
+		"MT2230478382",
+		"PciRoot(0x3)/Pci(0x1,0x0)/Pci(0x0,0x0)",
+		"OCP.Slot.15.1",
+		"Broadcom NetXtreme Gigabit Ethernet - NIC",
+		"OCP Slot 15",
+		"P51183-001",
+		"1CH0150001",
+		"20.28.41",
+		"System ROM",
+		"v2.22 (06/19/2024)",
+		"03/30/2026 09:47:33",
+		"iLO network link down.",
+		`{"@odata.id":"/redfish/v1/Systems/1/Storage/DE00A000/Controllers/0","@odata.type":"#StorageController.v1_7_0.StorageController","Id":"0","Name":"HPE MR408i-o Gen11","FirmwareVersion":"52.26.3-5379","Manufacturer":"HPE","Model":"HPE MR408i-o Gen11","PartNumber":"P58543-001","SKU":"P58335-B21","SerialNumber":"PXSFQ0BBIJY3B3","Status":{"State":"Enabled","Health":"OK"},"Location":{"PartLocation":{"ServiceLabel":"Slot=14","LocationType":"Slot","LocationOrdinalValue":14}},"PCIeInterface":{"PCIeType":"Gen4","LanesInUse":8}}`,
+		`{"@odata.id":"/redfish/v1/Chassis/DE00A000/Drives/0","@odata.type":"#Drive.v1_17_0.Drive","Id":"0","Name":"480GB 6G SATA SSD","Status":{"State":"StandbyOffline","Health":"OK"},"PhysicalLocation":{"PartLocation":{"ServiceLabel":"Slot=14:Port=1:Box=3:Bay=1","LocationType":"Bay","LocationOrdinalValue":1}},"CapacityBytes":480103981056,"MediaType":"SSD","Model":"SAMSUNGMZ7L3480HCHQ-00A07","Protocol":"SATA","Revision":"JXTC604Q","SerialNumber":"S664NC0Y502720","PredictedMediaLifeLeftPercent":100}`,
+		`{"@odata.id":"/redfish/v1/Chassis/DE00A000/Drives/64515","@odata.type":"#Drive.v1_17_0.Drive","Id":"64515","Name":"Empty Bay","Status":{"State":"Absent","Health":"OK"}}`,
+	)
+}
+
+func stringsJoin(parts ...string) string {
+	return string(bytes.Join(func() [][]byte {
+		out := make([][]byte, 0, len(parts))
+		for _, part := range parts {
+			out = append(out, []byte(part))
+		}
+		return out
+	}(), []byte{0}))
+}

internal/parser/vendors/vendors.go

@@ -5,7 +5,9 @@ package vendors
 import (
 	// Import vendor modules to trigger their init() registration
 	_ "git.mchus.pro/mchus/logpile/internal/parser/vendors/dell"
+	_ "git.mchus.pro/mchus/logpile/internal/parser/vendors/easy_bee"
 	_ "git.mchus.pro/mchus/logpile/internal/parser/vendors/h3c"
+	_ "git.mchus.pro/mchus/logpile/internal/parser/vendors/hpe_ilo_ahs"
 	_ "git.mchus.pro/mchus/logpile/internal/parser/vendors/inspur"
 	_ "git.mchus.pro/mchus/logpile/internal/parser/vendors/nvidia"
 	_ "git.mchus.pro/mchus/logpile/internal/parser/vendors/nvidia_bug_report"

internal/server/handlers.go

@@ -13,12 +13,12 @@ import (
 	"net"
 	"net/http"
 	"os"
-	"sync/atomic"
 	"path/filepath"
 	"regexp"
 	"sort"
 	"strconv"
 	"strings"
+	"sync/atomic"
 	"time"
 
 	"git.mchus.pro/mchus/logpile/internal/collector"
@@ -717,6 +717,19 @@ func hasUsableSerial(serial string) bool {
 	}
 }
 
+func hasUsableFirmwareVersion(version string) bool {
+	v := strings.TrimSpace(version)
+	if v == "" {
+		return false
+	}
+	switch strings.ToUpper(v) {
+	case "N/A", "NA", "NONE", "NULL", "UNKNOWN", "-":
+		return false
+	default:
+		return true
+	}
+}
+
 func (s *Server) handleGetFirmware(w http.ResponseWriter, r *http.Request) {
 	result := s.GetResult()
 	if result == nil || result.Hardware == nil {
@@ -944,7 +957,7 @@ func buildFirmwareEntries(hw *models.HardwareConfig) []firmwareEntry {
 		component = strings.TrimSpace(component)
 		model = strings.TrimSpace(model)
 		version = strings.TrimSpace(version)
-		if component == "" || version == "" {
+		if component == "" || !hasUsableFirmwareVersion(version) {
 			return
 		}
 		if model == "" {
@@ -1992,14 +2005,14 @@ func applyCollectSourceMetadata(result *models.AnalysisResult, req CollectReques
 
 func toCollectorRequest(req CollectRequest) collector.Request {
 	return collector.Request{
-		Host:             req.Host,
-		Protocol:         req.Protocol,
-		Port:             req.Port,
-		Username:         req.Username,
-		AuthType:         req.AuthType,
-		Password:         req.Password,
-		Token:            req.Token,
-		TLSMode:          req.TLSMode,
+		Host:                 req.Host,
+		Protocol:             req.Protocol,
+		Port:                 req.Port,
+		Username:             req.Username,
+		AuthType:             req.AuthType,
+		Password:             req.Password,
+		Token:                req.Token,
+		TLSMode:              req.TLSMode,
 		PowerOnIfHostOff:     req.PowerOnIfHostOff,
 		StopHostAfterCollect: req.StopHostAfterCollect,
 		DebugPayloads:        req.DebugPayloads,

internal/server/handlers_firmware_test.go

@@ -62,3 +62,22 @@ func TestBuildFirmwareEntries_IncludesGPUFirmwareFallback(t *testing.T) {
 		t.Fatalf("expected GPU firmware entry from hardware.gpus fallback")
 	}
 }
+
+func TestBuildFirmwareEntries_SkipsPlaceholderVersions(t *testing.T) {
+	hw := &models.HardwareConfig{
+		Firmware: []models.FirmwareInfo{
+			{DeviceName: "BMC", Version: "3.13.42P13"},
+			{DeviceName: "Front_BP_1", Version: "NA"},
+			{DeviceName: "Rear_BP_0", Version: "N/A"},
+			{DeviceName: "HDD_BP", Version: "-"},
+		},
+	}
+
+	entries := buildFirmwareEntries(hw)
+	if len(entries) != 1 {
+		t.Fatalf("expected only usable firmware entries, got %#v", entries)
+	}
+	if entries[0].Component != "BMC" || entries[0].Version != "3.13.42P13" {
+		t.Fatalf("unexpected remaining firmware entry: %#v", entries[0])
+	}
+}

web/templates/index.html

@@ -36,9 +36,9 @@
             <div id="archive-source-content">
                 <div class="upload-area" id="drop-zone">
                     <p>Перетащите архив, TXT/LOG или JSON snapshot сюда</p>
-                    <input type="file" id="file-input" accept="application/gzip,application/x-gzip,application/x-tar,application/zip,application/json,text/plain,.json,.tar,.tar.gz,.tgz,.sds,.zip,.txt,.log" hidden>
+                    <input type="file" id="file-input" accept="application/gzip,application/x-gzip,application/x-tar,application/zip,application/json,text/plain,.ahs,.json,.tar,.tar.gz,.tgz,.sds,.zip,.txt,.log" hidden>
                     <button type="button" onclick="document.getElementById('file-input').click()">Выберите файл</button>
-                    <p class="hint">Поддерживаемые форматы: tar.gz, tar, tgz, sds, zip, json, txt, log</p>
+                    <p class="hint">Поддерживаемые форматы: ahs, tar.gz, tar, tgz, sds, zip, json, txt, log</p>
                 </div>
                 <div id="upload-status"></div>
                 <div id="parsers-info" class="parsers-info"></div>