From d3ae6b558505a20dade749dd6d9ef78d13f88301 Mon Sep 17 00:00:00 2001
From: TheWitness <thewitness@cacti.net>
Date: Sat, 10 Oct 2026 17:27:10 -0400
Subject: [PATCH 1/5] feature(hmib): add Fleet (Summary) Dashboard with
 min/avg/max bullet charts

A dashboard glyph (same icon/first position as the per-device dashboard) on the Summary tab's Device Type rows opens a Fleet Dashboard scoped to all devices or one OS type:

- Draggable add/remove card grid reusing the shared .hmibDash* card chrome, with its own self-contained controller (js/hmib_summary_dashboard.js) so the merged per-device dashboard JS is untouched.
- Cards: Fleet Overview (status + resource stat tiles), Resource Utilization (min/avg/max BULLET CHARTS for CPU/memory/swap/processes), Device Status (stacked bar), Storage Utilization (bullet + capacity), Uptime Distribution (bullet), OS Type Distribution (bars), and Top Processes by CPU and by Memory (sortable, with relative mini-bars).
- Aggregates come from hrSystem/hrStorage/hrSWRun scoped by host_type; utilization stats consider only up/recovering devices so down-device staleness does not skew min/avg/max.
- CSRF AJAX endpoints summary_card/summary_layout/summary_refresh; scope (OS type), card order, expanded state and refresh interval persist per user in settings_user. A stateful 'Fleet Dashboard' tab appears after first use and remembers the last scope.
- Visuals (bullet charts, stat tiles, stacked bar, distribution/mini bars) are theme-adaptive via color-mix; nonce'd inline init + JSON_HEX hardening.
---
 CHANGELOG.md                 |   1 +
 css/hmib.css                 | 199 +++++++++
 hmib.php                     | 768 ++++++++++++++++++++++++++++++++++-
 js/hmib_summary_dashboard.js | 437 ++++++++++++++++++++
 locales/po/cacti.pot         |  98 ++++-
 5 files changed, 1495 insertions(+), 8 deletions(-)
 create mode 100644 js/hmib_summary_dashboard.js

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 88dbb0d..9a14c06 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,7 @@
 ChangeLog
 
 --- develop ---
+* feature: Add a Fleet (Summary) Dashboard reached by a dashboard glyph on the Summary tab's Device Type rows: a draggable, add/remove card grid scoped to all devices or one OS type, with min/avg/max bullet charts (CPU/memory/swap/processes/uptime), a device-status stacked bar, OS type distribution, storage utilization, fleet stat tiles, and top processes by CPU and by memory; scope, card order, expanded state and refresh interval persist per user
 * issue: Fix 'Uncaught TypeError: runCollector(): Argument #2 ($lastrun) must be of type float, null given' in the poller when a collector's *_lastrun/*_freq setting has never been written (e.g. a task's first run); runCollector() now accepts null and normalizes it
 * issue: Fix the per-device Dashboard Storage, Per-Processor Load, Hardware and Installed Software cards rendering empty because they filtered on 'present = 1' while the underlying Storage/Hardware/Inventory tabs never did, and add a Process Use History card
 * feature: Add a per-device Dashboard that drills into a single host with a draggable, add/remove card grid (CPU/memory/swap gauges, per-processor load, storage, top processes, hardware, installed software, logins and system information); card order, expanded state, the selected device and the auto-refresh interval persist per user, and a dashboard glyph on the Devices tab opens a stateful Dashboard tab that remembers the last host opened
diff --git a/css/hmib.css b/css/hmib.css
index ebc4a41..7851d03 100644
--- a/css/hmib.css
+++ b/css/hmib.css
@@ -496,3 +496,202 @@
 		grid-column: 1 / -1;
 	}
 }
+
+/*
+ * Fleet (Summary) Dashboard visuals: min/avg/max bullet charts, stat tiles, a
+ * status stacked bar and in-table mini bars. Theme-adaptive via
+ * color-mix(currentColor ...); severity accents use fixed colours.
+ */
+
+/* Min / avg / max bullet chart. The track is 0..scale; a translucent band spans
+   min..max; a strong marker sits at avg. */
+.hmibBullet {
+	margin: 9px 0;
+}
+
+.hmibBulletHead {
+	display: flex;
+	justify-content: space-between;
+	align-items: baseline;
+	gap: 8px;
+	margin-bottom: 4px;
+}
+
+.hmibBulletLabel {
+	font-size: 12px;
+	font-weight: 600;
+}
+
+.hmibBulletAvg {
+	font-size: 12px;
+	font-variant-numeric: tabular-nums;
+	color: color-mix(in srgb, currentColor 78%, transparent);
+}
+
+.hmibBulletTrack {
+	position: relative;
+	height: 16px;
+	border-radius: 8px;
+	background: color-mix(in srgb, currentColor 12%, transparent);
+	overflow: hidden;
+}
+
+.hmibBulletRange {
+	position: absolute;
+	top: 0;
+	bottom: 0;
+	border-radius: 8px;
+}
+
+.hmibBulletRange--up         { background: color-mix(in srgb, #3c9a5f 55%, transparent); }
+.hmibBulletRange--recovering { background: color-mix(in srgb, #d9830f 55%, transparent); }
+.hmibBulletRange--down       { background: color-mix(in srgb, #cc0000 55%, transparent); }
+.hmibBulletRange--none       { background: color-mix(in srgb, currentColor 32%, transparent); }
+
+.hmibBulletMarker {
+	position: absolute;
+	top: -2px;
+	bottom: -2px;
+	width: 3px;
+	transform: translateX(-1px);
+	background: currentColor;
+	border-radius: 2px;
+}
+
+.hmibBulletScale {
+	display: flex;
+	justify-content: space-between;
+	margin-top: 2px;
+	font-size: 10px;
+	font-variant-numeric: tabular-nums;
+	color: color-mix(in srgb, currentColor 60%, transparent);
+}
+
+/* Stat tiles for the fleet overview. */
+.hmibFleetTiles {
+	display: grid;
+	grid-template-columns: repeat(auto-fit, minmax(96px, 1fr));
+	gap: 8px;
+}
+
+.hmibFleetTile {
+	display: flex;
+	flex-direction: column;
+	align-items: center;
+	gap: 2px;
+	padding: 8px 6px;
+	border-radius: 7px;
+	border: 1px solid color-mix(in srgb, currentColor 14%, transparent);
+	background: color-mix(in srgb, currentColor 4%, transparent);
+}
+
+.hmibFleetTileValue {
+	font-size: 22px;
+	font-weight: 700;
+	line-height: 1;
+	font-variant-numeric: tabular-nums;
+}
+
+.hmibFleetTileLabel {
+	font-size: 11px;
+	text-align: center;
+	color: color-mix(in srgb, currentColor 70%, transparent);
+}
+
+.hmibFleetTile--up    { border-color: color-mix(in srgb, #3c9a5f 55%, transparent); }
+.hmibFleetTile--rec   { border-color: color-mix(in srgb, #d9830f 55%, transparent); }
+.hmibFleetTile--down  { border-color: color-mix(in srgb, #cc0000 55%, transparent); }
+.hmibFleetTile--up .hmibFleetTileValue    { color: #3c9a5f; }
+.hmibFleetTile--rec .hmibFleetTileValue   { color: #d9830f; }
+.hmibFleetTile--down .hmibFleetTileValue  { color: #cc0000; }
+
+/* Horizontal status stacked bar (up / recovering / down / disabled). */
+.hmibStackBar {
+	display: flex;
+	height: 20px;
+	border-radius: 6px;
+	overflow: hidden;
+	background: color-mix(in srgb, currentColor 12%, transparent);
+}
+
+.hmibStackSeg {
+	height: 100%;
+}
+
+.hmibStackSeg--up    { background: #3c9a5f; }
+.hmibStackSeg--rec   { background: #d9830f; }
+.hmibStackSeg--down  { background: #cc0000; }
+.hmibStackSeg--dis   { background: color-mix(in srgb, currentColor 35%, transparent); }
+
+.hmibStackLegend {
+	display: flex;
+	flex-wrap: wrap;
+	gap: 10px;
+	margin-top: 8px;
+	font-size: 11px;
+}
+
+.hmibStackLegend span {
+	display: inline-flex;
+	align-items: center;
+	gap: 5px;
+}
+
+.hmibStackChip {
+	width: 10px;
+	height: 10px;
+	border-radius: 2px;
+	display: inline-block;
+}
+
+/* Horizontal distribution bars (OS type counts) and in-table mini bars. */
+.hmibDistRow {
+	display: grid;
+	grid-template-columns: minmax(80px, 34%) 1fr auto;
+	align-items: center;
+	gap: 8px;
+	margin: 6px 0;
+	font-size: 12px;
+}
+
+.hmibDistLabel {
+	overflow: hidden;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+}
+
+.hmibDistTrack {
+	height: 12px;
+	border-radius: 6px;
+	background: color-mix(in srgb, currentColor 12%, transparent);
+	overflow: hidden;
+}
+
+.hmibDistFill {
+	height: 100%;
+	border-radius: 6px;
+	background: color-mix(in srgb, currentColor 45%, transparent);
+}
+
+.hmibDistValue {
+	font-variant-numeric: tabular-nums;
+	color: color-mix(in srgb, currentColor 80%, transparent);
+}
+
+.hmibMiniBar {
+	position: relative;
+	height: 10px;
+	min-width: 60px;
+	border-radius: 5px;
+	background: color-mix(in srgb, currentColor 12%, transparent);
+	overflow: hidden;
+}
+
+.hmibMiniBarFill {
+	position: absolute;
+	top: 0;
+	left: 0;
+	bottom: 0;
+	border-radius: 5px;
+	background: color-mix(in srgb, currentColor 45%, transparent);
+}
diff --git a/hmib.php b/hmib.php
index c49cf8a..235e666 100644
--- a/hmib.php
+++ b/hmib.php
@@ -81,6 +81,24 @@
 	exit;
 }
 
+if (get_request_var('action') == 'summary_card') {
+	header('Content-Type: application/json; charset=UTF-8');
+	print hmib_summary_card_ajax();
+	exit;
+}
+
+if (get_request_var('action') == 'summary_layout') {
+	header('Content-Type: application/json; charset=UTF-8');
+	print hmib_summary_layout_save();
+	exit;
+}
+
+if (get_request_var('action') == 'summary_refresh') {
+	header('Content-Type: application/json; charset=UTF-8');
+	print hmib_summary_refresh_save();
+	exit;
+}
+
 general_header();
 
 // Load this plugin's per-theme glyph styling: base rules plus the active
@@ -126,6 +144,10 @@
 	case 'dashboard':
 		hmib_dashboard();
 
+		break;
+	case 'summary_dashboard':
+		hmib_summary_dashboard();
+
 		break;
 	case 'history':
 		hmib_history();
@@ -2914,14 +2936,27 @@ function hmib_tabs(): void {
 	// set the default tab
 	$current_tab = get_request_var('action');
 
-	// The stateful per-device Dashboard tab only appears once a device has been
-	// opened from the Devices tab (it remembers the last device viewed).
-	if ($current_tab == 'dashboard' || (int) read_user_setting('hmib_dashboard_host', 0) > 0) {
-		$tabs = array_slice($tabs, 0, 2, true)
-			+ ['dashboard' => __esc('Dashboard', 'hmib')]
-			+ array_slice($tabs, 2, null, true);
+	// The stateful Dashboard tabs only appear once opened from their glyph: the
+	// Fleet Dashboard from the Summary tab, the per-device Dashboard from Devices.
+	$show_fleet  = ($current_tab == 'summary_dashboard' || read_user_setting('hmib_summary_type', '') !== '');
+	$show_device = ($current_tab == 'dashboard' || (int) read_user_setting('hmib_dashboard_host', 0) > 0);
+
+	$ordered = [];
+
+	foreach ($tabs as $tab_key => $tab_label) {
+		$ordered[$tab_key] = $tab_label;
+
+		if ($tab_key == 'summary' && $show_fleet) {
+			$ordered['summary_dashboard'] = __esc('Fleet Dashboard', 'hmib');
+		}
+
+		if ($tab_key == 'devices' && $show_device) {
+			$ordered['dashboard'] = __esc('Dashboard', 'hmib');
+		}
 	}
 
+	$tabs = $ordered;
+
 	// draw the tabs
 	print "<div class='tabs'><nav><ul>";
 
@@ -3311,7 +3346,9 @@ function clearHostFilter() {
 			$graph_aproc = hmib_get_graph_template_url($hpgt, $row['id'], 0, number_format_i18n($row['avgProcesses'], 0), false);
 			$graph_mproc = hmib_get_graph_template_url($hpgt, $row['id'], 0, number_format_i18n($row['maxProcesses'], 0), false);
 
-			$aurl  = "<a class='pic' href='" . html_escape("$url?reset=1&action=devices&ostype=" . $row['host_type']) . "'><i class='fas fa-server deviceUp' title='" . __('View Devices', 'hmib') . "'></i></a>";
+			$aurl  = "<a class='pic' href='" . html_escape("$url?action=summary_dashboard&reset=1&ostype=" . $row['host_type']) . "'><i class='fas fa-tachometer-alt hmibDashboard' title='" . __('View Fleet Dashboard', 'hmib') . "'></i></a>";
+
+			$aurl .= "<a class='pic' href='" . html_escape("$url?reset=1&action=devices&ostype=" . $row['host_type']) . "'><i class='fas fa-server deviceUp' title='" . __('View Devices', 'hmib') . "'></i></a>";
 
 			$aurl .= "<a class='pic' href='" . html_escape("$url?reset=1&action=storage&ostype=" . $row['host_type']) . "'><i class='fas fa-database' title='" . __('View Storage', 'hmib') . "'></i></a>";
 
@@ -4748,3 +4785,720 @@ function hmib_dashboard(): void {
 	// JSON_HEX_* prevents a card title from breaking out of the inline <script>.
 	print '<script type="text/javascript" ' . plugin_hmib_csp_nonce() . '>var hmibDashCatalog = ' . json_encode($catalog, JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT) . '; initHmibDashboard();</script>';
 }
+
+/**
+ * Resolve the OS type the Fleet (Summary) Dashboard should scope to. A validated
+ * 'ostype' request variable wins and is remembered; 0 means "all types". Falls
+ * back to the remembered type, or 0.
+ *
+ * @return int The OS type id (host_type), or 0 for all types.
+ */
+function hmib_summary_resolve_type(): int {
+	$ostype = -1;
+
+	if (isset_request_var('ostype')) {
+		$candidate = get_nfilter_request_var('ostype');
+
+		if (preg_match('/^[0-9]+$/', (string) $candidate)) {
+			$ostype = (int) $candidate;
+
+			if ((string) read_user_setting('hmib_summary_type', '') !== (string) $ostype) {
+				set_user_setting('hmib_summary_type', $ostype);
+			}
+		}
+	}
+
+	if ($ostype < 0) {
+		$stored = read_user_setting('hmib_summary_type', '');
+		$ostype = ($stored !== '' && preg_match('/^[0-9]+$/', (string) $stored)) ? (int) $stored : 0;
+	}
+
+	return $ostype;
+}
+
+/**
+ * Memoized fleet system aggregates for an OS type scope (0 = all types). The
+ * utilization statistics (cpu/mem/swap/processes/uptime) consider only up or
+ * recovering devices so stale values from down devices do not skew them.
+ *
+ * @param int $ostype The host_type to scope to, or 0 for all types.
+ *
+ * @return array The aggregate row.
+ */
+function hmib_summary_stats(int $ostype): array {
+	static $cache = [];
+
+	if (!array_key_exists($ostype, $cache)) {
+		$where  = $ostype > 0 ? 'WHERE hrs.host_type = ?' : '';
+		$params = $ostype > 0 ? [$ostype] : [];
+
+		$row = db_fetch_row_prepared("SELECT
+			COUNT(*) AS devices,
+			SUM(host_status = 3) AS up,
+			SUM(host_status = 2) AS recovering,
+			SUM(host_status = 1) AS down,
+			SUM(host_status = 0) AS disabled,
+			SUM(numCpus) AS cpus,
+			SUM(users) AS users,
+			SUM(processes) AS processes,
+			SUM(memSize) AS memTotal,
+			MIN(CASE WHEN host_status >= 2 THEN cpuPercent END) AS minCpu,
+			AVG(CASE WHEN host_status >= 2 THEN cpuPercent END) AS avgCpu,
+			MAX(CASE WHEN host_status >= 2 THEN cpuPercent END) AS maxCpu,
+			MIN(CASE WHEN host_status >= 2 THEN memUsed END) AS minMem,
+			AVG(CASE WHEN host_status >= 2 THEN memUsed END) AS avgMem,
+			MAX(CASE WHEN host_status >= 2 THEN memUsed END) AS maxMem,
+			MIN(CASE WHEN host_status >= 2 AND swapSize > 0 THEN swapUsed END) AS minSwap,
+			AVG(CASE WHEN host_status >= 2 AND swapSize > 0 THEN swapUsed END) AS avgSwap,
+			MAX(CASE WHEN host_status >= 2 AND swapSize > 0 THEN swapUsed END) AS maxSwap,
+			MIN(CASE WHEN host_status >= 2 THEN processes END) AS minProc,
+			AVG(CASE WHEN host_status >= 2 THEN processes END) AS avgProc,
+			MAX(CASE WHEN host_status >= 2 THEN processes END) AS maxProc,
+			MIN(CASE WHEN host_status >= 2 THEN uptime END) AS minUptime,
+			AVG(CASE WHEN host_status >= 2 THEN uptime END) AS avgUptime,
+			MAX(CASE WHEN host_status >= 2 THEN uptime END) AS maxUptime
+			FROM plugin_hmib_hrSystem AS hrs
+			$where", $params);
+
+		$cache[$ostype] = is_array($row) ? $row : [];
+	}
+
+	return $cache[$ostype];
+}
+
+/**
+ * Memoized fleet storage aggregates (per-volume used% distribution and total
+ * capacity) for an OS type scope.
+ *
+ * @param int $ostype The host_type to scope to, or 0 for all types.
+ *
+ * @return array The aggregate row.
+ */
+function hmib_summary_storage_stats(int $ostype): array {
+	static $cache = [];
+
+	if (!array_key_exists($ostype, $cache)) {
+		$where  = $ostype > 0 ? 'AND hrs.host_type = ?' : '';
+		$params = $ostype > 0 ? [$ostype] : [];
+
+		$row = db_fetch_row_prepared("SELECT
+			MIN(pct) AS minPct, AVG(pct) AS avgPct, MAX(pct) AS maxPct,
+			SUM(total) AS totalBytes, SUM(usedBytes) AS usedBytes, COUNT(*) AS volumes
+			FROM (
+				SELECT (hrsto.used / hrsto.size) * 100 AS pct,
+					hrsto.size * hrsto.allocationUnits AS total,
+					hrsto.used * hrsto.allocationUnits AS usedBytes
+				FROM plugin_hmib_hrStorage AS hrsto
+				INNER JOIN plugin_hmib_hrSystem AS hrs ON hrs.host_id = hrsto.host_id
+				WHERE hrsto.size > 0 AND hrsto.description != '' $where
+			) AS v", $params);
+
+		$cache[$ostype] = is_array($row) ? $row : [];
+	}
+
+	return $cache[$ostype];
+}
+
+/**
+ * The Fleet Dashboard card registry: title, column span (out of 8) and whether
+ * the card clips with a "show more" control.
+ *
+ * @return array<string, array{title: string, span: int, expandable: bool}>
+ */
+function hmib_summary_card_meta(): array {
+	return [
+		'overview'    => ['title' => __('Fleet Overview', 'hmib'),            'span' => 4, 'expandable' => false],
+		'utilization' => ['title' => __('Resource Utilization', 'hmib'),      'span' => 4, 'expandable' => false],
+		'status'      => ['title' => __('Device Status', 'hmib'),             'span' => 2, 'expandable' => false],
+		'storage'     => ['title' => __('Storage Utilization', 'hmib'),       'span' => 2, 'expandable' => false],
+		'uptime'      => ['title' => __('Uptime Distribution', 'hmib'),       'span' => 2, 'expandable' => false],
+		'ostypes'     => ['title' => __('OS Type Distribution', 'hmib'),      'span' => 4, 'expandable' => true],
+		'top_cpu'     => ['title' => __('Top Processes by CPU', 'hmib'),      'span' => 4, 'expandable' => true],
+		'top_memory'  => ['title' => __('Top Processes by Memory', 'hmib'),   'span' => 4, 'expandable' => true],
+	];
+}
+
+/**
+ * The Fleet Dashboard card keys available in this scope, in default order.
+ *
+ * @param int $ostype The host_type scope (reserved for future per-scope rules).
+ *
+ * @return string[]
+ */
+function hmib_summary_available_cards(int $ostype): array {
+	return array_keys(hmib_summary_card_meta());
+}
+
+/**
+ * Render a min/avg/max bullet chart: a 0..scale track, a translucent band from
+ * min to max, and a strong marker at the average.
+ *
+ * @param string     $label    The metric label.
+ * @param float|null $min      The minimum value, or null when unavailable.
+ * @param float|null $avg      The average value, or null when unavailable.
+ * @param float|null $max      The maximum value, or null when unavailable.
+ * @param float      $scale    The axis maximum (full-width value).
+ * @param string     $severity 'up'/'recovering'/'down' to tint the band, else '' (neutral).
+ * @param string     $format   'percent', 'number' or 'uptime' value formatting.
+ *
+ * @return string The bullet HTML.
+ */
+function hmib_summary_bullet(string $label, ?float $min, ?float $avg, ?float $max, float $scale, string $severity, string $format): string {
+	$fmt = function(?float $value) use ($format): string {
+		if ($value === null) {
+			return __('N/A', 'hmib');
+		}
+
+		switch ($format) {
+			case 'percent':
+				return number_format_i18n($value, 1) . '%';
+			case 'uptime':
+				return hmib_dashboard_format_uptime((int) $value);
+			default:
+				return number_format_i18n($value, 0);
+		}
+	};
+
+	$head = '<div class="hmibBulletHead"><span class="hmibBulletLabel">' . html_escape($label) . '</span><span class="hmibBulletAvg">' . html_escape($fmt($avg)) . '</span></div>';
+
+	if ($avg === null || $scale <= 0) {
+		return '<div class="hmibBullet">' . $head . '<div class="hmibBulletTrack"></div></div>';
+	}
+
+	$lo = max(0.0, min($scale, (float) ($min ?? $avg)));
+	$hi = max(0.0, min($scale, (float) ($max ?? $avg)));
+	$av = max(0.0, min($scale, (float) $avg));
+
+	$left  = $lo / $scale * 100;
+	$width = max(0.75, ($hi - $lo) / $scale * 100);
+	$mark  = $av / $scale * 100;
+
+	$sev = in_array($severity, ['up', 'recovering', 'down'], true) ? $severity : 'none';
+
+	return '<div class="hmibBullet">' . $head
+		. '<div class="hmibBulletTrack">'
+		. '<div class="hmibBulletRange hmibBulletRange--' . $sev . '" style="left:' . number_format($left, 2, '.', '') . '%;width:' . number_format($width, 2, '.', '') . '%"></div>'
+		. '<div class="hmibBulletMarker" style="left:' . number_format($mark, 2, '.', '') . '%"></div>'
+		. '</div>'
+		. '<div class="hmibBulletScale"><span>' . html_escape($fmt($min)) . '</span><span>' . html_escape($fmt($max)) . '</span></div>'
+		. '</div>';
+}
+
+/**
+ * The header severity accent for a Fleet Dashboard card, or '' for neutral.
+ *
+ * @param string $key    The card identifier.
+ * @param int    $ostype The host_type scope.
+ *
+ * @return string One of 'up', 'recovering', 'down' or ''.
+ */
+function hmib_summary_card_state(string $key, int $ostype): string {
+	$stats = hmib_summary_stats($ostype);
+
+	if (!cacti_sizeof($stats)) {
+		return '';
+	}
+
+	switch ($key) {
+		case 'utilization':
+			return $stats['avgCpu'] !== null ? hmib_dashboard_severity((float) $stats['avgCpu']) : '';
+		case 'storage':
+			$storage = hmib_summary_storage_stats($ostype);
+
+			return isset($storage['avgPct']) && $storage['avgPct'] !== null ? hmib_dashboard_severity((float) $storage['avgPct']) : '';
+		case 'status':
+			if ((int) $stats['down'] > 0) {
+				return 'down';
+			}
+
+			if ((int) $stats['recovering'] > 0) {
+				return 'recovering';
+			}
+
+			return (int) $stats['up'] > 0 ? 'up' : '';
+	}
+
+	return '';
+}
+
+/**
+ * Render the inner body HTML of a single Fleet Dashboard card.
+ *
+ * @param string $key    The card identifier.
+ * @param int    $ostype The host_type scope (0 = all types).
+ *
+ * @return string The card body HTML.
+ */
+function hmib_summary_card_body(string $key, int $ostype): string {
+	$stats = hmib_summary_stats($ostype);
+
+	ob_start();
+
+	if (!cacti_sizeof($stats) || (int) $stats['devices'] === 0) {
+		print '<p class="hmibDashEmpty">' . __esc('No Host MIB devices in this scope yet.', 'hmib') . '</p>';
+
+		return (string) ob_get_clean();
+	}
+
+	switch ($key) {
+		case 'overview':
+			$tiles = [
+				['', number_format_i18n((int) $stats['devices'], 0), __('Devices', 'hmib')],
+				['up', number_format_i18n((int) $stats['up'], 0), __('Up', 'hmib')],
+				['rec', number_format_i18n((int) $stats['recovering'], 0), __('Recovering', 'hmib')],
+				['down', number_format_i18n((int) $stats['down'], 0), __('Down', 'hmib')],
+				['', number_format_i18n((int) $stats['disabled'], 0), __('Disabled', 'hmib')],
+				['', number_format_i18n((int) $stats['cpus'], 0), __('CPUs', 'hmib')],
+				['', number_format_i18n((int) $stats['users'], 0), __('Logins', 'hmib')],
+				['', number_format_i18n((int) $stats['processes'], 0), __('Processes', 'hmib')],
+				['', hmib_memory((float) $stats['memTotal']), __('Total RAM', 'hmib')]
+			];
+
+			print '<div class="hmibFleetTiles">';
+			foreach ($tiles as $tile) {
+				$mod = $tile[0] !== '' ? ' hmibFleetTile--' . $tile[0] : '';
+				print '<div class="hmibFleetTile' . $mod . '"><span class="hmibFleetTileValue">' . html_escape($tile[1]) . '</span><span class="hmibFleetTileLabel">' . html_escape($tile[2]) . '</span></div>';
+			}
+			print '</div>';
+
+			break;
+		case 'utilization':
+			$cpuSev = $stats['avgCpu'] !== null ? hmib_dashboard_severity((float) $stats['avgCpu']) : 'none';
+			$memSev = $stats['avgMem'] !== null ? hmib_dashboard_severity((float) $stats['avgMem']) : 'none';
+			$swSev  = $stats['avgSwap'] !== null ? hmib_dashboard_severity((float) $stats['avgSwap']) : 'none';
+
+			print hmib_summary_bullet(__('CPU %', 'hmib'), $stats['minCpu'], $stats['avgCpu'], $stats['maxCpu'], 100.0, $cpuSev, 'percent');
+			print hmib_summary_bullet(__('Memory %', 'hmib'), $stats['minMem'], $stats['avgMem'], $stats['maxMem'], 100.0, $memSev, 'percent');
+
+			if ($stats['avgSwap'] !== null) {
+				print hmib_summary_bullet(__('Swap %', 'hmib'), $stats['minSwap'], $stats['avgSwap'], $stats['maxSwap'], 100.0, $swSev, 'percent');
+			}
+
+			$procScale = max(1.0, (float) ($stats['maxProc'] ?? 1));
+			print hmib_summary_bullet(__('Processes / host', 'hmib'), $stats['minProc'], $stats['avgProc'], $stats['maxProc'], $procScale, 'none', 'number');
+
+			break;
+		case 'status':
+			$total = max(1, (int) $stats['devices']);
+			$segs  = [
+				['up', (int) $stats['up'], __('Up', 'hmib')],
+				['rec', (int) $stats['recovering'], __('Recovering', 'hmib')],
+				['down', (int) $stats['down'], __('Down', 'hmib')],
+				['dis', (int) $stats['disabled'], __('Disabled', 'hmib')]
+			];
+
+			print '<div class="hmibStackBar">';
+			foreach ($segs as $seg) {
+				if ($seg[1] > 0) {
+					print '<div class="hmibStackSeg hmibStackSeg--' . $seg[0] . '" style="width:' . number_format($seg[1] / $total * 100, 2, '.', '') . '%" title="' . html_escape($seg[2] . ': ' . $seg[1]) . '"></div>';
+				}
+			}
+			print '</div>';
+
+			print '<div class="hmibStackLegend">';
+			foreach ($segs as $seg) {
+				print '<span><span class="hmibStackChip hmibStackSeg--' . $seg[0] . '"></span>' . html_escape($seg[2]) . ' ' . number_format_i18n($seg[1], 0) . '</span>';
+			}
+			print '</div>';
+
+			break;
+		case 'storage':
+			$storage = hmib_summary_storage_stats($ostype);
+
+			if (!cacti_sizeof($storage) || (int) $storage['volumes'] === 0) {
+				print '<p class="hmibDashEmpty">' . __esc('No storage volumes detected in this scope.', 'hmib') . '</p>';
+
+				break;
+			}
+
+			$stoSev = $storage['avgPct'] !== null ? hmib_dashboard_severity((float) $storage['avgPct']) : 'none';
+			print hmib_summary_bullet(__('Used %', 'hmib'), $storage['minPct'], $storage['avgPct'], $storage['maxPct'], 100.0, $stoSev, 'percent');
+
+			print '<table class="hmibDashTable hmibDashKv"><tbody>';
+			print '<tr><th>' . __esc('Volumes', 'hmib') . '</th><td>' . number_format_i18n((int) $storage['volumes'], 0) . '</td></tr>';
+			print '<tr><th>' . __esc('Total Capacity', 'hmib') . '</th><td>' . html_escape(hmib_memory((float) $storage['totalBytes'])) . '</td></tr>';
+			print '<tr><th>' . __esc('Used', 'hmib') . '</th><td>' . html_escape(hmib_memory((float) $storage['usedBytes'])) . '</td></tr>';
+			print '</tbody></table>';
+
+			break;
+		case 'uptime':
+			$upScale = max(1.0, (float) ($stats['maxUptime'] ?? 1));
+			print hmib_summary_bullet(__('Uptime', 'hmib'), $stats['minUptime'], $stats['avgUptime'], $stats['maxUptime'], $upScale, 'none', 'uptime');
+
+			break;
+		case 'ostypes':
+			$types = db_fetch_assoc("SELECT
+				CONCAT_WS('', IF(hrst.name = '' OR hrst.name IS NULL, '" . __('Unknown', 'hmib') . "', hrst.name), IF(hrst.version = '' OR hrst.version IS NULL, '', CONCAT(' ', hrst.version))) AS name,
+				COUNT(*) AS devices
+				FROM plugin_hmib_hrSystem AS hrs
+				LEFT JOIN plugin_hmib_hrSystemTypes AS hrst ON hrs.host_type = hrst.id
+				GROUP BY hrs.host_type
+				ORDER BY devices DESC
+				LIMIT 15");
+
+			if (!cacti_sizeof($types)) {
+				print '<p class="hmibDashEmpty">' . __esc('No OS types recorded.', 'hmib') . '</p>';
+
+				break;
+			}
+
+			$peak = 1;
+			foreach ($types as $type) {
+				$peak = max($peak, (int) $type['devices']);
+			}
+
+			foreach ($types as $type) {
+				$width = (int) $type['devices'] / $peak * 100;
+				print '<div class="hmibDistRow">'
+					. '<span class="hmibDistLabel" title="' . html_escape($type['name']) . '">' . html_escape($type['name']) . '</span>'
+					. '<span class="hmibDistTrack"><span class="hmibDistFill" style="width:' . number_format($width, 2, '.', '') . '%"></span></span>'
+					. '<span class="hmibDistValue">' . number_format_i18n((int) $type['devices'], 0) . '</span>'
+					. '</div>';
+			}
+
+			break;
+		case 'top_cpu':
+		case 'top_memory':
+			$by_cpu = ($key === 'top_cpu');
+			$where  = $ostype > 0 ? 'AND hrs.host_type = ?' : '';
+			$join   = $ostype > 0 ? 'INNER JOIN plugin_hmib_hrSystem AS hrs ON hrs.host_id = hrswr.host_id' : '';
+			$params = $ostype > 0 ? [$ostype] : [];
+
+			$processes = db_fetch_assoc_prepared("SELECT hrswr.name AS name,
+				COUNT(DISTINCT hrswr.host_id) AS hosts,
+				AVG(hrswr.perfCPU) AS avgCpu, MAX(hrswr.perfCPU) AS maxCpu,
+				AVG(hrswr.perfMemory) AS avgMem, MAX(hrswr.perfMemory) AS maxMem
+				FROM plugin_hmib_hrSWRun AS hrswr
+				$join
+				WHERE hrswr.name != '' AND hrswr.name != 'System Idle Process' $where
+				GROUP BY hrswr.name
+				ORDER BY " . ($by_cpu ? 'maxCpu' : 'maxMem') . " DESC
+				LIMIT 15", $params);
+
+			$metric_head = $by_cpu ? __esc('Max CPU (s)', 'hmib') : __esc('Max Memory', 'hmib');
+
+			print '<table class="hmibDashTable"><thead><tr>'
+				. '<th class="hmibDashSortable">' . __esc('Process', 'hmib') . '</th>'
+				. '<th class="hmibDashSortable hmibDashNum" data-sort="num">' . __esc('Hosts', 'hmib') . '</th>'
+				. '<th class="hmibDashSortable hmibDashNum" data-sort="num">' . $metric_head . '</th>'
+				. '<th>' . __esc('Relative', 'hmib') . '</th>'
+				. '</tr></thead><tbody>';
+
+			if (cacti_sizeof($processes)) {
+				$peak = 1.0;
+				foreach ($processes as $process) {
+					$peak = max($peak, (float) ($by_cpu ? $process['maxCpu'] : $process['maxMem']));
+				}
+
+				foreach ($processes as $process) {
+					if ($by_cpu) {
+						$raw     = (float) $process['maxCpu'];
+						$display = number_format_i18n($raw / 100, 0);
+					} else {
+						$raw     = (float) $process['maxMem'];
+						$display = hmib_memory($raw * 1024);
+					}
+
+					$width = $raw / $peak * 100;
+
+					print '<tr>'
+						. '<td>' . html_escape($process['name']) . '</td>'
+						. '<td class="hmibDashNum" data-sort-value="' . (int) $process['hosts'] . '">' . number_format_i18n((int) $process['hosts'], 0) . '</td>'
+						. '<td class="hmibDashNum" data-sort-value="' . $raw . '">' . html_escape($display) . '</td>'
+						. '<td><span class="hmibMiniBar"><span class="hmibMiniBarFill" style="width:' . number_format($width, 2, '.', '') . '%"></span></span></td>'
+						. '</tr>';
+				}
+			} else {
+				print '<tr class="hmibDashEmptyRow"><td colspan="4" class="hmibDashEmpty">' . __esc('No process statistics recorded.', 'hmib') . '</td></tr>';
+			}
+
+			print '</tbody></table>';
+
+			break;
+	}
+
+	return (string) ob_get_clean();
+}
+
+/**
+ * Render a complete Fleet Dashboard card (section, header toolbar and body).
+ *
+ * @param string $key      The card identifier.
+ * @param int    $ostype   The host_type scope.
+ * @param bool   $expanded Whether the card opens expanded.
+ *
+ * @return string The card HTML, or '' for an unknown key.
+ */
+function hmib_summary_render_card(string $key, int $ostype, bool $expanded = false): string {
+	$meta = hmib_summary_card_meta();
+
+	if (!isset($meta[$key])) {
+		return '';
+	}
+
+	$def = $meta[$key];
+
+	$tools = '';
+
+	if ($def['expandable']) {
+		$tools .= '<button type="button" class="hmibDashCardTool" data-tool="expand" aria-label="' . __esc('Show more', 'hmib') . '" title="' . __esc('Show more', 'hmib') . '"><i class="fas fa-chevron-down" aria-hidden="true"></i></button>';
+		$tools .= '<button type="button" class="hmibDashCardTool" data-tool="collapse" aria-label="' . __esc('Show less', 'hmib') . '" title="' . __esc('Show less', 'hmib') . '"><i class="fas fa-chevron-up" aria-hidden="true"></i></button>';
+	}
+
+	$tools .= '<button type="button" class="hmibDashCardTool" data-tool="maximize" aria-label="' . __esc('Open in a dialog', 'hmib') . '" title="' . __esc('Open in a dialog', 'hmib') . '"><i class="fas fa-window-maximize" aria-hidden="true"></i></button>';
+	$tools .= '<button type="button" class="hmibDashCardTool" data-tool="refresh" aria-label="' . __esc('Refresh', 'hmib') . '" title="' . __esc('Refresh', 'hmib') . '"><i class="fas fa-sync-alt" aria-hidden="true"></i></button>';
+	$tools .= '<button type="button" class="hmibDashCardTool" data-tool="remove" aria-label="' . __esc('Remove from page', 'hmib') . '" title="' . __esc('Remove from page', 'hmib') . '"><i class="fas fa-times" aria-hidden="true"></i></button>';
+
+	$classes = 'hmibDashCard hmibDashSpan' . (int) $def['span'];
+
+	if ($def['expandable']) {
+		$classes .= ' hmibDashCardExpandable';
+	}
+
+	if ($expanded) {
+		$classes .= ' hmibDashCardExpanded';
+	}
+
+	$state = hmib_summary_card_state($key, $ostype);
+	$header_class = 'hmibDashCardHeader' . ($state !== '' ? ' hmibDashCardHeader--' . $state : '');
+
+	return '<section class="' . $classes . '" data-card="' . html_escape($key) . '">'
+		. '<header class="' . $header_class . '">'
+		. '<button type="button" class="hmibDashCardDrag" aria-label="' . __esc('Drag to reorder card', 'hmib') . '"><i class="fas fa-bars" aria-hidden="true"></i></button>'
+		. '<h2 class="hmibDashCardTitle">' . html_escape($def['title']) . '</h2>'
+		. '<span class="hmibDashCardTools">' . $tools . '</span>'
+		. '</header>'
+		. '<div class="hmibDashCardBody">' . hmib_summary_card_body($key, $ostype) . '</div>'
+		. '</section>';
+}
+
+/**
+ * The current user's Fleet Dashboard layout (present cards in order + expanded
+ * state); defaults to every card in registry order.
+ *
+ * @param int $ostype The host_type scope.
+ *
+ * @return array{order: string[], expanded: array<string, bool>}
+ */
+function hmib_summary_layout(int $ostype): array {
+	$available = hmib_summary_available_cards($ostype);
+	$saved     = json_decode((string) read_user_setting('hmib_summary_layout', '', true), true);
+
+	if (!is_array($saved) || !isset($saved['order']) || !is_array($saved['order'])) {
+		return ['order' => $available, 'expanded' => []];
+	}
+
+	$order = [];
+
+	foreach ($saved['order'] as $key) {
+		if (is_string($key) && in_array($key, $available, true) && !in_array($key, $order, true)) {
+			$order[] = $key;
+		}
+	}
+
+	$expanded = [];
+
+	if (isset($saved['expanded']) && is_array($saved['expanded'])) {
+		foreach ($saved['expanded'] as $key => $on) {
+			if ($on && in_array($key, $available, true)) {
+				$expanded[(string) $key] = true;
+			}
+		}
+	}
+
+	return ['order' => $order, 'expanded' => $expanded];
+}
+
+/**
+ * Persist the posted Fleet Dashboard layout for the current user.
+ *
+ * @return string A JSON status document.
+ */
+function hmib_summary_layout_save(): string {
+	if ($_SERVER['REQUEST_METHOD'] !== 'POST' || !function_exists('csrf_check') || !csrf_check(false)) {
+		return (string) json_encode(['error' => __('Invalid request. Please try again.', 'hmib')]);
+	}
+
+	$available = hmib_summary_available_cards(0);
+	$posted    = json_decode(isset_request_var('layout') ? (string) get_nfilter_request_var('layout') : '', true);
+
+	$order    = [];
+	$expanded = [];
+
+	if (is_array($posted)) {
+		if (isset($posted['order']) && is_array($posted['order'])) {
+			foreach ($posted['order'] as $key) {
+				if (is_string($key) && in_array($key, $available, true) && !in_array($key, $order, true)) {
+					$order[] = $key;
+				}
+			}
+		}
+
+		if (isset($posted['expanded']) && is_array($posted['expanded'])) {
+			foreach ($posted['expanded'] as $key => $on) {
+				if ($on && is_string($key) && in_array($key, $available, true)) {
+					$expanded[$key] = true;
+				}
+			}
+		}
+	}
+
+	set_user_setting('hmib_summary_layout', json_encode(['order' => $order, 'expanded' => $expanded]));
+
+	return (string) json_encode(['ok' => true]);
+}
+
+/**
+ * Persist the posted Fleet Dashboard auto-refresh interval for the current user
+ * (CSRF POST, validated against the refresh picker's options).
+ *
+ * @return string A JSON status document.
+ *
+ * @global array $page_refresh_interval Cacti's allowed refresh intervals.
+ */
+function hmib_summary_refresh_save(): string {
+	global $page_refresh_interval;
+
+	if ($_SERVER['REQUEST_METHOD'] !== 'POST' || !function_exists('csrf_check') || !csrf_check(false)) {
+		return (string) json_encode(['error' => __('Invalid request. Please try again.', 'hmib')]);
+	}
+
+	$posted    = isset_request_var('refresh') ? (string) get_nfilter_request_var('refresh') : '';
+	$intervals = (is_array($page_refresh_interval) && cacti_sizeof($page_refresh_interval)) ? $page_refresh_interval : [30 => '', 60 => '', 300 => ''];
+	$allowed   = array_map('intval', array_keys($intervals));
+	$allowed[] = 0;
+
+	if (!preg_match('/^[0-9]+$/', $posted) || !in_array((int) $posted, $allowed, true)) {
+		return (string) json_encode(['error' => __('Invalid refresh interval.', 'hmib')]);
+	}
+
+	set_user_setting('hmib_summary_refresh', (int) $posted);
+
+	return (string) json_encode(['ok' => true]);
+}
+
+/**
+ * AJAX: render a single Fleet Dashboard card (adding from the catalogue or
+ * refreshing in place).
+ *
+ * @return string A JSON document with the card key and rendered HTML.
+ */
+function hmib_summary_card_ajax(): string {
+	if ($_SERVER['REQUEST_METHOD'] !== 'POST' || !function_exists('csrf_check') || !csrf_check(false)) {
+		return (string) json_encode(['error' => __('Invalid request. Please try again.', 'hmib')]);
+	}
+
+	$ostype = hmib_summary_resolve_type();
+	$key    = isset_request_var('card') ? (string) get_nfilter_request_var('card') : '';
+
+	if (!in_array($key, hmib_summary_available_cards($ostype), true)) {
+		return (string) json_encode(['error' => __('Unknown card.', 'hmib')]);
+	}
+
+	$expanded = isset_request_var('expanded') && get_nfilter_request_var('expanded') === '1';
+
+	return (string) json_encode(['card' => $key, 'html' => hmib_summary_render_card($key, $ostype, $expanded)]);
+}
+
+/**
+ * Renders the Fleet (Summary) Dashboard: a draggable grid of aggregate cards
+ * (fleet overview, min/avg/max utilization bullet charts, device status, storage,
+ * uptime, OS type distribution and top processes by CPU/memory) scoped to all
+ * devices or a single OS type. Card order, expanded state, the selected OS type
+ * and the auto-refresh interval persist per user. Called from this script's main
+ * request-dispatch switch when action=summary_dashboard.
+ *
+ * @return void
+ *
+ * @global array $config                Cacti global configuration array.
+ * @global array $page_refresh_interval Cacti's refresh-interval option list.
+ */
+function hmib_summary_dashboard(): void {
+	global $config, $page_refresh_interval;
+
+	$ostype = hmib_summary_resolve_type();
+
+	$current_refresh = (int) read_user_setting('hmib_summary_refresh', 0);
+
+	if ($current_refresh > 0 && function_exists('set_page_refresh')) {
+		set_page_refresh([
+			'seconds' => $current_refresh,
+			'page'    => $config['url_path'] . 'plugins/hmib/hmib.php?action=summary_dashboard&header=false',
+			'logout'  => 'false'
+		]);
+	}
+
+	print '<script type="text/javascript" ' . plugin_hmib_csp_nonce() . ' src="' . $config['url_path'] . 'plugins/hmib/js/hmib_summary_dashboard.js?v=' . filemtime($config['base_path'] . '/plugins/hmib/js/hmib_summary_dashboard.js') . '"></script>';
+
+	$layout = hmib_summary_layout($ostype);
+	$meta   = hmib_summary_card_meta();
+	$absent = array_values(array_diff(hmib_summary_available_cards($ostype), $layout['order']));
+
+	if (empty($page_refresh_interval) || !is_array($page_refresh_interval)) {
+		$page_refresh_interval = [0 => __('No Refresh', 'hmib'), 30 => __('30 Seconds', 'hmib'), 60 => __('1 Minute', 'hmib'), 300 => __('5 Minutes', 'hmib')];
+	}
+
+	print '<div class="hmibDashToolbar">';
+	print '<label class="hmibDashToolbarLabel" for="hmib_summary_type">' . __esc('Scope', 'hmib') . '</label>';
+	print '<select id="hmib_summary_type" class="hmibDashAdd">';
+	print '<option value="0"' . ($ostype === 0 ? ' selected' : '') . '>' . __esc('All Types', 'hmib') . '</option>';
+
+	$types = db_fetch_assoc("SELECT DISTINCT hrst.id, CONCAT_WS('', hrst.name, ' [', hrst.version, ']') AS name
+		FROM plugin_hmib_hrSystemTypes AS hrst
+		INNER JOIN plugin_hmib_hrSystem AS hrs ON hrst.id = hrs.host_type
+		WHERE hrst.name != ''
+		ORDER BY name");
+
+	if (cacti_sizeof($types)) {
+		foreach ($types as $type) {
+			print '<option value="' . (int) $type['id'] . '"' . ((int) $type['id'] === $ostype ? ' selected' : '') . '>' . html_escape($type['name']) . '</option>';
+		}
+	}
+
+	print '</select>';
+
+	print '<label class="hmibDashToolbarLabel" for="hmib_summary_add">' . __esc('Add card', 'hmib') . '</label>';
+	print '<select id="hmib_summary_add" class="hmibDashAdd"><option value="">' . __esc('Add a card…', 'hmib') . '</option>';
+
+	foreach ($absent as $key) {
+		print '<option value="' . html_escape($key) . '">' . html_escape($meta[$key]['title']) . '</option>';
+	}
+
+	print '</select>';
+
+	print '<div class="hmibDashRefresh">';
+	print '<label class="hmibDashToolbarLabel" for="hmib_summary_refresh">' . __esc('Refresh', 'hmib') . '</label>';
+	print '<select id="hmib_summary_refresh" class="hmibDashRefreshInterval">';
+	print '<option value="0"' . ($current_refresh === 0 ? ' selected' : '') . '>' . __esc('No Refresh', 'hmib') . '</option>';
+
+	foreach ($page_refresh_interval as $seconds => $display_text) {
+		if ((int) $seconds === 0) {
+			continue;
+		}
+
+		print '<option value="' . (int) $seconds . '"' . ($current_refresh === (int) $seconds ? ' selected' : '') . '>' . html_escape($display_text) . '</option>';
+	}
+
+	print '</select>';
+	print '<button type="button" id="hmib_summary_refresh_now" class="hmibDashCardTool hmibDashRefreshNow" aria-label="' . __esc('Refresh', 'hmib') . '" title="' . __esc('Refresh', 'hmib') . '"><i class="fas fa-sync-alt" aria-hidden="true"></i></button>';
+	print '</div>';
+	print '</div>';
+
+	print '<div id="hmib_summary_dashboard" class="hmibDashGrid" data-ostype="' . $ostype . '">';
+
+	foreach ($layout['order'] as $key) {
+		print hmib_summary_render_card($key, $ostype, !empty($layout['expanded'][$key]));
+	}
+
+	print '</div>';
+
+	print '<div id="hmib_summary_dialog" class="hmibDashDialog" style="display:none"></div>';
+
+	$catalog = [];
+
+	foreach (hmib_summary_available_cards($ostype) as $key) {
+		$catalog[$key] = $meta[$key]['title'];
+	}
+
+	print '<script type="text/javascript" ' . plugin_hmib_csp_nonce() . '>var hmibSummaryCatalog = ' . json_encode($catalog, JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT) . '; initHmibSummaryDashboard();</script>';
+}
diff --git a/js/hmib_summary_dashboard.js b/js/hmib_summary_dashboard.js
new file mode 100644
index 0000000..53d0caf
--- /dev/null
+++ b/js/hmib_summary_dashboard.js
@@ -0,0 +1,437 @@
+/*
+ +-------------------------------------------------------------------------+
+ | Copyright (C) 2004-2026 The Cacti Group                                 |
+ |                                                                         |
+ | This program is free software; you can redistribute it and/or           |
+ | modify it under the terms of the GNU General Public License             |
+ | as published by the Free Software Foundation; either version 2          |
+ | of the License, or (at your option) any later version.                  |
+ +-------------------------------------------------------------------------+
+ | Cacti: The Complete RRDtool-based Graphing Solution                     |
+ +-------------------------------------------------------------------------+
+*/
+
+/* Fleet Dashboard: the Summary-tab aggregate card grid. Mirrors the per-device
+ * dashboard's card interaction model (drag/keyboard reorder, add/remove,
+ * refresh, maximize, sortable tables, layout persistence) but is scoped by OS
+ * type (ostype, 0 = all types) rather than a single device, and reuses the
+ * shared .hmibDash* card chrome. */
+
+var hmibSumDragging = null;
+
+function initHmibSummaryDashboard() {
+	$(function() {
+		var grid = document.getElementById('hmib_summary_dashboard');
+		if (!grid) {
+			return;
+		}
+
+		grid.querySelectorAll('.hmibDashCard').forEach(function(card) {
+			hmibSumBindCard(grid, card);
+		});
+
+		grid.addEventListener('dragover', function(event) {
+			if (!hmibSumDragging) {
+				return;
+			}
+			event.preventDefault();
+			event.dataTransfer.dropEffect = 'move';
+			var before = hmibSumDragReference(grid, event.clientX, event.clientY);
+			if (before == null) {
+				grid.appendChild(hmibSumDragging);
+			} else if (before !== hmibSumDragging) {
+				grid.insertBefore(hmibSumDragging, before);
+			}
+		});
+
+		$(grid).off('click.hmibsum').on('click.hmibsum', '.hmibDashCardTool', function() {
+			var card = this.closest('.hmibDashCard');
+			if (!card) {
+				return;
+			}
+			switch (this.dataset.tool) {
+				case 'expand':   card.classList.add('hmibDashCardExpanded'); hmibSumSaveLayout(grid); break;
+				case 'collapse': card.classList.remove('hmibDashCardExpanded'); hmibSumSaveLayout(grid); break;
+				case 'maximize': hmibSumMaximize(card); break;
+				case 'refresh':  hmibSumRefreshCard(grid, card); break;
+				case 'remove':   hmibSumRemoveCard(grid, card); break;
+			}
+		});
+
+		$(grid).off('click.hmibsumsort').on('click.hmibsumsort', 'th.hmibDashSortable', function() {
+			hmibSumSortTable(this);
+		});
+		$(grid).off('keydown.hmibsumsort').on('keydown.hmibsumsort', 'th.hmibDashSortable', function(event) {
+			if (event.key === 'Enter' || event.key === ' ' || event.key === 'Spacebar') {
+				event.preventDefault();
+				hmibSumSortTable(this);
+			}
+		});
+
+		var add = document.getElementById('hmib_summary_add');
+		if (add) {
+			$(add).off('change.hmibsum').on('change.hmibsum', function() {
+				var key = this.value;
+				this.value = '';
+				if (key) {
+					hmibSumAddCard(grid, key);
+				}
+			});
+		}
+
+		var type = document.getElementById('hmib_summary_type');
+		if (type) {
+			$(type).off('change.hmibsum').on('change.hmibsum', function() {
+				window.location = 'hmib.php?action=summary_dashboard&ostype=' + encodeURIComponent(this.value);
+			});
+		}
+
+		var interval = document.getElementById('hmib_summary_refresh');
+		if (interval) {
+			$(interval).off('change.hmibsum').on('change.hmibsum', function() {
+				$.post('hmib.php', {action: 'summary_refresh', refresh: this.value, __csrf_magic: csrfMagicToken}, null, 'json').always(function() {
+					window.location = 'hmib.php?action=summary_dashboard';
+				});
+			});
+		}
+
+		var refreshNow = document.getElementById('hmib_summary_refresh_now');
+		if (refreshNow) {
+			$(refreshNow).off('click.hmibsum').on('click.hmibsum', function() {
+				hmibSumRefreshAll(grid, this);
+			});
+		}
+	});
+}
+
+/** Wire a single card's drag handle (mouse + keyboard) and drag events. */
+function hmibSumBindCard(grid, card) {
+	hmibSumPrepSortHeaders(card);
+
+	var handle = card.querySelector('.hmibDashCardDrag');
+	if (!handle) {
+		return;
+	}
+
+	var disarm = function() { card.draggable = false; };
+	handle.addEventListener('mousedown', function() {
+		card.draggable = true;
+		document.addEventListener('mouseup', disarm, {once: true});
+	});
+	handle.addEventListener('touchstart', function() {
+		card.draggable = true;
+		document.addEventListener('touchend', disarm, {once: true});
+		document.addEventListener('touchcancel', disarm, {once: true});
+	}, {passive: true});
+
+	handle.addEventListener('keydown', function(event) {
+		var back = event.key === 'ArrowLeft' || event.key === 'ArrowUp';
+		var fwd  = event.key === 'ArrowRight' || event.key === 'ArrowDown';
+		if (!back && !fwd) {
+			return;
+		}
+		event.preventDefault();
+		if (back && card.previousElementSibling) {
+			grid.insertBefore(card, card.previousElementSibling);
+		} else if (fwd && card.nextElementSibling) {
+			grid.insertBefore(card.nextElementSibling, card);
+		} else {
+			return;
+		}
+		handle.focus();
+		hmibSumSaveLayout(grid);
+	});
+
+	card.addEventListener('dragstart', function(event) {
+		hmibSumDragging = card;
+		card.classList.add('hmibDashCardDragging');
+		event.dataTransfer.effectAllowed = 'move';
+		try { event.dataTransfer.setData('text/plain', card.dataset.card || ''); } catch (error) { /* IE guard */ }
+	});
+
+	card.addEventListener('dragend', function() {
+		card.draggable = false;
+		card.classList.remove('hmibDashCardDragging');
+		if (hmibSumDragging) {
+			hmibSumDragging = null;
+			hmibSumSaveLayout(grid);
+		}
+	});
+}
+
+/** The card the dragged card should be inserted before for the current pointer
+ *  position, or null to append at the end. */
+function hmibSumDragReference(grid, x, y) {
+	var cards = Array.prototype.slice.call(grid.querySelectorAll('.hmibDashCard:not(.hmibDashCardDragging)'));
+	for (var i = 0; i < cards.length; i++) {
+		var rect = cards[i].getBoundingClientRect();
+		if (y < rect.top - 1) {
+			return cards[i];
+		}
+		if (y <= rect.bottom && x < rect.left + rect.width / 2) {
+			return cards[i];
+		}
+	}
+	return null;
+}
+
+/** Add a card from the catalogue: fetch its HTML, append it, persist and refresh
+ *  the "Add" options. */
+function hmibSumAddCard(grid, key) {
+	if (hmibSumHasCard(grid, key)) {
+		return;
+	}
+	$.post('hmib.php', {action: 'summary_card', card: key, ostype: grid.dataset.ostype, __csrf_magic: csrfMagicToken}, null, 'json').done(function(data) {
+		if (!data || !data.html || hmibSumHasCard(grid, key)) {
+			return;
+		}
+		var card = hmibSumParseCard(data.html);
+		if (!card) {
+			return;
+		}
+		grid.appendChild(card);
+		hmibSumBindCard(grid, card);
+		hmibSumSaveLayout(grid);
+		hmibSumSyncAddOptions(grid);
+	});
+}
+
+/** Whether a card with the given key is currently on the grid. */
+function hmibSumHasCard(grid, key) {
+	var present = false;
+	grid.querySelectorAll('.hmibDashCard').forEach(function(card) {
+		if (card.dataset.card === key) {
+			present = true;
+		}
+	});
+	return present;
+}
+
+/** Remove a card from the page and return it to the "Add" catalogue. */
+function hmibSumRemoveCard(grid, card) {
+	card.parentNode.removeChild(card);
+	hmibSumSaveLayout(grid);
+	hmibSumSyncAddOptions(grid);
+}
+
+/** Re-fetch a single card's HTML and swap it in place, keeping expanded state. */
+function hmibSumRefreshCard(grid, card, done) {
+	var icon = card.querySelector('.hmibDashCardTool[data-tool="refresh"] .fa, .hmibDashCardTool[data-tool="refresh"] .fas');
+	if (icon) {
+		icon.classList.add('fa-spin');
+	}
+	var settle = function() {
+		if (icon) {
+			icon.classList.remove('fa-spin');
+		}
+		if (done) {
+			done();
+		}
+	};
+	var expanded = card.classList.contains('hmibDashCardExpanded') ? '1' : '0';
+	$.post('hmib.php', {action: 'summary_card', card: card.dataset.card, ostype: grid.dataset.ostype, expanded: expanded, __csrf_magic: csrfMagicToken}, null, 'json').done(function(data) {
+		if (!data || !data.html || !card.parentNode) {
+			settle();
+			return;
+		}
+		var fresh = hmibSumParseCard(data.html);
+		if (!fresh) {
+			settle();
+			return;
+		}
+		card.parentNode.replaceChild(fresh, card);
+		hmibSumBindCard(grid, fresh);
+		if (done) {
+			done();
+		}
+	}).fail(settle);
+}
+
+/** Refresh every card on the page, spinning the toolbar glyph until all land. */
+function hmibSumRefreshAll(grid, button) {
+	var icon = button ? button.querySelector('.fa, .fas') : null;
+	var cards = Array.prototype.slice.call(grid.querySelectorAll('.hmibDashCard'));
+	var pending = cards.length;
+	if (!pending) {
+		return;
+	}
+	if (icon) {
+		icon.classList.add('fa-spin');
+	}
+	cards.forEach(function(card) {
+		hmibSumRefreshCard(grid, card, function() {
+			pending--;
+			if (pending <= 0 && icon) {
+				icon.classList.remove('fa-spin');
+			}
+		});
+	});
+}
+
+/** Open a copy of a card's body in a large modal dialog. */
+function hmibSumMaximize(card) {
+	var dialog = document.getElementById('hmib_summary_dialog');
+	if (!dialog) {
+		return;
+	}
+	var title = card.querySelector('.hmibDashCardTitle');
+	var body  = card.querySelector('.hmibDashCardBody');
+	dialog.innerHTML = '<div class="hmibDashDialogBody">' + (body ? body.innerHTML : '') + '</div>';
+
+	hmibSumPrepSortHeaders(dialog);
+	$(dialog).off('click.hmibsumsort').on('click.hmibsumsort', 'th.hmibDashSortable', function() {
+		hmibSumSortTable(this);
+	});
+	$(dialog).off('keydown.hmibsumsort').on('keydown.hmibsumsort', 'th.hmibDashSortable', function(event) {
+		if (event.key === 'Enter' || event.key === ' ' || event.key === 'Spacebar') {
+			event.preventDefault();
+			hmibSumSortTable(this);
+		}
+	});
+
+	$(dialog).dialog({
+		modal: true,
+		appendTo: 'body',
+		width: Math.min(900, $(window).width() - 40),
+		title: title ? title.textContent : ''
+	});
+}
+
+/** Make a container's sortable headers focusable and screen-reader friendly. */
+function hmibSumPrepSortHeaders(container) {
+	if (!container) {
+		return;
+	}
+	container.querySelectorAll('th.hmibDashSortable').forEach(function(th) {
+		if (!th.hasAttribute('tabindex')) {
+			th.setAttribute('tabindex', '0');
+		}
+		th.setAttribute('role', 'button');
+		if (!th.hasAttribute('aria-sort')) {
+			th.setAttribute('aria-sort', 'none');
+		}
+	});
+}
+
+/** Parse a card HTML string into its <section> element. */
+function hmibSumParseCard(html) {
+	var tmp = document.createElement('div');
+	tmp.innerHTML = html;
+	return tmp.querySelector('.hmibDashCard');
+}
+
+/** Rebuild the "Add" dropdown so it lists only cards not currently on the page. */
+function hmibSumSyncAddOptions(grid) {
+	var add = document.getElementById('hmib_summary_add');
+	if (!add || typeof hmibSummaryCatalog === 'undefined') {
+		return;
+	}
+	var present = {};
+	grid.querySelectorAll('.hmibDashCard').forEach(function(card) {
+		if (card.dataset.card) {
+			present[card.dataset.card] = true;
+		}
+	});
+	while (add.options.length > 1) {
+		add.remove(1);
+	}
+	Object.keys(hmibSummaryCatalog).forEach(function(key) {
+		if (!present[key]) {
+			var option = document.createElement('option');
+			option.value = key;
+			option.textContent = hmibSummaryCatalog[key];
+			add.appendChild(option);
+		}
+	});
+}
+
+/** Sort a card table by the clicked column header, toggling asc/desc. Numeric
+ *  columns (data-sort="num") sort by the cell's data-sort-value when present. */
+function hmibSumSortTable(th) {
+	var table = th.closest('table');
+	if (!table) {
+		return;
+	}
+	var tbody = table.tBodies[0];
+	if (!tbody) {
+		return;
+	}
+	var headers = Array.prototype.slice.call(th.parentNode.children);
+	var index = headers.indexOf(th);
+	var numeric = th.dataset.sort === 'num';
+	var asc = !th.classList.contains('hmibDashSortAsc');
+
+	headers.forEach(function(header) {
+		header.classList.remove('hmibDashSortAsc', 'hmibDashSortDesc');
+		if (header.classList.contains('hmibDashSortable')) {
+			header.setAttribute('aria-sort', 'none');
+		}
+	});
+	th.classList.add(asc ? 'hmibDashSortAsc' : 'hmibDashSortDesc');
+	th.setAttribute('aria-sort', asc ? 'ascending' : 'descending');
+
+	var rows = Array.prototype.slice.call(tbody.rows).filter(function(row) {
+		return !row.classList.contains('hmibDashEmptyRow');
+	});
+
+	var value = function(row) {
+		var cell = row.cells[index];
+		if (!cell) {
+			return numeric ? 0 : '';
+		}
+		if (numeric) {
+			var raw = cell.dataset.sortValue !== undefined ? cell.dataset.sortValue : cell.textContent;
+			var num = parseFloat(String(raw).replace(/[^0-9.\-]/g, ''));
+			return isNaN(num) ? 0 : num;
+		}
+		return cell.textContent.trim().toLowerCase();
+	};
+
+	rows.sort(function(a, b) {
+		var va = value(a);
+		var vb = value(b);
+		if (va < vb) { return asc ? -1 : 1; }
+		if (va > vb) { return asc ? 1 : -1; }
+		return 0;
+	});
+
+	rows.forEach(function(row) {
+		tbody.appendChild(row);
+	});
+}
+
+/** Serialize layout POSTs so rapid actions can't persist out of order. */
+var hmibSumSaveInFlight = false;
+var hmibSumSaveQueued = false;
+
+function hmibSumSaveLayout(grid) {
+	if (hmibSumSaveInFlight) {
+		hmibSumSaveQueued = true;
+		return;
+	}
+	hmibSumSaveInFlight = true;
+
+	var order = [];
+	var expanded = {};
+	grid.querySelectorAll('.hmibDashCard').forEach(function(card) {
+		if (!card.dataset.card) {
+			return;
+		}
+		order.push(card.dataset.card);
+		if (card.classList.contains('hmibDashCardExpanded')) {
+			expanded[card.dataset.card] = true;
+		}
+	});
+
+	$.post('hmib.php', {
+		action: 'summary_layout',
+		layout: JSON.stringify({order: order, expanded: expanded}),
+		__csrf_magic: csrfMagicToken
+	}, null, 'json').always(function() {
+		hmibSumSaveInFlight = false;
+		if (hmibSumSaveQueued) {
+			hmibSumSaveQueued = false;
+			hmibSumSaveLayout(grid);
+		}
+	});
+}
diff --git a/locales/po/cacti.pot b/locales/po/cacti.pot
index 393cc92..46766aa 100644
--- a/locales/po/cacti.pot
+++ b/locales/po/cacti.pot
@@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: Cacti\n"
 "Report-Msgid-Bugs-To: developers@cacti.net\n"
-"POT-Creation-Date: 2026-10-10 09:47-0400\n"
+"POT-Creation-Date: 2026-10-10 17:26-0400\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: Cacti Developers <developers@cacti.net>\n"
 "Language-Team: Cacti Developers <developers@cacti.net>\n"
@@ -385,6 +385,10 @@ msgstr ""
 msgid "Graphs"
 msgstr ""
 
+#: hmib.php
+msgid "Fleet Dashboard"
+msgstr ""
+
 #: hmib.php
 msgid "Dashboard"
 msgstr ""
@@ -463,6 +467,10 @@ msgstr ""
 msgid "Max Proc"
 msgstr ""
 
+#: hmib.php
+msgid "View Fleet Dashboard"
+msgstr ""
+
 #: hmib.php
 msgid "View Devices"
 msgstr ""
@@ -785,6 +793,94 @@ msgstr ""
 msgid "Add a card…"
 msgstr ""
 
+#: hmib.php
+msgid "Fleet Overview"
+msgstr ""
+
+#: hmib.php
+msgid "Resource Utilization"
+msgstr ""
+
+#: hmib.php
+msgid "Device Status"
+msgstr ""
+
+#: hmib.php
+msgid "Storage Utilization"
+msgstr ""
+
+#: hmib.php
+msgid "Uptime Distribution"
+msgstr ""
+
+#: hmib.php
+msgid "OS Type Distribution"
+msgstr ""
+
+#: hmib.php
+msgid "Top Processes by CPU"
+msgstr ""
+
+#: hmib.php
+msgid "Top Processes by Memory"
+msgstr ""
+
+#: hmib.php
+msgid "No Host MIB devices in this scope yet."
+msgstr ""
+
+#: hmib.php
+msgid "Total RAM"
+msgstr ""
+
+#: hmib.php
+msgid "CPU %"
+msgstr ""
+
+#: hmib.php
+msgid "Memory %"
+msgstr ""
+
+#: hmib.php
+msgid "Swap %"
+msgstr ""
+
+#: hmib.php
+msgid "Processes / host"
+msgstr ""
+
+#: hmib.php
+msgid "No storage volumes detected in this scope."
+msgstr ""
+
+#: hmib.php
+msgid "Total Capacity"
+msgstr ""
+
+#: hmib.php
+msgid "No OS types recorded."
+msgstr ""
+
+#: hmib.php
+msgid "Max CPU (s)"
+msgstr ""
+
+#: hmib.php
+msgid "Relative"
+msgstr ""
+
+#: hmib.php
+msgid "No process statistics recorded."
+msgstr ""
+
+#: hmib.php
+msgid "Scope"
+msgstr ""
+
+#: hmib.php
+msgid "All Types"
+msgstr ""
+
 #: hmib_types.php
 msgid "Delete"
 msgstr ""

From 491c7efa3d356c2d3be7c2a230705adb633bf8ae Mon Sep 17 00:00:00 2001
From: TheWitness <thewitness@cacti.net>
Date: Sat, 10 Oct 2026 17:36:59 -0400
Subject: [PATCH 2/5] fix(hmib): address Fleet Dashboard review (live-host
 gating, OS scope, snake_case)

- Storage bullet: gate the per-volume used% min/avg/max on host_status >= 2 so stale values from down/disabled hosts don't skew the live distribution, while keeping capacity totals over all volumes.
- OS Type Distribution card: apply the \ scope predicate and switch to db_fetch_assoc_prepared(), binding the translated 'Unknown' fallback so a locale apostrophe can't break the SQL.
- Top Processes by CPU/Memory: always join hrSystem and require host_status >= 2 so the AVG/MAX rankings use only live devices (the all-types scope previously had no host-status column at all).
- Rename the new camelCase locals (cpuSev/memSev/swSev/procScale/stoSev/upScale) to snake_case per the repo convention.
---
 hmib.php | 51 +++++++++++++++++++++++++++++++--------------------
 1 file changed, 31 insertions(+), 20 deletions(-)

diff --git a/hmib.php b/hmib.php
index 235e666..06b2bc8 100644
--- a/hmib.php
+++ b/hmib.php
@@ -4882,12 +4882,15 @@ function hmib_summary_storage_stats(int $ostype): array {
 		$params = $ostype > 0 ? [$ostype] : [];
 
 		$row = db_fetch_row_prepared("SELECT
-			MIN(pct) AS minPct, AVG(pct) AS avgPct, MAX(pct) AS maxPct,
+			MIN(CASE WHEN host_status >= 2 THEN pct END) AS minPct,
+			AVG(CASE WHEN host_status >= 2 THEN pct END) AS avgPct,
+			MAX(CASE WHEN host_status >= 2 THEN pct END) AS maxPct,
 			SUM(total) AS totalBytes, SUM(usedBytes) AS usedBytes, COUNT(*) AS volumes
 			FROM (
 				SELECT (hrsto.used / hrsto.size) * 100 AS pct,
 					hrsto.size * hrsto.allocationUnits AS total,
-					hrsto.used * hrsto.allocationUnits AS usedBytes
+					hrsto.used * hrsto.allocationUnits AS usedBytes,
+					hrs.host_status AS host_status
 				FROM plugin_hmib_hrStorage AS hrsto
 				INNER JOIN plugin_hmib_hrSystem AS hrs ON hrs.host_id = hrsto.host_id
 				WHERE hrsto.size > 0 AND hrsto.description != '' $where
@@ -5063,19 +5066,19 @@ function hmib_summary_card_body(string $key, int $ostype): string {
 
 			break;
 		case 'utilization':
-			$cpuSev = $stats['avgCpu'] !== null ? hmib_dashboard_severity((float) $stats['avgCpu']) : 'none';
-			$memSev = $stats['avgMem'] !== null ? hmib_dashboard_severity((float) $stats['avgMem']) : 'none';
-			$swSev  = $stats['avgSwap'] !== null ? hmib_dashboard_severity((float) $stats['avgSwap']) : 'none';
+			$cpu_sev  = $stats['avgCpu'] !== null ? hmib_dashboard_severity((float) $stats['avgCpu']) : 'none';
+			$mem_sev  = $stats['avgMem'] !== null ? hmib_dashboard_severity((float) $stats['avgMem']) : 'none';
+			$swap_sev = $stats['avgSwap'] !== null ? hmib_dashboard_severity((float) $stats['avgSwap']) : 'none';
 
-			print hmib_summary_bullet(__('CPU %', 'hmib'), $stats['minCpu'], $stats['avgCpu'], $stats['maxCpu'], 100.0, $cpuSev, 'percent');
-			print hmib_summary_bullet(__('Memory %', 'hmib'), $stats['minMem'], $stats['avgMem'], $stats['maxMem'], 100.0, $memSev, 'percent');
+			print hmib_summary_bullet(__('CPU %', 'hmib'), $stats['minCpu'], $stats['avgCpu'], $stats['maxCpu'], 100.0, $cpu_sev, 'percent');
+			print hmib_summary_bullet(__('Memory %', 'hmib'), $stats['minMem'], $stats['avgMem'], $stats['maxMem'], 100.0, $mem_sev, 'percent');
 
 			if ($stats['avgSwap'] !== null) {
-				print hmib_summary_bullet(__('Swap %', 'hmib'), $stats['minSwap'], $stats['avgSwap'], $stats['maxSwap'], 100.0, $swSev, 'percent');
+				print hmib_summary_bullet(__('Swap %', 'hmib'), $stats['minSwap'], $stats['avgSwap'], $stats['maxSwap'], 100.0, $swap_sev, 'percent');
 			}
 
-			$procScale = max(1.0, (float) ($stats['maxProc'] ?? 1));
-			print hmib_summary_bullet(__('Processes / host', 'hmib'), $stats['minProc'], $stats['avgProc'], $stats['maxProc'], $procScale, 'none', 'number');
+			$proc_scale = max(1.0, (float) ($stats['maxProc'] ?? 1));
+			print hmib_summary_bullet(__('Processes / host', 'hmib'), $stats['minProc'], $stats['avgProc'], $stats['maxProc'], $proc_scale, 'none', 'number');
 
 			break;
 		case 'status':
@@ -5111,8 +5114,8 @@ function hmib_summary_card_body(string $key, int $ostype): string {
 				break;
 			}
 
-			$stoSev = $storage['avgPct'] !== null ? hmib_dashboard_severity((float) $storage['avgPct']) : 'none';
-			print hmib_summary_bullet(__('Used %', 'hmib'), $storage['minPct'], $storage['avgPct'], $storage['maxPct'], 100.0, $stoSev, 'percent');
+			$storage_sev = $storage['avgPct'] !== null ? hmib_dashboard_severity((float) $storage['avgPct']) : 'none';
+			print hmib_summary_bullet(__('Used %', 'hmib'), $storage['minPct'], $storage['avgPct'], $storage['maxPct'], 100.0, $storage_sev, 'percent');
 
 			print '<table class="hmibDashTable hmibDashKv"><tbody>';
 			print '<tr><th>' . __esc('Volumes', 'hmib') . '</th><td>' . number_format_i18n((int) $storage['volumes'], 0) . '</td></tr>';
@@ -5122,19 +5125,28 @@ function hmib_summary_card_body(string $key, int $ostype): string {
 
 			break;
 		case 'uptime':
-			$upScale = max(1.0, (float) ($stats['maxUptime'] ?? 1));
-			print hmib_summary_bullet(__('Uptime', 'hmib'), $stats['minUptime'], $stats['avgUptime'], $stats['maxUptime'], $upScale, 'none', 'uptime');
+			$up_scale = max(1.0, (float) ($stats['maxUptime'] ?? 1));
+			print hmib_summary_bullet(__('Uptime', 'hmib'), $stats['minUptime'], $stats['avgUptime'], $stats['maxUptime'], $up_scale, 'none', 'uptime');
 
 			break;
 		case 'ostypes':
-			$types = db_fetch_assoc("SELECT
-				CONCAT_WS('', IF(hrst.name = '' OR hrst.name IS NULL, '" . __('Unknown', 'hmib') . "', hrst.name), IF(hrst.version = '' OR hrst.version IS NULL, '', CONCAT(' ', hrst.version))) AS name,
+			$unknown_label = __('Unknown', 'hmib');
+			$type_where    = $ostype > 0 ? 'WHERE hrs.host_type = ?' : '';
+			$type_params   = [$unknown_label];
+
+			if ($ostype > 0) {
+				$type_params[] = $ostype;
+			}
+
+			$types = db_fetch_assoc_prepared("SELECT
+				CONCAT_WS('', IF(hrst.name = '' OR hrst.name IS NULL, ?, hrst.name), IF(hrst.version = '' OR hrst.version IS NULL, '', CONCAT(' ', hrst.version))) AS name,
 				COUNT(*) AS devices
 				FROM plugin_hmib_hrSystem AS hrs
 				LEFT JOIN plugin_hmib_hrSystemTypes AS hrst ON hrs.host_type = hrst.id
+				$type_where
 				GROUP BY hrs.host_type
 				ORDER BY devices DESC
-				LIMIT 15");
+				LIMIT 15", $type_params);
 
 			if (!cacti_sizeof($types)) {
 				print '<p class="hmibDashEmpty">' . __esc('No OS types recorded.', 'hmib') . '</p>';
@@ -5161,7 +5173,6 @@ function hmib_summary_card_body(string $key, int $ostype): string {
 		case 'top_memory':
 			$by_cpu = ($key === 'top_cpu');
 			$where  = $ostype > 0 ? 'AND hrs.host_type = ?' : '';
-			$join   = $ostype > 0 ? 'INNER JOIN plugin_hmib_hrSystem AS hrs ON hrs.host_id = hrswr.host_id' : '';
 			$params = $ostype > 0 ? [$ostype] : [];
 
 			$processes = db_fetch_assoc_prepared("SELECT hrswr.name AS name,
@@ -5169,8 +5180,8 @@ function hmib_summary_card_body(string $key, int $ostype): string {
 				AVG(hrswr.perfCPU) AS avgCpu, MAX(hrswr.perfCPU) AS maxCpu,
 				AVG(hrswr.perfMemory) AS avgMem, MAX(hrswr.perfMemory) AS maxMem
 				FROM plugin_hmib_hrSWRun AS hrswr
-				$join
-				WHERE hrswr.name != '' AND hrswr.name != 'System Idle Process' $where
+				INNER JOIN plugin_hmib_hrSystem AS hrs ON hrs.host_id = hrswr.host_id
+				WHERE hrswr.name != '' AND hrswr.name != 'System Idle Process' AND hrs.host_status >= 2 $where
 				GROUP BY hrswr.name
 				ORDER BY " . ($by_cpu ? 'maxCpu' : 'maxMem') . " DESC
 				LIMIT 15", $params);

From 2aac739ecd9ef438cda0db18ebc6de8dc8f98116 Mon Sep 17 00:00:00 2001
From: TheWitness <thewitness@cacti.net>
Date: Sat, 10 Oct 2026 17:48:20 -0400
Subject: [PATCH 3/5] fix(hmib): Fleet Dashboard re-review (OS sentinel, full
 distribution, bar fills, refresh race)

- Use -1 as the all-types sentinel instead of 0, since Cacti already uses 0 for the Unknown OS type. The Unknown Device Type row's glyph (ostype=0) now correctly scopes to untyped devices, and the scope picker gains an explicit Unknown option. All aggregate queries scope on host_type when ostype >= 0 (Unknown or a specific type) and span the whole fleet only for -1.
- OS Type Distribution: drop the LIMIT 15 so fleets with more than 15 types are fully represented (the card already clips/expands).
- Make the distribution-bar and top-process mini-bar fills block-level so their percentage widths actually render (an inline <span> ignored width/height).
- Top-process refresh: copy the card's current expanded class onto the fresh node before swapping, so toggling expand/collapse while a refresh is in flight is not reverted by the stale snapshot.
---
 css/hmib.css                 |  2 ++
 hmib.php                     | 59 ++++++++++++++++++++----------------
 js/hmib_summary_dashboard.js |  7 +++++
 locales/po/cacti.pot         |  2 +-
 4 files changed, 43 insertions(+), 27 deletions(-)

diff --git a/css/hmib.css b/css/hmib.css
index 7851d03..2e61951 100644
--- a/css/hmib.css
+++ b/css/hmib.css
@@ -668,6 +668,7 @@
 }
 
 .hmibDistFill {
+	display: block;
 	height: 100%;
 	border-radius: 6px;
 	background: color-mix(in srgb, currentColor 45%, transparent);
@@ -679,6 +680,7 @@
 }
 
 .hmibMiniBar {
+	display: block;
 	position: relative;
 	height: 10px;
 	min-width: 60px;
diff --git a/hmib.php b/hmib.php
index 06b2bc8..125886e 100644
--- a/hmib.php
+++ b/hmib.php
@@ -4788,19 +4788,22 @@ function hmib_dashboard(): void {
 
 /**
  * Resolve the OS type the Fleet (Summary) Dashboard should scope to. A validated
- * 'ostype' request variable wins and is remembered; 0 means "all types". Falls
- * back to the remembered type, or 0.
+ * 'ostype' request variable wins and is remembered. -1 = all types, 0 = Unknown
+ * (untyped devices), a positive id = a specific OS type. Falls back to the
+ * remembered scope, or -1 (all).
  *
- * @return int The OS type id (host_type), or 0 for all types.
+ * @return int The host_type scope: -1 (all), 0 (Unknown), or a positive type id.
  */
 function hmib_summary_resolve_type(): int {
-	$ostype = -1;
+	$ostype   = -1;
+	$resolved = false;
 
 	if (isset_request_var('ostype')) {
 		$candidate = get_nfilter_request_var('ostype');
 
-		if (preg_match('/^[0-9]+$/', (string) $candidate)) {
-			$ostype = (int) $candidate;
+		if (preg_match('/^-?[0-9]+$/', (string) $candidate) && (int) $candidate >= -1) {
+			$ostype   = (int) $candidate;
+			$resolved = true;
 
 			if ((string) read_user_setting('hmib_summary_type', '') !== (string) $ostype) {
 				set_user_setting('hmib_summary_type', $ostype);
@@ -4808,20 +4811,21 @@ function hmib_summary_resolve_type(): int {
 		}
 	}
 
-	if ($ostype < 0) {
+	if (!$resolved) {
 		$stored = read_user_setting('hmib_summary_type', '');
-		$ostype = ($stored !== '' && preg_match('/^[0-9]+$/', (string) $stored)) ? (int) $stored : 0;
+		$ostype = ($stored !== '' && preg_match('/^-?[0-9]+$/', (string) $stored) && (int) $stored >= -1) ? (int) $stored : -1;
 	}
 
 	return $ostype;
 }
 
 /**
- * Memoized fleet system aggregates for an OS type scope (0 = all types). The
- * utilization statistics (cpu/mem/swap/processes/uptime) consider only up or
- * recovering devices so stale values from down devices do not skew them.
+ * Memoized fleet system aggregates for an OS type scope (-1 = all types, 0 =
+ * Unknown). The utilization statistics (cpu/mem/swap/processes/uptime) consider
+ * only up or recovering devices so stale values from down devices do not skew
+ * them.
  *
- * @param int $ostype The host_type to scope to, or 0 for all types.
+ * @param int $ostype The host_type to scope to; -1 for all types.
  *
  * @return array The aggregate row.
  */
@@ -4829,8 +4833,8 @@ function hmib_summary_stats(int $ostype): array {
 	static $cache = [];
 
 	if (!array_key_exists($ostype, $cache)) {
-		$where  = $ostype > 0 ? 'WHERE hrs.host_type = ?' : '';
-		$params = $ostype > 0 ? [$ostype] : [];
+		$where  = $ostype >= 0 ? 'WHERE hrs.host_type = ?' : '';
+		$params = $ostype >= 0 ? [$ostype] : [];
 
 		$row = db_fetch_row_prepared("SELECT
 			COUNT(*) AS devices,
@@ -4868,9 +4872,9 @@ function hmib_summary_stats(int $ostype): array {
 
 /**
  * Memoized fleet storage aggregates (per-volume used% distribution and total
- * capacity) for an OS type scope.
+ * capacity) for an OS type scope (-1 = all types, 0 = Unknown).
  *
- * @param int $ostype The host_type to scope to, or 0 for all types.
+ * @param int $ostype The host_type to scope to; -1 for all types.
  *
  * @return array The aggregate row.
  */
@@ -4878,8 +4882,8 @@ function hmib_summary_storage_stats(int $ostype): array {
 	static $cache = [];
 
 	if (!array_key_exists($ostype, $cache)) {
-		$where  = $ostype > 0 ? 'AND hrs.host_type = ?' : '';
-		$params = $ostype > 0 ? [$ostype] : [];
+		$where  = $ostype >= 0 ? 'AND hrs.host_type = ?' : '';
+		$params = $ostype >= 0 ? [$ostype] : [];
 
 		$row = db_fetch_row_prepared("SELECT
 			MIN(CASE WHEN host_status >= 2 THEN pct END) AS minPct,
@@ -5028,7 +5032,7 @@ function hmib_summary_card_state(string $key, int $ostype): string {
  * Render the inner body HTML of a single Fleet Dashboard card.
  *
  * @param string $key    The card identifier.
- * @param int    $ostype The host_type scope (0 = all types).
+ * @param int    $ostype The host_type scope (-1 = all types).
  *
  * @return string The card body HTML.
  */
@@ -5131,10 +5135,10 @@ function hmib_summary_card_body(string $key, int $ostype): string {
 			break;
 		case 'ostypes':
 			$unknown_label = __('Unknown', 'hmib');
-			$type_where    = $ostype > 0 ? 'WHERE hrs.host_type = ?' : '';
+			$type_where    = $ostype >= 0 ? 'WHERE hrs.host_type = ?' : '';
 			$type_params   = [$unknown_label];
 
-			if ($ostype > 0) {
+			if ($ostype >= 0) {
 				$type_params[] = $ostype;
 			}
 
@@ -5145,8 +5149,7 @@ function hmib_summary_card_body(string $key, int $ostype): string {
 				LEFT JOIN plugin_hmib_hrSystemTypes AS hrst ON hrs.host_type = hrst.id
 				$type_where
 				GROUP BY hrs.host_type
-				ORDER BY devices DESC
-				LIMIT 15", $type_params);
+				ORDER BY devices DESC", $type_params);
 
 			if (!cacti_sizeof($types)) {
 				print '<p class="hmibDashEmpty">' . __esc('No OS types recorded.', 'hmib') . '</p>';
@@ -5172,8 +5175,8 @@ function hmib_summary_card_body(string $key, int $ostype): string {
 		case 'top_cpu':
 		case 'top_memory':
 			$by_cpu = ($key === 'top_cpu');
-			$where  = $ostype > 0 ? 'AND hrs.host_type = ?' : '';
-			$params = $ostype > 0 ? [$ostype] : [];
+			$where  = $ostype >= 0 ? 'AND hrs.host_type = ?' : '';
+			$params = $ostype >= 0 ? [$ostype] : [];
 
 			$processes = db_fetch_assoc_prepared("SELECT hrswr.name AS name,
 				COUNT(DISTINCT hrswr.host_id) AS hosts,
@@ -5452,7 +5455,11 @@ function hmib_summary_dashboard(): void {
 	print '<div class="hmibDashToolbar">';
 	print '<label class="hmibDashToolbarLabel" for="hmib_summary_type">' . __esc('Scope', 'hmib') . '</label>';
 	print '<select id="hmib_summary_type" class="hmibDashAdd">';
-	print '<option value="0"' . ($ostype === 0 ? ' selected' : '') . '>' . __esc('All Types', 'hmib') . '</option>';
+	print '<option value="-1"' . ($ostype === -1 ? ' selected' : '') . '>' . __esc('All Types', 'hmib') . '</option>';
+
+	if (db_fetch_cell('SELECT COUNT(*) FROM plugin_hmib_hrSystem WHERE host_type = 0') > 0) {
+		print '<option value="0"' . ($ostype === 0 ? ' selected' : '') . '>' . __esc('Unknown', 'hmib') . '</option>';
+	}
 
 	$types = db_fetch_assoc("SELECT DISTINCT hrst.id, CONCAT_WS('', hrst.name, ' [', hrst.version, ']') AS name
 		FROM plugin_hmib_hrSystemTypes AS hrst
diff --git a/js/hmib_summary_dashboard.js b/js/hmib_summary_dashboard.js
index 53d0caf..cca1928 100644
--- a/js/hmib_summary_dashboard.js
+++ b/js/hmib_summary_dashboard.js
@@ -239,6 +239,13 @@ function hmibSumRefreshCard(grid, card, done) {
 			settle();
 			return;
 		}
+		// Use the card's CURRENT expanded state (the user may have toggled it while
+		// the request was in flight) rather than the snapshot sent with the request.
+		if (card.classList.contains('hmibDashCardExpanded')) {
+			fresh.classList.add('hmibDashCardExpanded');
+		} else {
+			fresh.classList.remove('hmibDashCardExpanded');
+		}
 		card.parentNode.replaceChild(fresh, card);
 		hmibSumBindCard(grid, fresh);
 		if (done) {
diff --git a/locales/po/cacti.pot b/locales/po/cacti.pot
index 46766aa..1928286 100644
--- a/locales/po/cacti.pot
+++ b/locales/po/cacti.pot
@@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: Cacti\n"
 "Report-Msgid-Bugs-To: developers@cacti.net\n"
-"POT-Creation-Date: 2026-10-10 17:26-0400\n"
+"POT-Creation-Date: 2026-10-10 17:47-0400\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: Cacti Developers <developers@cacti.net>\n"
 "Language-Team: Cacti Developers <developers@cacti.net>\n"

From f413bff480986c45441e90385cf50c4376847381 Mon Sep 17 00:00:00 2001
From: TheWitness <thewitness@cacti.net>
Date: Sat, 10 Oct 2026 17:58:27 -0400
Subject: [PATCH 4/5] fix(hmib): Fleet Dashboard scope grouping + AJAX scope
 persistence

- Summary 'Device Type Summary Statistics' now groups by hrs.host_type instead of name/version, so each row maps to a single host_type and its Fleet Dashboard glyph scopes to exactly that type (previously rows merging two OID mappings with the same name/version, e.g. shipped ids 11 and 12, passed one arbitrary id and omitted the rest).\n- hmib_summary_resolve_type() only persists the chosen scope on the main summary_dashboard navigation (new \ arg); summary_card AJAX refreshes resolve without saving, so an older tab's refresh can no longer overwrite another tab's remembered scope.
---
 hmib.php | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/hmib.php b/hmib.php
index 125886e..cfdf154 100644
--- a/hmib.php
+++ b/hmib.php
@@ -3228,7 +3228,7 @@ function clearHostFilter() {
 		FROM plugin_hmib_hrSystem AS hrs
 		LEFT JOIN plugin_hmib_hrSystemTypes AS hrst
 		ON hrs.host_type=hrst.id
-		GROUP BY name, version
+		GROUP BY hrs.host_type
 		$sql_order
 		$sql_limit";
 
@@ -4788,13 +4788,17 @@ function hmib_dashboard(): void {
 
 /**
  * Resolve the OS type the Fleet (Summary) Dashboard should scope to. A validated
- * 'ostype' request variable wins and is remembered. -1 = all types, 0 = Unknown
- * (untyped devices), a positive id = a specific OS type. Falls back to the
- * remembered scope, or -1 (all).
+ * 'ostype' request variable wins and, when $persist is set, is remembered. -1 =
+ * all types, 0 = Unknown (untyped devices), a positive id = a specific OS type.
+ * Falls back to the remembered scope, or -1 (all). Only the main navigation
+ * persists; AJAX card requests pass $persist = false so an older tab's refresh
+ * cannot overwrite another tab's remembered scope.
+ *
+ * @param bool $persist Whether a resolved request scope updates the saved preference.
  *
  * @return int The host_type scope: -1 (all), 0 (Unknown), or a positive type id.
  */
-function hmib_summary_resolve_type(): int {
+function hmib_summary_resolve_type(bool $persist = false): int {
 	$ostype   = -1;
 	$resolved = false;
 
@@ -4805,7 +4809,7 @@ function hmib_summary_resolve_type(): int {
 			$ostype   = (int) $candidate;
 			$resolved = true;
 
-			if ((string) read_user_setting('hmib_summary_type', '') !== (string) $ostype) {
+			if ($persist && (string) read_user_setting('hmib_summary_type', '') !== (string) $ostype) {
 				set_user_setting('hmib_summary_type', $ostype);
 			}
 		}
@@ -5430,7 +5434,7 @@ function hmib_summary_card_ajax(): string {
 function hmib_summary_dashboard(): void {
 	global $config, $page_refresh_interval;
 
-	$ostype = hmib_summary_resolve_type();
+	$ostype = hmib_summary_resolve_type(true);
 
 	$current_refresh = (int) read_user_setting('hmib_summary_refresh', 0);
 

From 0fe3f9e81c1686c38e3a5a62fe39900567c69232 Mon Sep 17 00:00:00 2001
From: TheWitness <thewitness@cacti.net>
Date: Sat, 10 Oct 2026 18:07:21 -0400
Subject: [PATCH 5/5] fix(hmib): Fleet Dashboard a11y + stale-scope handling

- resolve_type falls back to all-types when a remembered positive OS type no longer has any devices, so the picker (which lists only populated types) and the data stay consistent instead of showing empty cards mislabelled 'All Types'.\n- Card refresh preserves keyboard focus: if a tool button in the card was focused, focus moves to the same tool on the replacement node (refresh-all focuses a toolbar button outside the card and is unaffected).\n- Sortable headers keep their native columnheader role (dropped role=button) so aria-sort stays valid; tabindex + Enter/Space keydown already make them operable.
---
 hmib.php                     |  7 +++++++
 js/hmib_summary_dashboard.js | 14 +++++++++++++-
 2 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/hmib.php b/hmib.php
index cfdf154..81cb03a 100644
--- a/hmib.php
+++ b/hmib.php
@@ -4820,6 +4820,13 @@ function hmib_summary_resolve_type(bool $persist = false): int {
 		$ostype = ($stored !== '' && preg_match('/^-?[0-9]+$/', (string) $stored) && (int) $stored >= -1) ? (int) $stored : -1;
 	}
 
+	// A remembered positive type can become unselectable (its last device left, or
+	// an admin deleted the type); the picker only lists populated types, so fall
+	// back to all-types instead of silently showing an empty, mislabelled scope.
+	if ($ostype > 0 && db_fetch_cell_prepared('SELECT COUNT(*) FROM plugin_hmib_hrSystem WHERE host_type = ?', [$ostype]) == 0) {
+		$ostype = -1;
+	}
+
 	return $ostype;
 }
 
diff --git a/js/hmib_summary_dashboard.js b/js/hmib_summary_dashboard.js
index cca1928..0fdd262 100644
--- a/js/hmib_summary_dashboard.js
+++ b/js/hmib_summary_dashboard.js
@@ -246,7 +246,18 @@ function hmibSumRefreshCard(grid, card, done) {
 		} else {
 			fresh.classList.remove('hmibDashCardExpanded');
 		}
+		// Preserve keyboard focus: if a tool button in THIS card was focused, move
+		// focus to the same tool on the replacement. (Refresh-all focuses a toolbar
+		// button outside the card, so it is not captured here.)
+		var active = document.activeElement;
+		var focusedTool = (active && card.contains(active) && active.classList && active.classList.contains('hmibDashCardTool')) ? active.dataset.tool : null;
 		card.parentNode.replaceChild(fresh, card);
+		if (focusedTool) {
+			var toolEl = fresh.querySelector('.hmibDashCardTool[data-tool="' + focusedTool + '"]');
+			if (toolEl) {
+				toolEl.focus();
+			}
+		}
 		hmibSumBindCard(grid, fresh);
 		if (done) {
 			done();
@@ -313,7 +324,8 @@ function hmibSumPrepSortHeaders(container) {
 		if (!th.hasAttribute('tabindex')) {
 			th.setAttribute('tabindex', '0');
 		}
-		th.setAttribute('role', 'button');
+		// Keep the native columnheader role: aria-sort is only valid there, and the
+		// tabindex + Enter/Space keydown handler already makes it operable.
 		if (!th.hasAttribute('aria-sort')) {
 			th.setAttribute('aria-sort', 'none');
 		}